diff --git a/docs/bugbot/quality-observability.mdx b/docs/bugbot/quality-observability.mdx index c53b8c141..a9ad47ff4 100644 --- a/docs/bugbot/quality-observability.mdx +++ b/docs/bugbot/quality-observability.mdx @@ -967,6 +967,16 @@ waiting. Live progress remains informational. ### Qualification provenance +Treat scorer FP/FN labels separately from independently checked causal defects. +The [EV-07 failure audit](https://github.com/vypdev/copilot/issues/971) reproduces +the frozen current and prior negative results. Its eleven rejected category +matches contain detected hypotheses, rather than eleven absent hypotheses. +Every unmatched prediction and expectation retains an evidence row; unresolved +premises remain unresolved. Neither a taxonomy diagnostic nor a supported +fixture inconsistency changes a completed campaign's labels, calibration, +thresholds or qualification decision. A new campaign requires its own committed +implementation, driver and runtime identities. Production remains disabled. + The full-review qualification runner rederives the independent corpus score from the recorded predictions and checks the complete per-case ledger against the frozen plan, source, compiler configuration, CLI and invocation profile. A passing summary copied from another run cannot open full review. The CLI version must match before measured work starts. Historical campaigns remain reproducible from their preregistration commits with their original runner and rubric; stricter admission in a later revision does not rewrite their results. This local evaluation control adds no repository or organization setting and does not qualify a profile by itself. Freeze the implementation, lockfile, shipping compiler configuration and all eight evaluator driver hashes before measurement. The current runners reject diff --git a/quality/bugbot/evidence/issue-971/README.md b/quality/bugbot/evidence/issue-971/README.md new file mode 100644 index 000000000..40ead00ce --- /dev/null +++ b/quality/bugbot/evidence/issue-971/README.md @@ -0,0 +1,88 @@ +# EV-07 failure audit for #971 + +The frozen Luna/xhigh campaign remains **not qualified**. This audit reproduces its score, preserves every original label and gives all 17 unmatched predictions and 11 unmatched expectations an evidence row. It makes zero model calls and zero evaluated-PR writes. It does not start either a new corpus campaign or any of the 42 paired reviews. + +## Reproduced decisions + +| Input | Source | Precision | Recall | F1 | Brier | Original decision | +|---|---|---:|---:|---:|---:|---| +| Current complete ledger | `d26d0d6cd` | 80.2326% | 86.25% | 83.1325% | 0.1883116 | Failed precision, F1 and Brier | +| Recovered prior exact predictions | `03f8e6e3` | 87.9518% | 91.25% | 89.5706% | 0.1140651 | Failed precision | + +The current ledger is the unchanged `issue-950/ev07-shadow/campaign-provenance-attempts.jsonl`. Its score exactly equals the frozen campaign controls. The prior plan, predictions and score are copied unchanged from the retained local `copilot-951-ev07-final.KDBPKv` campaign, with their digests in this audit. Their reconstruction reproduces the published prior score. Local recovery alone is not an independent server timestamp attestation. + +The older archived `b12d0e9c` prediction fixture and its saved 75/80 score belong to a different campaign. They are not the prior `03f8e6e3` measurement. No archived passing fixture admits the proposed runtime or changes the two negative decisions above. Git blob checks confirm that `bugbot_benchmark.ts`, `bugbot_quality_eval.ts` and `finding_identity.ts` are byte-identical at `03f8e6e3`, `d26d0d6cd` and the audited merged tree. + +## What the score does and does not establish + +Eleven category mismatches account for **22 scorer rows**: one FP and one FN per case. The predicted hypotheses are present and describe the expected causal mechanisms. No completely absent hypothesis was found among these eleven FN rows. The remaining six predictions have empty frozen expectations: one exposes an independently supported defect in the supplied workflow fixture; five retain unresolved material premises or contract gaps. This does not prove six SDK defects or authorize changing labels. + +The unchanged Brier calculation contributes 0.1260604651 from the eleven taxonomy-mismatched predictions, 0.0113965116 from the malformed-workflow prediction, 0.0503139535 from the five unresolved predictions and 0.0005406977 from matched predictions. These sum to 0.1883116279. A scorer mismatch receives label zero even when an independent causal assessment supports the explanation. This diagnoses the arithmetic without producing an alternative qualifying score. + +Location and severity remain distinct. Rust, shell and membership-order predictions also disagree with frozen severity; the Kotlin cancellation location is one line away, and the unittest finding's ID contains an old line while its actual final `line` is 12. The aggregate category accuracy is calculated only among matched findings. It cannot independently establish category correctness for the eleven rejected matches. + +## Independent causal evidence + +- `observations.json` records immutable owned Node oracle executions for the bypassed stub, request-header value and both selected-token paths; a real shell archive control; fixed Python short-circuit observations; and the parsed workflow shape. No arbitrary corpus strings or consumer application source are executed. +- `unittest-observations.json` records actual CPython 3.14.6 discovery on fixed owned fixtures. The wrong directory runs one unrelated method and zero export methods; the passing controls run 19 methods including all five export methods. +- `kotlin-observations.json` records `kotlinc-jvm 2.4.10` on JRE 26.0.1 and `java -jar` executing the separate exception-mapping primitive on OpenJDK 21.0.11. The narrow catch propagates cancellation; the broad catch maps it to an ordinary error. It is not a JDBC or coroutine-scheduler measurement. +- Rust, viewport and synthetic upstream-Action cases retain their precise supplied source/contract proofs; this audit claims no Rust, browser/framework or native upstream Action execution. C# remains unresolved without the actual platform and acceptance contract. +- The root-level workflow `steps` observation is compared with [GitHub's official job-step syntax](https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps), checked on 2026-11-19. Read-only metadata access does not make a malformed workflow valid. No live workflow is dispatched for this control. + +## Complete per-error inventory + +The full machine rows, original finding IDs and SHA-256 bindings are in `score-and-rows.json`; `adjudications.json` contains the independently reviewable reasoning and next action. FP/FN below always name the unchanged scorer's result. + +| Case | Scorer row | Independent classification | Evidence and remaining boundary | +|---|---|---|---| +| `sql-bounded-query` | FP prediction #0 | unresolved | The prediction needs tied created_at values and a required stable boundary. The scenario calls the order deterministic, but supplies no schema or uniqueness constraint to establish or refute ties. The conditional SQL concern is not independently proven for the declared fixture. | +| `rust-unchecked-input` | FP prediction #0 | taxonomy-mismatch | The prediction identifies the supplied parse().unwrap() panic on malformed request input. The scorer rejects security versus reliability; the severity also differs (high versus medium). No Rust process was executed in this audit. | +| `rust-unchecked-input` | FN expected #0 | taxonomy-mismatch | The prediction identifies the supplied parse().unwrap() panic on malformed request input. The scorer rejects security versus reliability; the severity also differs (high versus medium). No Rust process was executed in this audit. | +| `actions-readonly-metadata` | FP prediction #0 | actual-causal-defect | The supplied added YAML has root-level steps and no jobs mapping. Read-only metadata access does not repair that workflow shape. The prediction identifies a causal defect in the supplied fixture, separately from the scorer's empty expectation. | +| `shell-unquoted-path` | FP prediction #0 | taxonomy-mismatch | The prediction identifies unquoted word splitting at the exact changed command. Its proposed -- and quoting repair also addresses option interpretation. The frozen security expectation differs from correctness and high differs from medium. | +| `shell-unquoted-path` | FN expected #0 | taxonomy-mismatch | The prediction identifies unquoted word splitting at the exact changed command. Its proposed -- and quoting repair also addresses option interpretation. The frozen security expectation differs from correctness and high differs from medium. | +| `react-complete-dependencies` | FP prediction #0 | unresolved | The stale-response hypothesis is possible for an asynchronous loader, but the fixture supplies no loadUser implementation, scheduling guarantee, cleanup elsewhere, or interaction witness. Complete dependencies alone neither proves nor refutes that separate hypothesis. | +| `csharp-contained-path` | FP prediction #0 | unresolved | The prediction assumes Windows case-insensitive path resolution and a requirement to accept differently cased contained paths. Neither supported OS/filesystem policy nor that acceptance requirement is supplied. No .NET/Windows execution is available in this audit. | +| `py-coverage-config-branch` | FP prediction #0 | unresolved | coverage run collects data while reporting applies fail_under, but the excerpt does not prove the complete job has no report step or that this change promises threshold enforcement. The separate threshold hypothesis cannot be resolved from this fragment alone. | +| `py-short-circuit-unhashable` | FP prediction #0 | unresolved | A fixed Python control proves a mapping with an allowed string key returns True. The prediction additionally requires the whole issue_steps value to be an array; the scenario describes arbitrary persisted JSON but does not specify that container-shape contract. The concrete behavior is proven; whether it violates the intended contract remains unresolved. | +| `py-short-circuit-unsafe-order` | FP prediction #0 | taxonomy-mismatch | Membership runs before isinstance. A list/dict step reaches set membership and raises TypeError; the prediction describes that exact path. Reliability differs from the frozen correctness label, and severity differs. | +| `py-short-circuit-unsafe-order` | FN expected #0 | taxonomy-mismatch | Membership runs before isinstance. A list/dict step reaches set membership and raises TypeError; the prediction describes that exact path. Reliability differs from the frozen correctness label, and severity differs. | +| `ts-viewport-version-without-cleanup` | FP prediction #0 | taxonomy-mismatch | The pinned 1.0 mount appends a child and preserves the loader; the removed caller cleanup is the missing operation. The prediction follows that same version and path. Reliability differs from correctness. | +| `ts-viewport-version-without-cleanup` | FN expected #0 | taxonomy-mismatch | The pinned 1.0 mount appends a child and preserves the loader; the removed caller cleanup is the missing operation. The prediction follows that same version and path. Reliability differs from correctness. | +| `kt-broad-catch-swallows-cancellation` | FP prediction #0 | taxonomy-mismatch | The scenario requires cancellation propagation and supplies no other guard. The new Throwable catch wraps that cancellation in DatabaseException/Left. The prediction identifies this same cause; reliability differs from correctness. It also reports line 5 rather than frozen line 4. | +| `kt-broad-catch-swallows-cancellation` | FN expected #0 | taxonomy-mismatch | The scenario requires cancellation propagation and supplies no other guard. The new Throwable catch wraps that cancellation in DatabaseException/Left. The prediction identifies this same cause; reliability differs from correctness. It also reports line 5 rather than frozen line 4. | +| `test-delegate-bypasses-stub` | FP prediction #0 | taxonomy-mismatch | The public reader returns right(row) and never invokes bindSession. The new assertion therefore fails with zero participant-projection calls. The prediction describes this exact route; reliability differs from correctness. | +| `test-delegate-bypasses-stub` | FN expected #0 | taxonomy-mismatch | The public reader returns right(row) and never invokes bindSession. The new assertion therefore fails with zero participant-projection calls. The prediction describes this exact route; reliability differs from correctness. | +| `action-old-input-on-new-version` | FP prediction #0 | taxonomy-mismatch | The selected revision reads enable-problem-matcher; the added problem-matcher belongs to the older revision. The default remains enabled and the supplied absent-asset contract fails registration. Correctness differs from reliability. | +| `action-old-input-on-new-version` | FN expected #0 | taxonomy-mismatch | The selected revision reads enable-problem-matcher; the added problem-matcher belongs to the older revision. The default remains enabled and the supplied absent-asset contract fails registration. Correctness differs from reliability. | +| `request-transform-write` | FP prediction #0 | taxonomy-mismatch | The real authored request path emits no-cache, preserves it, and reaches a test requiring no-store. The prediction identifies that actual value and failure; security differs from correctness. | +| `request-transform-write` | FN expected #0 | taxonomy-mismatch | The real authored request path emits no-cache, preserves it, and reaches a test requiring no-store. The prediction identifies that actual value and failure; security differs from correctness. | +| `session-source-opaque-bootstrap` | FP prediction #0 | taxonomy-mismatch | Configured opaque.setup.ts persists the opaque token and its future expiry skips refresh. The compact-token assertion fails on that selected token. Reliability differs from correctness. | +| `session-source-opaque-bootstrap` | FN expected #0 | taxonomy-mismatch | Configured opaque.setup.ts persists the opaque token and its future expiry skips refresh. The compact-token assertion fails on that selected token. Reliability differs from correctness. | +| `session-source-expired-refresh` | FP prediction #0 | taxonomy-mismatch | The selected signed session expires before the fixed clock; the actual refresh response supplies an opaque token. The prediction follows that replacement and failed assertion. Reliability differs from correctness. | +| `session-source-expired-refresh` | FN expected #0 | taxonomy-mismatch | The selected signed session expires before the fixed clock; the actual refresh response supplies an opaque token. The prediction follows that replacement and failed assertion. Reliability differs from correctness. | +| `unittest-discovery-wrong-start-directory` | FP prediction #0 | taxonomy-mismatch | The selected start directory runs the unrelated health method and excludes both required manifest modules. The prediction explains that same actual selection. Reliability differs from correctness; the final location is the expected line 12 despite a stale line-9 string in its ID. | +| `unittest-discovery-wrong-start-directory` | FN expected #0 | taxonomy-mismatch | The selected start directory runs the unrelated health method and excludes both required manifest modules. The prediction explains that same actual selection. Reliability differs from correctness; the final location is the expected line 12 despite a stale line-9 string in its ID. | + +## Corrections and existing work + +There is no supported general prompt rewrite or automatic category normalization in this audit. The eleven causal explanations cannot be rejected merely to match the scorer. Any new taxonomy proposal needs its own reviewed rationale, new version and preregistration; neither labels nor thresholds of either executed campaign change. + +The malformed metadata workflow merits a narrow fixture/rubric review. Preserve the current 174-case corpus and completed campaigns; any future correction must be versioned and separately preregistered. The five unresolved cases need the exact missing evidence listed in `adjudications.json`, rather than speculative production patches. + +Existing #954 (observer convergence), #963 (ECMAScript end anchors) and #966 (consumer release-tag policy) were read with their current comments. None is a demonstrated cause of these 17 discrepancies. They retain their independent scope and are not duplicated or declared fixed by this audit. All 27 original #950 records remain in the unchanged traceability matrix. + +## Reproduction and limits + +```sh +node --test quality/bugbot/evidence/issue-971/audit.test.cjs +node quality/bugbot/evidence/issue-971/audit.cjs /tmp/new-971-audit.json +node quality/bugbot/evidence/issue-971/observe.cjs /tmp/new-971-observations.json +python3 src/tooling/__tests__/fixtures/bugbot_unittest_discovery_probe.py --output /tmp/new-971-unittest.json +kotlinc quality/bugbot/evidence/issue-971/cancellation-probe.kt -include-runtime -d /tmp/new-971-cancellation.jar +java -jar /tmp/new-971-cancellation.jar +``` + +Use a fresh destination. The audit script refuses to overwrite an existing output. The three deterministic scoring controls reproduce current and prior decisions and show that a diagnostic category change cannot rewrite the frozen campaign. Node oracle and native primitive observations are separate causal evidence, never model input or qualification. + +No new profile is qualified. #974 still requires the merged deterministic prerequisites, any independently justified corrections, and a committed exact implementation/driver/runtime preregistration. #975 requires an actually passing corpus on identical pins. Production remains `BUGBOT_VERIFICATION_MODE=disabled`; evaluated-PR write attempts remain zero. diff --git a/quality/bugbot/evidence/issue-971/adjudications.json b/quality/bugbot/evidence/issue-971/adjudications.json new file mode 100644 index 000000000..baa99d109 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/adjudications.json @@ -0,0 +1,172 @@ +[ + { + "case": "rust-unchecked-input", + "classification": "taxonomy-mismatch", + "reason": "The prediction identifies the supplied parse().unwrap() panic on malformed request input. The scorer rejects security versus reliability; the severity also differs (high versus medium). No Rust process was executed in this audit.", + "evidence": [ + "Supplied request-controlled parse/unwrap line and the scenario's explicit service-panic contract." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "shell-unquoted-path", + "classification": "taxonomy-mismatch", + "reason": "The prediction identifies unquoted word splitting at the exact changed command. Its proposed -- and quoting repair also addresses option interpretation. The frozen security expectation differs from correctness and high differs from medium.", + "evidence": [ + "Fixed shell archive reproduction; original command and unchanged expected security taxonomy." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "py-short-circuit-unsafe-order", + "classification": "taxonomy-mismatch", + "reason": "Membership runs before isinstance. A list/dict step reaches set membership and raises TypeError; the prediction describes that exact path. Reliability differs from the frozen correctness label, and severity differs.", + "evidence": [ + "Fixed Python short-circuit control; supplied expression order." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "ts-viewport-version-without-cleanup", + "classification": "taxonomy-mismatch", + "reason": "The pinned 1.0 mount appends a child and preserves the loader; the removed caller cleanup is the missing operation. The prediction follows that same version and path. Reliability differs from correctness.", + "evidence": [ + "Supplied immutable 1.0 mount source and index.html; no framework/browser execution is claimed." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "kt-broad-catch-swallows-cancellation", + "classification": "taxonomy-mismatch", + "reason": "The scenario requires cancellation propagation and supplies no other guard. The new Throwable catch wraps that cancellation in DatabaseException/Left. The prediction identifies this same cause; reliability differs from correctness. It also reports line 5 rather than frozen line 4.", + "evidence": [ + "Separately authored Kotlin CancellationException mapping control; supplied try/catch and cancellation contract." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "test-delegate-bypasses-stub", + "classification": "taxonomy-mismatch", + "reason": "The public reader returns right(row) and never invokes bindSession. The new assertion therefore fails with zero participant-projection calls. The prediction describes this exact route; reliability differs from correctness.", + "evidence": [ + "observeCallPathFixture on its immutable owned fixture, independently of model output." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "action-old-input-on-new-version", + "classification": "taxonomy-mismatch", + "reason": "The selected revision reads enable-problem-matcher; the added problem-matcher belongs to the older revision. The default remains enabled and the supplied absent-asset contract fails registration. Correctness differs from reliability.", + "evidence": [ + "Supplied exact-revision manifest/runtime contract; this synthetic Action is not executed on GitHub." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "request-transform-write", + "classification": "taxonomy-mismatch", + "reason": "The real authored request path emits no-cache, preserves it, and reaches a test requiring no-store. The prediction identifies that actual value and failure; security differs from correctness.", + "evidence": [ + "observeRequestTransform on the immutable owned write-policy fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "session-source-opaque-bootstrap", + "classification": "taxonomy-mismatch", + "reason": "Configured opaque.setup.ts persists the opaque token and its future expiry skips refresh. The compact-token assertion fails on that selected token. Reliability differs from correctness.", + "evidence": [ + "observeInitialSessionSource with real Node HMAC/base64url and the immutable owned opaque fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "session-source-expired-refresh", + "classification": "taxonomy-mismatch", + "reason": "The selected signed session expires before the fixed clock; the actual refresh response supplies an opaque token. The prediction follows that replacement and failed assertion. Reliability differs from correctness.", + "evidence": [ + "observeInitialSessionSource with real Node HMAC/base64url and the immutable owned expired fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "unittest-discovery-wrong-start-directory", + "classification": "taxonomy-mismatch", + "reason": "The selected start directory runs the unrelated health method and excludes both required manifest modules. The prediction explains that same actual selection. Reliability differs from correctness; the final location is the expected line 12 despite a stale line-9 string in its ID.", + "evidence": [ + "Actual fixed owned Python unittest discovery: 1 health method, 0 export methods; passing control runs 19 methods including 5 export methods." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "sql-bounded-query", + "classification": "unresolved", + "reason": "The prediction needs tied created_at values and a required stable boundary. The scenario calls the order deterministic, but supplies no schema or uniqueness constraint to establish or refute ties. The conditional SQL concern is not independently proven for the declared fixture.", + "evidence": [ + "No schema or tie witness is supplied; expected=[] is a scorer label, not independent proof." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Obtain the authored schema/ordering contract before proposing either a detector change or a corpus correction." + }, + { + "case": "actions-readonly-metadata", + "classification": "actual-causal-defect", + "reason": "The supplied added YAML has root-level steps and no jobs mapping. Read-only metadata access does not repair that workflow shape. The prediction identifies a causal defect in the supplied fixture, separately from the scorer's empty expectation.", + "evidence": [ + "Parsed YAML structure; GitHub workflow syntax places steps under jobs..steps (official documentation checked 2026-11-19)." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Submit the fixture/rubric inconsistency for separate review; do not relabel this completed campaign or suppress a supported workflow finding." + }, + { + "case": "react-complete-dependencies", + "classification": "unresolved", + "reason": "The stale-response hypothesis is possible for an asynchronous loader, but the fixture supplies no loadUser implementation, scheduling guarantee, cleanup elsewhere, or interaction witness. Complete dependencies alone neither proves nor refutes that separate hypothesis.", + "evidence": [ + "Only the three-line effect and its dependency intent are supplied; the actual loader contract is missing." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Request a frozen loader/interaction witness. Do not infer a production prompt defect solely from expected=[]." + }, + { + "case": "csharp-contained-path", + "classification": "unresolved", + "reason": "The prediction assumes Windows case-insensitive path resolution and a requirement to accept differently cased contained paths. Neither supported OS/filesystem policy nor that acceptance requirement is supplied. No .NET/Windows execution is available in this audit.", + "evidence": [ + "Supplied ordinal containment check; absent target-platform and alternate-spelling contract." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Keep the platform premise unresolved; obtain the actual supported filesystem contract before a narrow correction." + }, + { + "case": "py-coverage-config-branch", + "classification": "unresolved", + "reason": "coverage run collects data while reporting applies fail_under, but the excerpt does not prove the complete job has no report step or that this change promises threshold enforcement. The separate threshold hypothesis cannot be resolved from this fragment alone.", + "evidence": [ + "Supplied coverage command/configuration; no complete job or version-matched reporting observation." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Inspect the complete authored job and reporting requirement; retain the scorer FP without inventing a confirmed missed threshold defect." + }, + { + "case": "py-short-circuit-unhashable", + "classification": "unresolved", + "reason": "A fixed Python control proves a mapping with an allowed string key returns True. The prediction additionally requires the whole issue_steps value to be an array; the scenario describes arbitrary persisted JSON but does not specify that container-shape contract. The concrete behavior is proven; whether it violates the intended contract remains unresolved.", + "evidence": [ + "Fixed Python mapping/list/short-circuit observations, with no consumer execution." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Obtain the checkpoint container-shape requirement. Only then propose a narrow boundary or corpus follow-up." + } +] diff --git a/quality/bugbot/evidence/issue-971/audit.cjs b/quality/bugbot/evidence/issue-971/audit.cjs new file mode 100644 index 000000000..a0d17c435 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/audit.cjs @@ -0,0 +1,75 @@ +'use strict'; + +const assert = require('node:assert/strict'); +const { createHash } = require('node:crypto'); +const fs = require('node:fs'); +const path = require('node:path'); +const root = path.resolve(__dirname, '../../../..'); +const api = require(path.join(root, 'build/api/index.js')); +const currentDirectory = path.join(root, 'quality/bugbot/evidence/issue-950/ev07-shadow'); +const digest = bytes => createHash('sha256').update(bytes).digest('hex'); +const read = file => JSON.parse(fs.readFileSync(file, 'utf8')); + +async function audit() { + const corpusFile = path.join(root, 'quality/bugbot/corpus.v1.json'); + const corpus = await api.loadBugbotBenchmark(corpusFile); + const ledgerFile = path.join(currentDirectory, 'campaign-provenance-attempts.jsonl'); + const ledger = fs.readFileSync(ledgerFile, 'utf8').trim().split('\n').map(JSON.parse); + const controls = read(path.join(currentDirectory, 'campaign-provenance-controls.json')); + const starts = ledger.filter(row => row.event === 'start'); + assert.equal(starts.length, 1); + assert.equal(starts[0].implementation, controls.implementation); + assert.equal(digest(fs.readFileSync(ledgerFile)), controls.artifactHashes['corpus-v3/corpus.jsonl']); + const cases = ledger.filter(row => row.event === 'case'); + assert.equal(cases.length, 174); + assert.equal(new Set(cases.map(row => row.id)).size, 174); + assert(cases.every(row => row.status === 'completed')); + const predictions = { schemaVersion: 1, predictions: Object.fromEntries(cases.map(row => [row.id, row.predictions])) }; + const score = api.evaluateBugbotBenchmark(corpus, predictions); + assert.deepEqual(score, controls.corpusScore.score); + const prior = read(path.join(__dirname, 'prior-03f8e6e3-predictions.json')); + const priorStart = read(path.join(__dirname, 'prior-03f8e6e3-start.json')); + const priorPlanFile = path.join(__dirname, 'prior-03f8e6e3-plan.json'); + assert.equal(priorStart.implementation, read(priorPlanFile).implementation); + assert.equal(priorStart.plan, digest(fs.readFileSync(priorPlanFile))); + const priorScore = api.evaluateBugbotBenchmark(corpus, prior); + assert.deepEqual(priorScore, read(path.join(__dirname, 'prior-03f8e6e3-score.json')).score); + const adjudications = read(path.join(__dirname, 'adjudications.json')); + const rows = []; + for (const item of corpus.cases) { + const measured = predictions.predictions[item.id]; + const result = api.evaluateBugbotBenchmark({ ...corpus, cases: [item] }, predictions); + if (!result.metrics.falsePositives && !result.metrics.falseNegatives) continue; + const judgment = adjudications.find(entry => entry.case === item.id); + assert(judgment, 'missing independent audit row: ' + item.id); + assert(judgment.reason && judgment.evidence.length && judgment.nextAction); + // Every discrepancy in this frozen campaign is one unmatched prediction, + // optionally paired with one unmatched expectation. Reject inventory drift. + assert.equal(result.metrics.matched, 0); + assert.equal(result.metrics.falsePositives, measured.length); + assert.equal(result.metrics.falseNegatives, item.expected.length); + for (const [kind, findings] of [['prediction', measured], ['expected', item.expected]]) { + findings.forEach((finding, index) => rows.push({ case: item.id, kind, index, + scorerLabel: kind === 'prediction' ? 'FP' : 'FN', id: finding.id, + findingSha256: digest(JSON.stringify(finding)), ...judgment })); + } + } + assert.equal(rows.filter(row => row.kind === 'prediction').length, 17); + assert.equal(rows.filter(row => row.kind === 'expected').length, 11); + assert.equal(adjudications.length, new Set(rows.map(row => row.case)).size); + return { schemaVersion: 1, method: 'unchanged public evaluator; independent causal assessments remain separate', + implementation: starts[0].implementation, priorImplementation: priorStart.implementation, + corpusSha256: digest(fs.readFileSync(corpusFile)), currentLedgerSha256: digest(fs.readFileSync(ledgerFile)), + priorPredictionsSha256: digest(fs.readFileSync(path.join(__dirname, 'prior-03f8e6e3-predictions.json'))), + score, priorScore, rows, modelCalls: 0, evaluatedPrWriteAttempts: 0, + qualification: 'not-qualified; no score, label, threshold, prompt or campaign was changed' }; +} + +if (require.main === module) audit().then(result => { + const output = process.argv[2]; + if (output) fs.writeFileSync(output, JSON.stringify(result, null, 2) + '\n', { flag: 'wx' }); + console.log(JSON.stringify({ current: result.score, prior: result.priorScore, rows: result.rows.length, + modelCalls: 0, evaluatedPrWriteAttempts: 0 }, null, 2)); +}).catch(error => { console.error(error); process.exitCode = 1; }); + +module.exports = { audit }; diff --git a/quality/bugbot/evidence/issue-971/audit.test.cjs b/quality/bugbot/evidence/issue-971/audit.test.cjs new file mode 100644 index 000000000..9d6eed4a7 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/audit.test.cjs @@ -0,0 +1,43 @@ +'use strict'; + +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { test } = require('node:test'); +const { audit } = require('./audit.cjs'); +const root = path.resolve(__dirname, '../../../..'); +const api = require(path.join(root, 'build/api/index.js')); + +test('reproduces all frozen current scores and gives every 17 FP and 11 FN an independent row', async () => { + const result = await audit(); + assert.equal(result.score.metrics.matched, 69); + assert.equal(result.score.violations.length, 3); + assert.equal(result.rows.length, 28); + assert.equal(result.rows.filter(row => row.classification === 'taxonomy-mismatch').length, 22); + assert.equal(result.modelCalls, 0); + assert.equal(result.evaluatedPrWriteAttempts, 0); +}); + +test('reproduces the exact prior 03f8e6e3 predictions under the identical original rubric', async () => { + const result = await audit(); + assert.equal(result.priorScore.metrics.matched, 73); + assert.equal(result.priorScore.metrics.falsePositives, 10); + assert.equal(result.priorScore.metrics.falseNegatives, 7); + assert.deepEqual(result.priorScore.violations, ['precision 0.880 is below 0.900']); +}); + +test('a diagnostic category change cannot retrospectively pass or rewrite the frozen campaign', async () => { + const before = await audit(); + const corpus = await api.loadBugbotBenchmark(path.join(root, 'quality/bugbot/corpus.v1.json')); + const item = corpus.cases.find(row => row.id === 'request-transform-write'); + const ledger = fs.readFileSync(path.join(__dirname, '../issue-950/ev07-shadow/campaign-provenance-attempts.jsonl'), 'utf8') + .trim().split('\n').map(JSON.parse); + const finding = ledger.find(row => row.id === item.id).predictions[0]; + const score = prediction => api.evaluateBugbotBenchmark({ ...corpus, cases: [item] }, + { schemaVersion: 1, predictions: { [item.id]: [prediction] } }); + assert.equal(score(finding).metrics.matched, 0); + assert.equal(score({ ...finding, category: item.expected[0].category }).metrics.matched, 1); + const after = await audit(); + assert.deepEqual(after, before); + assert.equal(after.qualification.startsWith('not-qualified'), true); +}); diff --git a/quality/bugbot/evidence/issue-971/cancellation-probe.kt b/quality/bugbot/evidence/issue-971/cancellation-probe.kt new file mode 100644 index 000000000..d2fd88f59 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/cancellation-probe.kt @@ -0,0 +1,21 @@ +// Owned exception-mapping primitive; no consumer, JDBC or coroutine scheduler runs. +import java.sql.SQLException +import kotlin.coroutines.cancellation.CancellationException + +fun narrow(): String = try { + throw CancellationException("owned cancellation") +} catch (failure: SQLException) { + "database-error" +} + +fun broad(): String = try { + throw CancellationException("owned cancellation") +} catch (failure: Throwable) { + "database-error" +} + +fun main() { + val propagated = try { narrow(); false } catch (failure: CancellationException) { true } + check(propagated && broad() == "database-error") + println("{\"narrowPropagates\":true,\"broadMapsCancellationToDatabaseError\":true}") +} diff --git a/quality/bugbot/evidence/issue-971/kotlin-observations.json b/quality/bugbot/evidence/issue-971/kotlin-observations.json new file mode 100644 index 000000000..d334cb3f6 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/kotlin-observations.json @@ -0,0 +1,13 @@ +{ + "date": "2026-11-19", + "compiler": "info: kotlinc-jvm 2.4.10 (JRE 26.0.1)", + "java": "openjdk version \"21.0.11\" 2026-04-21\nOpenJDK Runtime Environment JBR-21.0.11+10-1163.116-nomod (build 21.0.11+10-b1163.116)\nOpenJDK 64-Bit Server VM JBR-21.0.11+10-1163.116-nomod (build 21.0.11+10-b1163.116, mixed mode, sharing)", + "sourceSha256": "d15d5cb6a1acda155abe74752530ed909c8675177067fbe708b629600db3594b", + "observation": { + "narrowPropagates": true, + "broadMapsCancellationToDatabaseError": true + }, + "scope": "separately authored exception mapping primitive; no JDBC, consumer or coroutine scheduler execution", + "modelCalls": 0, + "evaluatedPrWriteAttempts": 0 +} diff --git a/quality/bugbot/evidence/issue-971/observations.json b/quality/bugbot/evidence/issue-971/observations.json new file mode 100644 index 000000000..2d7e979d2 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/observations.json @@ -0,0 +1,68 @@ +{ + "node": "v24.20.0", + "method": "immutable owned oracles and separately authored primitives; no consumer execution", + "sources": { + "bugbot_call_path_oracles.ts": "c5f247d9783fcba2f5edcf74cf4300d36d906d20fa29567492245ff4d007cbe6", + "bugbot_request_transform_oracles.ts": "1657b1b19c5c6deb365f0d93ead363aa19b65c267b803ef23ab27f73a38ea896", + "bugbot_initial_session_oracles.ts": "e171b5936d28bc554a44b5133b9e3105ec031e606f12eebd2835cc1b5087402f" + }, + "observations": { + "test-delegate-bypasses-stub": { + "passes": false, + "calls": 0 + }, + "request-transform-write": { + "kind": "observed", + "headers": [ + "no-cache", + "no-cache", + "no-cache" + ], + "mockHeaders": [ + "no-cache", + "no-cache", + "no-cache" + ], + "producerCalls": 3, + "productionHeaderPasses": false, + "testHeaderPasses": false, + "validUtf8": true + }, + "session-source-opaque-bootstrap": { + "kind": "observed", + "setup": "opaque.setup.ts", + "tokenEndpointCalls": 1, + "initialSegments": 1, + "selectedSegments": 1, + "assertionPassed": false + }, + "session-source-expired-refresh": { + "kind": "observed", + "setup": "signed.setup.ts", + "tokenEndpointCalls": 1, + "initialSegments": 3, + "selectedSegments": 1, + "assertionPassed": false + }, + "python": { + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "nested_list_rejected": true, + "mapping_container_accepted": true, + "membership_first_failure": "TypeError", + "container_contract": "not supplied; acceptance alone does not prove a defect" + }, + "actions-readonly-metadata": { + "rootSteps": 1, + "jobsPresent": false, + "contract": "https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps", + "scope": "parsed supplied fragment and official syntax; no native GitHub run" + }, + "shell-unquoted-path": { + "unquotedExit": 1, + "quotedExit": 0, + "archived": "owned dir/source file.txt" + } + }, + "modelCalls": 0, + "evaluatedPrWriteAttempts": 0 +} diff --git a/quality/bugbot/evidence/issue-971/observe.cjs b/quality/bugbot/evidence/issue-971/observe.cjs new file mode 100644 index 000000000..125859dd2 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/observe.cjs @@ -0,0 +1,53 @@ +'use strict'; + +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { execFileSync, spawnSync } = require('node:child_process'); +const { createHash } = require('node:crypto'); +const { tmpdir } = require('node:os'); +const root = path.resolve(__dirname, '../../../..'); +require('../issue-950/ev07-shadow/load.cjs'); +const fixture = name => require(path.join(root, 'src/tooling/__tests__/fixtures', name)); +const corpus = JSON.parse(fs.readFileSync(path.join(root, 'quality/bugbot/corpus.v1.json'))); +const item = id => corpus.cases.find(row => row.id === id); +const { observeCallPathFixture } = fixture('bugbot_call_path_oracles'); +const { observeRequestTransform } = fixture('bugbot_request_transform_oracles'); +const { observeInitialSessionSource } = fixture('bugbot_initial_session_oracles'); +const observations = { + 'test-delegate-bypasses-stub': observeCallPathFixture(item('test-delegate-bypasses-stub')), + 'request-transform-write': observeRequestTransform(item('request-transform-write')), + 'session-source-opaque-bootstrap': observeInitialSessionSource(item('session-source-opaque-bootstrap')), + 'session-source-expired-refresh': observeInitialSessionSource(item('session-source-expired-refresh')), +}; +assert.deepEqual(observations['test-delegate-bypasses-stub'], { passes: false, calls: 0 }); +assert.equal(observations['request-transform-write'].productionHeaderPasses, false); +assert.equal(observations['session-source-opaque-bootstrap'].assertionPassed, false); +assert.equal(observations['session-source-expired-refresh'].assertionPassed, false); + +// Authored primitive controls; never execute arbitrary corpus or consumer text. +const python = execFileSync('python3', [path.join(__dirname, 'short-circuit-probe.py')], { encoding: 'utf8' }); +observations.python = JSON.parse(python); +const workflow = require('js-yaml').load(item('actions-readonly-metadata').diff.split('\n').map(line => line.slice(1)).join('\n')); +assert(Array.isArray(workflow.steps) && workflow.jobs === undefined); +observations['actions-readonly-metadata'] = { rootSteps: workflow.steps.length, jobsPresent: false, + contract: 'https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps', + scope: 'parsed supplied fragment and official syntax; no native GitHub run' }; +const directory = fs.mkdtempSync(path.join(tmpdir(), 'bugbot-971-shell-')); +try { + fs.mkdirSync(path.join(directory, 'owned dir')); + fs.writeFileSync(path.join(directory, 'owned dir/source file.txt'), 'owned fixture'); + const env = { PATH: '/usr/bin:/bin', UPLOAD_PATH: 'owned dir/source file.txt' }; + const unsafe = spawnSync('/bin/sh', ['-c', 'tar -czf backup.tgz $UPLOAD_PATH'], { cwd: directory, env, encoding: 'utf8' }); + const quoted = spawnSync('/bin/sh', ['-c', 'tar -czf fixed.tgz -- "$UPLOAD_PATH"'], { cwd: directory, env, encoding: 'utf8' }); + assert.notEqual(unsafe.status, 0); assert.equal(quoted.status, 0, quoted.stderr); + observations['shell-unquoted-path'] = { unquotedExit: unsafe.status, quotedExit: quoted.status, + archived: execFileSync('/usr/bin/tar', ['-tzf', 'fixed.tgz'], { cwd: directory, encoding: 'utf8' }).trim() }; +} finally { fs.rmSync(directory, { recursive: true, force: true }); } +const sources = ['bugbot_call_path_oracles.ts', 'bugbot_request_transform_oracles.ts', 'bugbot_initial_session_oracles.ts']; +const result = { node: process.version, method: 'immutable owned oracles and separately authored primitives; no consumer execution', + sources: Object.fromEntries(sources.map(file => [file, createHash('sha256') + .update(fs.readFileSync(path.join(root, 'src/tooling/__tests__/fixtures', file))).digest('hex')])), + observations, modelCalls: 0, evaluatedPrWriteAttempts: 0 }; +if (process.argv[2]) fs.writeFileSync(process.argv[2], JSON.stringify(result, null, 2) + '\n', { flag: 'wx' }); +console.log(JSON.stringify(result, null, 2)); diff --git a/quality/bugbot/evidence/issue-971/prior-03f8e6e3-plan.json b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-plan.json new file mode 100644 index 000000000..52d7c6d9d --- /dev/null +++ b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-plan.json @@ -0,0 +1,86 @@ +{ + "schemaVersion": 1, + "implementation": "03f8e6e33047333797ea37ad5e85bc756db223fa", + "mode": "shadow", + "publication": "dry-run", + "production": "disabled", + "detector": { + "provider": "codex", + "modelProvider": "openai", + "model": "gpt-6-luna", + "effort": "xhigh" + }, + "verifier": { + "provider": "codex", + "modelProvider": "openai", + "model": "gpt-6.1-sol", + "effort": "xhigh" + }, + "evidence": "installed exact Git head and permitted base, official release catalog, matching native CI step metadata", + "repositoryCohort": { + "manifestSha256": "dab7d62b0419c2da63eae3387be6222e77c114ed32b22dc9a2a9af35fb6afe85", + "oracleSha256": "c79302cb376519f60d69e0a080cd65dc29ff35ab256ce17b0e4b218fe69e239a", + "order": [ + "U1", + "U2", + "F1", + "F2", + "S1", + "S2", + "X1", + "X2", + "M1", + "M2", + "P1", + "P2", + "J1", + "J2" + ], + "repetitions": 3, + "baselineMinimumAlerts": 3, + "baselineMinimumPremises": 2, + "minimumStrictlyBetterRepetitions": 2, + "maximumAddedP95Ms": 90000, + "requireAllExactPositiveControls": true + }, + "corpus": { + "sha256": "640c3355aeb65c1b15454bd7f9242fa36acc12b8b3f5ef284ee06af8af36c6c6", + "cases": 174, + "concurrency": 6, + "outerAttemptsPerCase": 1, + "gates": { + "precision": 0.9, + "recall": 0.85, + "f1": 0.87, + "exactLocation": 0.8, + "severity": 0.8, + "category": 0.8, + "maxBrier": 0.16 + } + }, + "sourceTree": "a349b2c1271a326f8dae64ef26de8f0f9c890d22", + "frozenAt": "2026-11-18T05:18:51.328Z", + "runtime": { + "codex": "codex-cli 0.169.1", + "node": "v24.20.0", + "git": "git version 2.54.0 (Apple Git-157)", + "python": "Python 3.14.6", + "sqlite": "3.53.3\n2026-06-26 20:14:12 d4c0e51e4aeb96955b99185ab9cde75c339e2c29c3f3f12428d364a10d782c62", + "transpilationTarget": "ES2020" + }, + "inspectedArtifacts": { + "review": "0a77da33d7a4c021c394075773a8d39f1be88b37930105eca98ded5bf8604fd6", + "corpus": "728e8c6dcd5e6c771d99db471d46284e5364c70977fc645e0ac86f5c6345d95a", + "scheduler": "d9eb8a42ab966af183a00451e6926ef2283e2fece9d05e2b7d47ac8bda64149a", + "launcher": "e7be56f70ac324de14d963d6e6875e5615bfc6d10adb0fcde654aef450ab91d2", + "scorer": "a4ad32cfdfc90492ffab6a12e5a403ac64ce87d2033cf37efa0c9cdd6b2496cb", + "transpilations": "27394f21c5eb54773b98b7da777d7f3c3439746030e7cc2aa4c267745e730ada", + "preregisteredCohort": "dab7d62b0419c2da63eae3387be6222e77c114ed32b22dc9a2a9af35fb6afe85", + "dependencyLock": "b6f18c67cdf3d837074d5b6d9439d29d686ec7a8e99a5a7e0686b210b267c87b" + }, + "admission": { + "noGitHubWrites": true, + "stopNewWorkOnlyOnIrreversibleGateFailure": true, + "explicitCancellation": true + } +} diff --git a/quality/bugbot/evidence/issue-971/prior-03f8e6e3-predictions.json b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-predictions.json new file mode 100644 index 000000000..2a0f63c4b --- /dev/null +++ b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-predictions.json @@ -0,0 +1,1709 @@ +{ + "schemaVersion": 1, + "predictions": { + "ts-null-dereference": [ + { + "id": "src/users.ts:42:unguarded-find-result", + "title": "Guard the optional lookup result", + "description": "`Array.prototype.find` returns `undefined` when no user matches. In that case, `user.name` throws instead of handling the missing user.", + "file": "src/users.ts", + "line": 42, + "endLine": 42, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied fragment assigns the result of `users.find(...)` to `user` and immediately dereferences `user.name` without a guard.", + "suggestion": "Check whether a match was found and handle the missing-user case before reading `name`.", + "codeSnippet": "return user.name;", + "fingerprint": "fp-82335172", + "semanticFingerprint": "sf-34325d75" + } + ], + "py-command-injection": [ + { + "id": "app/image.py:18:shell-command-injection", + "title": "Untrusted input enables shell command injection", + "description": "The request’s `file` value is interpolated into a command string passed to `os.system`, which invokes a shell. A value containing shell syntax can run additional commands with the application’s privileges.", + "file": "app/image.py", + "line": 18, + "endLine": 18, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "The changed fragment starts at source line 18; the exact `os.system` statement is at displayed-line offset 0, so 18 + 0 = 18. It inserts `request.args['file']` directly into the shell command without separating it as an argument.", + "suggestion": "Pass the executable and arguments as a list to `subprocess.run` with its default `shell=False`.", + "codeSnippet": "os.system(f\"convert {request.args['file']} out.png\")", + "suggestedCode": "subprocess.run([\"convert\", request.args[\"file\"], \"out.png\"], check=True)", + "fingerprint": "fp-81fcdafa", + "semanticFingerprint": "sf-62840a63" + } + ], + "go-leaked-goroutine": [ + { + "id": "internal/fetch.go:64:producer-blocks-after-timeout", + "title": "Producer can block after the timeout returns", + "description": "If the timeout wins, the consumer returns without receiving from `results`. The goroutine can then block forever on this send when the channel has no available buffer slot; the send has no cancellation path.", + "file": "internal/fetch.go", + "line": 64, + "endLine": 64, + "severity": "medium", + "confidence": 0.87, + "category": "reliability", + "evidence": "The supplied scenario identifies the path where the producer blocks after the consumer returns. The changed send is the first displayed line, so with fragment origin 64 and offset 0, its line is 64 + 0 = 64.", + "suggestion": "Ensure the producer can finish after the timeout returns, such as by providing sufficient buffering for this result or selecting on a cancellation signal that is triggered when the consumer exits.", + "codeSnippet": "go func() { results <- fetch(ctx) }()", + "fingerprint": "fp-74c64fda", + "semanticFingerprint": "sf-d85612de" + } + ], + "sql-unbounded-query": [ + { + "id": "queries/events.sql:9:unbounded-events-query", + "title": "Restore the pagination limit on the events query", + "description": "The change removes `LIMIT 100`, so this hot query can return every row in `events` instead of a bounded page. As the table grows, this can increase query work and response size.", + "file": "queries/events.sql", + "line": 9, + "endLine": 9, + "severity": "medium", + "confidence": 0.99, + "category": "performance", + "evidence": "The added `SELECT * FROM events` is the second displayed diff line. With the fragment starting at line 8, its line is 8 + offset 1 = 9.", + "suggestion": "Restore a bounded pagination limit.", + "codeSnippet": "SELECT * FROM events", + "suggestedCode": "SELECT * FROM events LIMIT 100", + "fingerprint": "fp-c22ca1d9", + "semanticFingerprint": "sf-56140f5c" + } + ], + "java-close-resource": [ + { + "id": "src/StorageReader.java:32:unclosed-input-stream", + "title": "Close the storage stream after parsing", + "description": "The stream opened on line 31 is passed to `parse` and the method returns without closing it. Repeated reads can leave storage resources open. Use try-with-resources around the parse call.", + "file": "src/StorageReader.java", + "line": 32, + "endLine": 32, + "severity": "medium", + "confidence": 0.87, + "category": "reliability", + "evidence": "The changed fragment opens an `InputStream` and then returns from `parse(stream)` without a close operation; the scenario specifies that these early paths do not close the stream.", + "suggestion": "Close the stream with try-with-resources after parsing completes.", + "codeSnippet": "return parse(stream);", + "suggestedCode": "try (InputStream stream = storage.open(key)) {\n return parse(stream);\n}", + "fingerprint": "fp-38119794", + "semanticFingerprint": "sf-40cdde9c" + } + ], + "rust-safe-change": [], + "docs-only": [], + "ts-authorization-bypass": [ + { + "id": "src/admin/delete_user.ts:71:missing-admin-check", + "title": "User deletion no longer checks admin authorization", + "description": "The change removes the `actor.isAdmin` guard and calls `users.delete` directly. An actor who is not an admin can therefore delete the user identified by the request parameter.", + "file": "src/admin/delete_user.ts", + "line": 71, + "endLine": 71, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "The diff removes `if (!actor.isAdmin) throw new ForbiddenError();` and adds `await users.delete(request.params.id);`. The fragment starts at line 70; the added operation is at displayed-line offset 1, so its line is 71.", + "suggestion": "Restore the admin authorization guard before deleting the user.", + "codeSnippet": "await users.delete(request.params.id);", + "suggestedCode": "if (!actor.isAdmin) throw new ForbiddenError();\nawait users.delete(request.params.id);", + "fingerprint": "fp-60de4e87", + "semanticFingerprint": "sf-60f8c5a8" + } + ], + "ts-safe-optional-chain": [], + "py-mutable-default": [ + { + "id": "app/filters.py:11:mutable-default", + "title": "Default list is shared across calls", + "description": "When `selected` is omitted, calls reuse the list created when the function was defined. Since the function appends `value` and returns that list, later calls can include values accumulated by earlier requests.", + "file": "app/filters.py", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "In the supplied changed fragment, the source origin is line 11 and the exact function definition is at displayed-line offset 0, so 11 + 0 = line 11. The default list is reused across calls that omit `selected`; the following append mutates it and the function returns the accumulated list.", + "suggestion": "Use a `None` default and create a fresh list when no list is supplied.", + "symbol": "collect_filters", + "codeSnippet": "def collect_filters(value, selected=[]):", + "suggestedCode": "def collect_filters(value, selected=None):\n if selected is None:\n selected = []\n selected.append(value)\n return selected", + "fingerprint": "fp-297c8e79", + "semanticFingerprint": "sf-7385c725" + } + ], + "py-parameterized-query": [], + "go-ignored-write-error": [ + { + "id": "internal/export.go:52:ignored-response-write-error", + "title": "Response write errors are discarded", + "description": "If the response write fails or writes only part of the payload, this line discards the error and execution proceeds to increment the export metric. The failure is therefore invisible to the handler and may be counted as a successful export.", + "file": "internal/export.go", + "line": 52, + "endLine": 52, + "severity": "medium", + "confidence": 0.96, + "category": "reliability", + "evidence": "The supplied fragment places `_, _ = w.Write(payload)` at line 52, followed by `metrics.Exports.Inc()`. Go's `ResponseWriter.Write` can return a non-nil error.", + "suggestion": "Handle the write error, such as by recording the failed response, and ensure the export metric reflects its intended success or attempt semantics.", + "codeSnippet": "_, _ = w.Write(payload)", + "fingerprint": "fp-02a1e580", + "semanticFingerprint": "sf-2fa767dd" + } + ], + "go-cancellable-send": [], + "sql-string-concatenation": [ + { + "id": "queries/tenant.js:15:sql-injection", + "title": "Untrusted tenant ID is concatenated into SQL", + "description": "The query inserts `request.params.id` directly into SQL. An attacker can supply SQL syntax that changes the query and may bypass the tenant filter or expose data from other tenants.", + "file": "queries/tenant.js", + "line": 15, + "endLine": 15, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "The supplied line concatenates the untrusted `request.params.id` value into the SQL statement without parameter binding.", + "suggestion": "Use a parameterized query and pass the tenant ID as a bound value.", + "symbol": "db.query", + "codeSnippet": "db.query('SELECT * FROM tenants WHERE id = ' + request.params.id);", + "fingerprint": "fp-9a69c1c8", + "semanticFingerprint": "sf-4df517b0" + } + ], + "sql-bounded-query": [ + { + "id": "queries/audit.sql:4:non-unique-order", + "title": "Timestamp ties leave the limited result nondeterministic", + "description": "Rows with equal `created_at` values have no defined relative order. Because the query limits the result to 100 rows, tied rows near the boundary may be included or omitted unpredictably, so the ordering is not deterministic.", + "file": "queries/audit.sql", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.96, + "category": "correctness", + "evidence": "The query orders only by `created_at DESC` before applying `LIMIT 100`; SQL does not define the order of rows tied on that column.", + "suggestion": "Add a stable unique tie-breaker to the `ORDER BY` clause.", + "codeSnippet": "SELECT * FROM audit_events ORDER BY created_at DESC LIMIT 100;", + "fingerprint": "fp-b8e48c7a", + "semanticFingerprint": "sf-794c9e0c" + } + ], + "java-try-with-resources": [], + "rust-unchecked-input": [ + { + "id": "src/http/limit.rs:27:malformed-limit-panics", + "title": "Malformed limit input panics the service", + "description": "The request-controlled query value is parsed as `usize` and immediately unwrapped. A malformed or out-of-range value makes `parse()` return an error, so `unwrap()` panics and can terminate the service process as described in the scenario.", + "file": "src/http/limit.rs", + "line": 27, + "endLine": 27, + "severity": "high", + "confidence": 0.98, + "category": "reliability", + "evidence": "The supplied changed line calls `.parse().unwrap()` on `request.query(\"limit\")`; parsing an invalid `usize` returns `Err`, which `unwrap()` converts to a panic.", + "suggestion": "Handle the parse error and return a client error or an intentional fallback instead of panicking.", + "codeSnippet": "let limit: usize = request.query(\"limit\").parse().unwrap();", + "fingerprint": "fp-e0c71264", + "semanticFingerprint": "sf-e62a760c" + } + ], + "rust-result-propagation": [], + "actions-untrusted-checkout": [ + { + "id": ".github/workflows/review.yml:7:executes-untrusted-pr-code", + "title": "Untrusted pull request code runs with privileged workflow access", + "description": "The workflow uses `pull_request_target`, checks out the pull request head, then runs `npm test`. A pull request can modify test scripts or other executed code, so this runs attacker-controlled code in the privileged workflow context with `write-all` permissions.", + "file": ".github/workflows/review.yml", + "line": 7, + "endLine": 7, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "In the supplied fragment starting at line 1, `- run: npm test` is at zero-based offset 6, so the reported line is 1 + 6 = 7. The preceding checkout uses `${{ github.event.pull_request.head.sha }}`, and the workflow has `permissions: write-all`.", + "suggestion": "Run pull request tests in a `pull_request` workflow. Keep `pull_request_target` limited to trusted operations that do not check out or execute pull request code.", + "symbol": "steps", + "codeSnippet": "- run: npm test", + "fingerprint": "fp-0613bf32", + "semanticFingerprint": "sf-f1a81ba0" + } + ], + "actions-readonly-metadata": [ + { + "id": ".github/workflows/metadata.yml:4:steps-outside-job", + "title": "Workflow steps are not nested under a job", + "description": "GitHub Actions requires `steps` to be nested under a job in `jobs`. This workflow declares `steps` at the top level and has no `jobs` mapping, so GitHub cannot run it as a valid workflow.", + "file": ".github/workflows/metadata.yml", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The supplied workflow places `steps:` directly after `permissions:` at line 4, with no enclosing `jobs.` mapping.", + "suggestion": "Define a job under `jobs` and move `steps` into that job.", + "codeSnippet": "steps:", + "fingerprint": "fp-f364b52b", + "semanticFingerprint": "sf-ce1a408a" + } + ], + "shell-unquoted-path": [ + { + "id": "scripts/archive.sh:14:unquoted-upload-path", + "title": "Unquoted upload path changes the archive operands", + "description": "Because the attacker-controlled path is unquoted, the shell applies field splitting and pathname expansion. A path containing whitespace or wildcard characters can make tar archive unintended operands or matching files from the working directory.", + "file": "scripts/archive.sh", + "line": 14, + "endLine": 14, + "severity": "medium", + "confidence": 0.99, + "category": "security", + "evidence": "The supplied fragment starts at line 14; this command is its first displayed line (offset 0), so 14 + 0 = 14. The unquoted $UPLOAD_PATH undergoes field splitting and pathname expansion before tar receives its arguments.", + "suggestion": "Quote the path and terminate tar option parsing so it is passed as one operand.", + "codeSnippet": "tar -czf backup.tgz $UPLOAD_PATH", + "suggestedCode": "tar -czf backup.tgz -- \"$UPLOAD_PATH\"", + "fingerprint": "fp-b21fccee", + "semanticFingerprint": "sf-4ec05942" + } + ], + "shell-quoted-path": [], + "terraform-public-database": [ + { + "id": "infra/database.tf:94:public-postgresql-ingress", + "title": "PostgreSQL is reachable from the entire internet", + "description": "This ingress rule allows TCP connections to port 5432 from every IPv4 address. The database is therefore exposed to internet-wide connection attempts, increasing the risk of unauthorized access and exploitation.", + "file": "infra/database.tf", + "line": 94, + "endLine": 94, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "The changed ingress rule sets `cidr_blocks` to `[\"0.0.0.0/0\"]` for port 5432.", + "suggestion": "Restrict the allowed CIDR blocks to the specific trusted networks that need database access.", + "symbol": "ingress", + "codeSnippet": "cidr_blocks = [\"0.0.0.0/0\"]", + "fingerprint": "fp-6535776e", + "semanticFingerprint": "sf-5c6c6106" + } + ], + "terraform-private-database": [], + "react-stale-effect": [ + { + "id": "src/UserPanel.tsx:32:missing-userId-dependency", + "title": "Effect does not reload when userId changes", + "description": "The effect reads userId but has an empty dependency array, so it runs only on mount. If the mounted panel receives a different userId, it does not load that user and can continue showing the previous user's data.", + "file": "src/UserPanel.tsx", + "line": 32, + "endLine": 34, + "severity": "medium", + "confidence": 0.98, + "category": "correctness", + "evidence": "The supplied fragment starts at line 32; the effect calls loadUser(userId) but declares no dependencies. A later userId change does not rerun this effect.", + "suggestion": "Add userId to the dependency array so the effect reloads when the identifier changes.", + "symbol": "UserPanel", + "codeSnippet": "useEffect(() => {\n loadUser(userId).then(setUser);\n}, []);", + "suggestedCode": "useEffect(() => {\n loadUser(userId).then(setUser);\n}, [userId]);", + "fingerprint": "fp-f005be51", + "semanticFingerprint": "sf-65d51e70" + } + ], + "react-complete-dependencies": [], + "csharp-path-traversal": [ + { + "id": "Controllers/DownloadController.cs:58:upload-path-traversal", + "title": "Filename can escape the upload root", + "description": "`request.FileName` is combined with `uploadRoot` without checking the resolved path. A filename containing `..` can escape the upload directory, and a rooted filename can cause `Path.Combine` to discard the root. The subsequent `PhysicalFile` call can therefore serve a file outside the upload root.", + "file": "Controllers/DownloadController.cs", + "line": 58, + "endLine": 58, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "The supplied fragment starts at line 58. The changed `Path.Combine` statement is displayed-line offset 0, so its line is 58 + 0 = 58. No containment validation appears before the resulting path is passed to `PhysicalFile` on the next line.", + "suggestion": "Resolve the candidate to a full path and reject rooted filenames or any candidate that is not contained within the canonical upload root before serving it.", + "symbol": "DownloadController", + "codeSnippet": "var path = Path.Combine(uploadRoot, request.FileName);", + "fingerprint": "fp-af809603", + "semanticFingerprint": "sf-d5380e3b" + } + ], + "csharp-contained-path": [ + { + "id": "Controllers/DownloadController.cs:73:symlink-path-escape", + "title": "Symlinks can bypass the upload-root check", + "description": "GetFullPath canonicalizes the path text but does not resolve filesystem symlinks. A path such as an in-root symlink that targets a file outside uploadRoot still has the required string prefix and passes this check; opening it for download can expose the outside file.", + "file": "Controllers/DownloadController.cs", + "line": 73, + "endLine": 73, + "severity": "medium", + "confidence": 0.88, + "category": "security", + "evidence": "The changed check tests only the canonicalized string with StartsWith. It does not verify the resolved filesystem target, so a symlink beneath uploadRoot can point outside while its path remains beneath the root.", + "suggestion": "Resolve the target and verify that it remains under uploadRoot, or reject symlinks before opening the file.", + "codeSnippet": "if (!path.StartsWith(Path.GetFullPath(uploadRoot) + Path.DirectorySeparatorChar, StringComparison.Ordinal))", + "fingerprint": "fp-2b917d31", + "semanticFingerprint": "sf-2f868501" + } + ], + "kotlin-blocking-coroutine": [ + { + "id": "src/ReportController.kt:49:blocking-file-read", + "title": "Blocking file read runs on the request dispatcher", + "description": "`Files.readAllBytes` performs blocking I/O. Because `report()` runs on the request coroutine dispatcher, this call occupies a dispatcher thread until the read completes and can delay other requests under load. Making the function `suspend` does not make the file read nonblocking.", + "file": "src/ReportController.kt", + "line": 49, + "endLine": 49, + "severity": "medium", + "confidence": 0.97, + "category": "performance", + "evidence": "The changed statement is `val bytes = Files.readAllBytes(reportPath)`; the scenario specifies that this code runs directly on a request coroutine dispatcher.", + "suggestion": "Run the file read on an I/O dispatcher, or use a nonblocking file I/O API.", + "symbol": "report", + "codeSnippet": "val bytes = Files.readAllBytes(reportPath)", + "fingerprint": "fp-669ae37f", + "semanticFingerprint": "sf-a6dd1c73" + } + ], + "kotlin-io-dispatcher": [], + "py-coverage-config-branch": [ + { + "id": "pyproject.toml:4:coverage-threshold-not-enforced", + "title": "Coverage threshold is not enforced by the job command", + "description": "The scenario runs `coverage run` but never runs a coverage reporting command. `fail_under` is enforced when coverage generates a report, so this setting alone does not make the job fail when coverage is below 85%.", + "file": "pyproject.toml", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.98, + "category": "correctness", + "evidence": "The configured `fail_under = 85` is under `[tool.coverage.report]`, while the stated command is only `python -m coverage run -m unittest discover`; it records coverage and runs tests without checking the report threshold.", + "suggestion": "Add a coverage report command after the test run so the configured threshold is checked.", + "symbol": "fail_under", + "codeSnippet": "fail_under = 85", + "suggestedCode": "python -m coverage report", + "fingerprint": "fp-437af6c7", + "semanticFingerprint": "sf-03bc1b1f" + } + ], + "py-http10-reconnect": [], + "docs-correct-regression-total": [], + "py-short-circuit-unhashable": [], + "py-helper-retry-validation": [], + "ts-exclusive-render-branches": [], + "py-short-circuit-unsafe-order": [ + { + "id": "src/checkpoint.py:2:unhashable-step-before-type-check", + "title": "Unhashable steps can crash validation", + "description": "When `writable_ids` is a set, a persisted JSON array or object used as a step raises `TypeError` during membership testing instead of being rejected. The membership check runs before the string type check.", + "file": "src/checkpoint.py", + "line": 2, + "endLine": 2, + "severity": "medium", + "confidence": 0.9, + "category": "reliability", + "evidence": "For `issue_steps=[[]]` and `writable_ids=set()`, Python evaluates `step in writable_ids` first; the list is unhashable, so this raises `TypeError` before `isinstance(step, str)` runs. The changed fragment starts at line 1; the exact return statement has zero-based displayed-line offset 1, so 1 + 1 = line 2.", + "suggestion": "Check that each step is a string before testing membership in `writable_ids`.", + "symbol": "valid_steps", + "codeSnippet": "return all(step in writable_ids and isinstance(step, str) for step in issue_steps)", + "suggestedCode": "return all(isinstance(step, str) and step in writable_ids for step in issue_steps)", + "fingerprint": "fp-def2cccd", + "semanticFingerprint": "sf-13a798fe" + } + ], + "ts-composed-duplicate-ids": [ + { + "id": "ui/views.ts:1:duplicate-action-reason-id", + "title": "Repeated actions render duplicate IDs", + "description": "Each call to `unavailableAction()` creates a span with the same `action-reason` ID. Since `overview()` calls it twice, the rendered section contains duplicate IDs, making the document invalid and ID-based lookup ambiguous.", + "file": "ui/views.ts", + "line": 1, + "endLine": 1, + "severity": "low", + "confidence": 0.99, + "category": "correctness", + "evidence": "The helper assigns `id=\"action-reason\"`, and the overview invokes the helper twice in one section.", + "suggestion": "Remove the ID if it is not needed, or provide a distinct ID for each rendered action.", + "symbol": "unavailableAction", + "codeSnippet": "const unavailableAction = () => html`Unavailable`;", + "fingerprint": "fp-8f6c7241", + "semanticFingerprint": "sf-41c8b5c8" + } + ], + "kt-compose-owned-loader": [], + "kt-compose-external-loader": [ + { + "id": "frontend/index.html:2:loading-overlay-persists", + "title": "Loading overlay remains after Compose mounts", + "description": "The fixed, full-screen `#loading` element is a sibling of `#ComposeTarget`. `ComposeViewport` clears the target container before mounting content, so it does not remove this overlay. The removed window-load handler was the only cleanup shown; after successful startup, the overlay remains above and obscures the app.", + "file": "frontend/index.html", + "line": 2, + "endLine": 2, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The supplied fragment places `#ComposeTarget` on line 1 and the fixed `#loading` overlay on line 2. The supplied Compose 1.13.0-beta01 contract says `ComposeViewport` calls `replaceChildren()` on its viewport container, which is `#ComposeTarget`; the overlay is outside that container. The diff removes the handler that previously removed `#loading` on window load.", + "suggestion": "Place the loading element inside `#ComposeTarget` so ComposeViewport clears it, or remove it when Compose startup completes.", + "symbol": "#loading", + "codeSnippet": "
Loading...
", + "fingerprint": "fp-722d4dac", + "semanticFingerprint": "sf-e8faaa9b" + } + ], + "kt-compose-failed-startup-error": [], + "kt-compose-failed-startup-stuck": [ + { + "id": "frontend/Main.kt:2:startup-loader-stuck", + "title": "Initialization failure leaves the loading placeholder indefinitely", + "description": "If required saved settings are malformed, `initializeDependencies()` throws before `ComposeViewport` is called. The framework clears the container only during `onSkikoReady`, so that cleanup and content mounting never happen. With no error handler or other loader update, the host's `Loading...` child remains visible indefinitely.", + "file": "frontend/Main.kt", + "line": 2, + "endLine": 2, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The changed `main` calls `initializeDependencies()` at line 2 before `ComposeViewport` at line 3. The supplied scenario says initialization throws for malformed settings and there is no global error handler or other loader update; the supplied Compose 1.13.0-beta01 contract says container clearing occurs inside `onSkikoReady` before mounting content.", + "suggestion": "Handle initialization failures by presenting a startup error or updating the host loader before returning or rethrowing.", + "symbol": "main", + "codeSnippet": "initializeDependencies()", + "fingerprint": "fp-c8e387dc", + "semanticFingerprint": "sf-b1f43399" + } + ], + "ts-viewport-version-without-cleanup": [ + { + "id": "src/startup.ts:2:loading-remains-after-mount", + "title": "Loading indicator remains after mount", + "description": "The previous explicit removal of the loading element was deleted. The resolved viewport-framework 1.0 mount implementation only appends the app, so after this call the existing loading element remains beside the mounted app and continues to display “Loading...”.", + "file": "src/startup.ts", + "line": 2, + "endLine": 2, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The supplied fragment starts at line 1; the mount call is at offset 1, so its line is 2. The supplied viewport-framework 1.0 source implements mount as target.appendChild(app), and index.html already places #loading inside #target. The deleted line removed the cleanup that cleared it.", + "suggestion": "Remove the loading element after mounting the app.", + "codeSnippet": "mount(document.getElementById(\"target\")!, createApp());", + "suggestedCode": "mount(document.getElementById(\"target\")!, createApp());\ndocument.getElementById(\"loading\")!.remove();", + "fingerprint": "fp-17778b8d", + "semanticFingerprint": "sf-ce2481d5" + } + ], + "kt-compose-preferred-width-narrow": [], + "kt-compose-required-width-overflow": [ + { + "id": "ui/AuthForm.kt:10:required-width-overflows-narrow-parent", + "title": "Required width makes the form overflow narrow parents", + "description": "The required 400dp width overrides the Box's 280dp maximum. With the 16dp Card modifier padding and 24dp Column padding on each side, each fill-width field and button is 320dp wide. The required-width child is centered in the parent's reported 280dp size, so these interactive controls extend beyond the parent. Replacing requiredWidth with widthIn(max = 320.dp) lets the width respect the incoming 280dp constraint while keeping controls within the 320dp cap at wider sizes.", + "file": "ui/AuthForm.kt", + "line": 10, + "endLine": 10, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied fragment starts at line 1; a numbered listing places the Card statement at line 10 (offset 9). Its modifier requires 400dp, while the scenario bounds the Box to 280dp. The inner control width is 400 - 2×16 - 2×24 = 320dp, exceeding the narrow parent by 40dp.", + "suggestion": "Replace requiredWidth(400.dp) with widthIn(max = 320.dp) so the modifier respects the parent's width constraints and retains the wide-screen cap.", + "symbol": "AuthForm", + "codeSnippet": "Card(modifier = Modifier.requiredWidth(400.dp).padding(16.dp)) {", + "suggestedCode": "Card(modifier = Modifier.widthIn(max = 320.dp).padding(16.dp)) {", + "fingerprint": "fp-4a08a026", + "semanticFingerprint": "sf-a94cb530" + } + ], + "kt-compose-fill-before-cap": [ + { + "id": "ui/AuthForm.kt:10:width-cap-ineffective", + "title": "The width cap cannot constrain the form at 800dp", + "description": "At 800dp, fillMaxWidth first sets an exact 800dp width. The following widthIn(max = 400.dp) cannot reduce that incoming minimum, so the cap is ineffective. The 16dp Card modifier padding and 24dp Column padding leave the fill-width fields 720dp wide, exceeding the required 320dp maximum. Putting widthIn before fillMaxWidth preserves the 280dp layout and caps the fields at 320dp when the parent is 800dp wide.", + "file": "ui/AuthForm.kt", + "line": 10, + "endLine": 10, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied fragment starts at line 1; a numbered literal listing places the Card modifier at line 10. At 800dp, the padding leaves 800 - 2×16 - 2×24 = 720dp for the fields.", + "suggestion": "Apply widthIn before fillMaxWidth so the cap constrains the width before it becomes exact.", + "symbol": "AuthForm", + "codeSnippet": "Card(modifier = Modifier.fillMaxWidth().widthIn(max = 400.dp).padding(16.dp)) {", + "suggestedCode": "Card(modifier = Modifier.widthIn(max = 400.dp).fillMaxWidth().padding(16.dp)) {", + "fingerprint": "fp-18103c4e", + "semanticFingerprint": "sf-d684a679" + } + ], + "kt-compose-cap-before-fill": [], + "kt-compose-padded-preferred-width": [], + "android-listed-minor-platform": [], + "android-absent-platform-package": [ + { + "id": ".github/workflows/ci.yml:185:missing-platform-package", + "title": "Install command requests an unavailable Android platform package", + "description": "The workflow installs `platforms;android-37`, but the supplied stable macOS catalog contains only `platforms;android-37.0`, `platforms;android-37.1`, and `platforms;android-37.2`. The scenario confirms that a fresh installation on this workflow revision exits 1 because the requested package cannot be found, so the workflow fails before it can build.", + "file": ".github/workflows/ci.yml", + "line": 185, + "endLine": 185, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The changed command is `sdkmanager --install \"platforms;android-37\"`. The supplied dated catalog has no package with that path, and the supplied fresh-install observation reports `Failed to find package platforms;android-37`. The fragment starts at line 185 and the command is at offset 0, so the cited line is 185.", + "suggestion": "Change the install path to a platform package available in the catalog and ensure it matches the configured compile SDK.", + "codeSnippet": "sdkmanager --install \"platforms;android-37\"", + "fingerprint": "fp-12d180a9", + "semanticFingerprint": "sf-28df3f3e" + } + ], + "external-package-unverified-inventory": [], + "android-stale-inventory-current-install": [], + "android-unrelated-green-job": [ + { + "id": ".github/workflows/ci.yml:185:invalid-android-platform-package", + "title": "SDK install requests an unavailable Android platform package", + "description": "The command requests `platforms;android-37`, which is absent from the supplied complete catalog. The exact workflow revision fails this install command, blocking the build. The displayed fragment starts at line 185; this command is offset 0, so its line is 185.", + "file": ".github/workflows/ci.yml", + "line": 185, + "endLine": 185, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The catalog lists `platforms;android-37.0`, `platforms;android-37.1`, and `platforms;android-37.2`, but no `platforms;android-37`; the workflow's fresh install fails with `Failed to find package platforms;android-37`.", + "suggestion": "Install a package present in the catalog, such as `platforms;android-37.0`.", + "symbol": "sdkmanager install command", + "codeSnippet": "sdkmanager --install \"platforms;android-37\"", + "suggestedCode": "sdkmanager --install \"platforms;android-37.0\"", + "fingerprint": "fp-63162858", + "semanticFingerprint": "sf-28df3f3e" + } + ], + "kt-resolved-sql-subclass": [], + "jvm-type-hierarchy-unavailable": [], + "jvm-current-contract-over-stale-docs": [], + "jvm-unrelated-runtime-wrapper": [ + { + "id": "storage/ReadRows.kt:4:catch-unassignable-wrapper", + "title": "Catch does not handle the database wrapper exception", + "description": "On the stated duplicate-key fault, `driver.selectRows()` throws `example.db.SqlFailure`, which extends `RuntimeException` and is not assignable to `SQLException`. This catch is skipped, so the exception escapes instead of returning the promised `Either.Left(DatabaseException)`.", + "file": "storage/ReadRows.kt", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The supplied fragment starts at line 1; the catch clause is at zero-based offset 3, so its line is 1 + 3 = 4. The scenario specifies that `SqlFailure` wraps a `SQLException` as its cause but does not extend it; a cause relationship does not make the wrapper catchable as `SQLException`.", + "suggestion": "Catch the library's `SqlFailure` type and wrap that exception in `DatabaseException`, preserving it as the cause.", + "symbol": "readRows", + "codeSnippet": "} catch (failure: SQLException) {", + "fingerprint": "fp-63fbcd48", + "semanticFingerprint": "sf-90ad1723" + } + ], + "jvm-passing-mock-not-counterevidence": [ + { + "id": "storage/ReadRows.kt:4:uncaught-driver-wrapper", + "title": "Driver wrapper escapes the error conversion", + "description": "The handler catches SQLException, but the resolved driver throws example.db.SqlFailure, which extends RuntimeException rather than SQLException. On that production failure path, readRows throws instead of returning Either.Left as callers require. The passing mock test throws a different exception type and does not cover this path.", + "file": "storage/ReadRows.kt", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied dependency contract says driver.selectRows throws SqlFailure on SQL failure and SqlFailure is not a SQLException subtype; the changed catch therefore does not handle that failure.", + "suggestion": "Catch example.db.SqlFailure and convert it to Either.Left.", + "symbol": "readRows", + "codeSnippet": "} catch (failure: SQLException) {", + "suggestedCode": "} catch (failure: example.db.SqlFailure) {", + "fingerprint": "fp-ef4ef80f", + "semanticFingerprint": "sf-90ad1723" + } + ], + "kt-broad-catch-swallows-cancellation": [ + { + "id": "storage/ReadRows.kt:4:cancellation-swallowed-by-broad-catch", + "title": "Broad catch converts cancellation into a database error", + "description": "When `driver.selectRows()` is suspended and throws `CancellationException`, this catch handles it and returns `Either.Left(DatabaseException(...))`. Callers therefore receive an ordinary database failure instead of cancellation propagating.", + "file": "storage/ReadRows.kt", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The changed catch accepts `Throwable`, which includes `CancellationException`; the following `Either.Left` maps the caught failure to a normal result. The fragment starts at line 1, and the catch is at zero-based offset 3, so the line is 1 + 3 = 4.", + "suggestion": "Restore the `SQLException` catch, which already covers the driver's SQL exception subtype, or explicitly rethrow cancellation before mapping other failures.", + "symbol": "readRows", + "codeSnippet": "} catch (failure: Throwable) {", + "suggestedCode": "} catch (failure: SQLException) {", + "fingerprint": "fp-2f008abb", + "semanticFingerprint": "sf-0acfacbb" + } + ], + "test-indirect-binding-propagates": [], + "test-parameterized-fallback-reaches-stub": [], + "test-bound-callback-reaches-stub": [], + "test-delegate-bypasses-stub": [ + { + "id": "test/SessionReturnedState.test.ts:22:assertion-fails", + "title": "The new test expects a failure the public path never returns", + "description": "When `test()` runs, `service.getSession()` returns `right(row)`: `readSession()` returns that value, and the public path never calls `bindSession()`, the only function that invokes `participantSession` and returns the arranged failure. Therefore `assertDatabaseFailure` throws, so `observe()` reports `passes: false` with `calls: 0`.", + "file": "test/SessionReturnedState.test.ts", + "line": 22, + "endLine": 22, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "In the supplied fragment, the first displayed line is origin 1; the changed `test()` line is at zero-based offset 21, giving line 22. The actual path is `service.getSession()` → `access.session()` → `readSession()` → `right(row)`. `bindSession()` is not on that path.", + "suggestion": "If the projection failure is the intended contract, route the public reader through `bindSession()` before this assertion. Otherwise, update the assertion to match the returned `right(row)`.", + "symbol": "test", + "codeSnippet": "function test() { assertDatabaseFailure(service.getSession()); }", + "fingerprint": "fp-f971c2cb", + "semanticFingerprint": "sf-efea4a32" + } + ], + "test-empty-participants-skip-stub": [ + { + "id": "test/SessionReturnedState.test.ts:22:empty-participants-skip-projection-stub", + "title": "The assertion expects an error from a projection that is never called", + "description": "The row has an empty participants array, so bindSession skips its loop and returns a right result. The service therefore returns success, and assertDatabaseFailure throws because it expects the participant projection failure. Add a participant to the fixture so the stub is reached.", + "file": "test/SessionReturnedState.test.ts", + "line": 22, + "endLine": 22, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The numbered fragment starts at line 1; the changed assertion is at zero-based offset 21, so 1 + 21 = line 22. With participants: [], bindSession makes no participantSession call and returns right(session); the service returns that result, contradicting the assertion's expected left result.", + "suggestion": "Give the row at least one participant so bindSession invokes participantSession and receives the configured failure.", + "symbol": "test", + "codeSnippet": "function test() { assertDatabaseFailure(service.getSession()); }", + "suggestedCode": "const row = {id: \"s1\", participants: [{id: \"p1\"}]};", + "fingerprint": "fp-489a57a7", + "semanticFingerprint": "sf-efea4a32" + } + ], + "test-recovery-swallows-bound-failure": [ + { + "id": "test/SessionReturnedState.test.ts:24:projection-failure-swallowed", + "title": "Projection failure is converted to success before the assertion", + "description": "The added test expects the participant projection’s database failure to propagate, but `readSession` turns its `left(failure)` result into `right(row)`. Consequently, `service.getSession()` returns a successful row and `assertDatabaseFailure` throws when this test runs. Preserve the failure in `readSession` so the public contract is met.", + "file": "test/SessionReturnedState.test.ts", + "line": 24, + "endLine": 24, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The participant lookup returns `left(failure)`; `bindSession` returns that result, and `flatMap(right(row), bindSession)` therefore produces `left(failure)`. `readSession` then replaces it with `right(row)`, which flows through `access.session` and `service.getSession`. The displayed fragment starts at line 1; the changed test statement has zero-based offset 23, so its line is 1 + 23 = 24.", + "suggestion": "Return the `result` from `readSession` without converting a left result into a successful row.", + "symbol": "test", + "codeSnippet": "function test() { assertDatabaseFailure(service.getSession()); }", + "suggestedCode": "return result;", + "fingerprint": "fp-1330048a", + "semanticFingerprint": "sf-efea4a32" + } + ], + "action-declared-matcher-input": [], + "action-renamed-input-current-version": [], + "action-input-contract-unavailable": [], + "action-undeclared-matcher-alias": [ + { + "id": ".github/actions/publish-package/action.yml:23:undeclared-matcher-input", + "title": "Use the declared problem-matcher input", + "description": "The upstream action reads `problem-matcher`, so `enable-problem-matcher` is ignored and the default `true` remains active. Matcher registration then fails because this composite has no matcher asset, preventing the upload.", + "file": ".github/actions/publish-package/action.yml", + "line": 23, + "endLine": 23, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The changed line is at fragment offset 8 from the supplied first line (line 15), so it is line 23. The supplied contract says the action reads `problem-matcher`, defaults it to true, and fails during registration when the parent composite has no matcher asset.", + "suggestion": "Pass `problem-matcher: false` to disable matcher registration.", + "symbol": "Publish package composite step", + "codeSnippet": "enable-problem-matcher: false", + "suggestedCode": "problem-matcher: false", + "fingerprint": "fp-a3bf90ec", + "semanticFingerprint": "sf-0474b070" + } + ], + "action-old-input-on-new-version": [ + { + "id": ".github/actions/publish-package/action.yml:22:ignored-problem-matcher-input", + "title": "Use the input supported by this action revision", + "description": "The selected revision declares and reads `enable-problem-matcher`; it ignores `problem-matcher`. As a result, the default remains `true`, so the action attempts to register a matcher that the parent composite does not provide and fails before upload.", + "file": ".github/actions/publish-package/action.yml", + "line": 22, + "endLine": 22, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The supplied contract for revision `2222222222222222222222222222222222222222` identifies `enable-problem-matcher` as the declared input and says only its string value `false` disables registration. The changed key is `problem-matcher`. The displayed fragment starts at line 15; this operation is at zero-based offset 7, so 15 + 7 = line 22.", + "suggestion": "Rename the input to `enable-problem-matcher` and provide the string `false`.", + "symbol": "steps[0].with", + "codeSnippet": "problem-matcher: false", + "suggestedCode": "enable-problem-matcher: 'false'", + "fingerprint": "fp-9a14be84", + "semanticFingerprint": "sf-a4d21264" + } + ], + "action-declared-input-wrong-value": [ + { + "id": ".github/actions/publish-package/action.yml:22:matcher-input-not-false", + "title": "Use the exact value that disables matcher registration", + "description": "The explicit value `off` reaches the upstream getter, but only the string `false` disables matcher registration. The composite has no matcher asset, so registration fails before the upload step and prevents publishing.", + "file": ".github/actions/publish-package/action.yml", + "line": 22, + "endLine": 22, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The changed line passes `problem-matcher: 'off'`. Per the supplied contract, only `'false'` disables registration; the parent composite has no matcher asset. In the fragment starting at line 15, the changed statement is at offset 7, so 15 + 7 = line 22.", + "suggestion": "Pass the exact string `false` to disable matcher registration.", + "symbol": "dart-lang/setup-dart step", + "codeSnippet": "problem-matcher: 'off'", + "suggestedCode": "problem-matcher: 'false'", + "fingerprint": "fp-7734e04d", + "semanticFingerprint": "sf-547dc978" + } + ], + "kt-email-unicode-empty-label-guard": [], + "ts-email-caller-empty-label-guard": [], + "ts-email-normalization-before-guard": [], + "ts-email-existential-label-defect": [ + { + "id": "auth/register.ts:5:empty-domain-label-accepted", + "title": "Empty domain labels pass validation", + "description": "The validator accepts a domain if it has at least two labels and any label is nonempty. For `user@example..com`, the two adjacent separators are ASCII U+002E dots, so `split('.')` produces `[\"example\", \"\", \"com\"]`. The length and `some` checks both pass, and the unchanged domain reaches `save`, despite the contract requiring every persisted label to be nonempty.", + "file": "auth/register.ts", + "line": 5, + "endLine": 5, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "`valid` returns true for the supplied `user@example..com` witness; the caller then stores `user@example..com`. The supported `Owner119+tag@Audit.Invalid` case still has nonempty labels under an all-labels check.", + "suggestion": "Require every domain label to be nonempty, for example by using `every` instead of `some`.", + "symbol": "registerExistential", + "codeSnippet": "return labels.length >= 2 && labels.some(label => label.length > 0);", + "suggestedCode": "return labels.length >= 2 && labels.every(label => label.length > 0);", + "fingerprint": "fp-e09d1135", + "semanticFingerprint": "sf-0786b5c4" + } + ], + "ts-email-ignored-validator-result": [ + { + "id": "auth/register.ts:11:ignored-domain-validation", + "title": "Invalid domain labels are persisted", + "description": "The registration path ignores the result of `valid(checked)`, so an address with an empty domain label passes the surrounding checks, is saved, and returns `true`.", + "file": "auth/register.ts", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "For `user@example..com`, `parts.length` is 2, the local part is nonempty, and there is no whitespace. `valid(checked)` returns false because splitting the domain on `.` produces an empty label, but execution continues to `save(...)` and returns true.", + "suggestion": "Reject the address when domain validation fails before saving it.", + "symbol": "registerIgnoredResult", + "codeSnippet": "valid(checked);", + "suggestedCode": "if (!valid(checked)) return false;", + "fingerprint": "fp-b986a571", + "semanticFingerprint": "sf-6107da19" + } + ], + "ts-email-normalization-after-guard": [], + "kt-wasm-parameter-closure": [], + "kt-wasm-size-count-parameters": [], + "kt-wasm-object-parameter": [], + "kt-wasm-binding-evidence-unavailable": [], + "kt-wasm-missing-direct-identifier": [ + { + "id": "fixtures/WasmBindings.kt:2:unbound-count", + "title": "Unbound `count` makes the Wasm bridge throw", + "description": "Calling `installBudget` evaluates JavaScript that reads `count`, but the generated import has only `size` as a parameter and the supplied scenario confirms no `count` binding or global exists. The call therefore raises `ReferenceError` instead of constructing the array.", + "file": "fixtures/WasmBindings.kt", + "line": 2, + "endLine": 2, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The generated import is `(size) => Array.from({length: count}, () => new Uint8Array(size))`; `count` is not bound. The changed expression is on fragment line 2: origin 1 plus zero-based offset 1 gives line 2.", + "suggestion": "Bind `count` in the JavaScript function or pass it as a parameter, using the intended array length.", + "symbol": "installBudget", + "codeSnippet": "\"\"\"Array.from({length: count}, () => new Uint8Array(size))\"\"\"", + "fingerprint": "fp-f53a95e2", + "semanticFingerprint": "sf-ec697896" + } + ], + "kt-wasm-missing-callback-identifier": [ + { + "id": "fixtures/WasmBindings.kt:3:undefined-empty-in-callback", + "title": "Callback reads an undeclared identifier", + "description": "When the installed callback runs, it evaluates `empty`, but the generated function has only the `selected` parameter and the shown JavaScript body declares no `empty` binding. With no global `empty`, the callback throws a `ReferenceError` instead of returning a byte array.", + "file": "fixtures/WasmBindings.kt", + "line": 3, + "endLine": 3, + "severity": "medium", + "confidence": 0.97, + "category": "correctness", + "evidence": "The callback closes over the generated function scope, whose only declared parameter is `selected`; `empty` is not declared in the shown body. The supplied scenario states there is no `empty` global.", + "suggestion": "Use the intended declared or captured boolean, or declare `empty` in the callback's scope.", + "symbol": "installDirectory", + "codeSnippet": "globalThis.onSelection = () => empty ? new Uint8Array(0) : new Uint8Array([1]);", + "fingerprint": "fp-c030a01e", + "semanticFingerprint": "sf-a86a0a45" + } + ], + "action-self-ref-bootstrap": [], + "action-self-ref-version-policy": [], + "action-workspace-ref-after-checkout": [], + "action-reference-contract-unavailable": [], + "action-self-ref-explicit-suffix": [ + { + "id": ".github/workflows/build.yml:5:invalid-self-repository-action-ref", + "title": "Self-repository action reference has an invalid ref suffix", + "description": "On GitHub.com, `$/.github/actions/...` resolves from the workflow’s repository at its running commit, and this syntax does not allow an explicit `@ref` suffix. The `@v1` suffix makes this action reference invalid, preventing the workflow from resolving the action.", + "file": ".github/workflows/build.yml", + "line": 5, + "endLine": 5, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The displayed fragment starts at line 1. The `uses` statement is at zero-based offset 4, so its line is 1 + 4 = 5. The supplied contract snapshot states that an explicit `@ref` suffix is invalid for this GitHub.com self-repository reference.", + "suggestion": "Remove the `@v1` suffix; the self-repository path resolves at the workflow’s running commit.", + "symbol": "jobs.build.steps[0]", + "codeSnippet": "uses: $/.github/actions/bootstrap@v1", + "fingerprint": "fp-c3c52fbd", + "semanticFingerprint": "sf-16fd3aef" + } + ], + "action-workspace-ref-before-checkout": [ + { + "id": ".github/workflows/build.yml:5:local-action-before-checkout", + "title": "Local action runs before checkout", + "description": "On a fresh workspace, `./.github/actions/bootstrap` is not present when GitHub tries to resolve it, so the job fails before reaching the checkout step. Move checkout ahead of this local action.", + "file": ".github/workflows/build.yml", + "line": 5, + "endLine": 5, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The supplied contract says `./path` resolves from the workspace and requires the action files to be checked out first. The changed fragment starts at line 1; the action use is at zero-based offset 4, so the line is 1 + 4 = 5.", + "suggestion": "Move the existing checkout step before the bootstrap action.", + "symbol": "build.steps", + "codeSnippet": "- uses: ./.github/actions/bootstrap", + "fingerprint": "fp-8300157d", + "semanticFingerprint": "sf-eef417db" + } + ], + "action-self-ref-unsupported-host": [ + { + "id": ".github/workflows/build.yml:5:unsupported-same-repository-reference-on-ghes", + "title": "Same-repository shorthand is unsupported on GHES 3.19", + "description": "This step uses the `$/` shorthand on GitHub Enterprise Server 3.19, where the supplied host-specific contract says that shorthand is unsupported. The action reference therefore cannot be resolved and the build job fails.", + "file": ".github/workflows/build.yml", + "line": 5, + "endLine": 5, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The workflow step is `uses: $/.github/actions/bootstrap`. The supplied GHES 3.19 contract identifies `$/` as unsupported on this host.", + "suggestion": "Use an available workspace reference or a remote repository reference supported by this GHES host.", + "symbol": "jobs.build.steps[0]", + "codeSnippet": "- uses: $/.github/actions/bootstrap", + "fingerprint": "fp-3fa59937", + "semanticFingerprint": "sf-bda545a5" + } + ], + "md-link-root-self": [], + "md-link-nested-self": [], + "md-link-companion": [], + "md-link-root-relative": [], + "md-link-evidence-unavailable": [], + "md-link-extra-specs-directory": [ + { + "id": "specs/payments.md:41:broken-architecture-link", + "title": "Architecture link points to a nonexistent file", + "description": "From `specs/payments.md`, the relative href `./specs/payments.md#architecture` resolves to `specs/specs/payments.md`, which is absent from the supplied tracked-file inventory. The `architecture` fragment matches the heading, but the target file does not exist.", + "file": "specs/payments.md", + "line": 41, + "endLine": 41, + "severity": "low", + "confidence": 1, + "category": "correctness", + "evidence": "The source directory is `specs`; resolving `./specs/payments.md` from it yields `specs/specs/payments.md`. The supplied inventory lists only `specs/payments.md`.", + "suggestion": "Use a relative path to the existing document.", + "symbol": "Architecture", + "codeSnippet": "[Design](./specs/payments.md#architecture)", + "suggestedCode": "[Design](./payments.md#architecture)", + "fingerprint": "fp-aa59ae0f", + "semanticFingerprint": "sf-7b2d1029" + } + ], + "md-link-missing-fragment": [ + { + "id": "specs/payments.md:41:missing-architecture-fragment", + "title": "Link points to a missing heading", + "description": "The link resolves to specs/payments.md, but its fragment `missing-architecture` does not match the document’s `architecture` heading anchor. Following the link will not navigate to the Architecture section.", + "file": "specs/payments.md", + "line": 41, + "endLine": 41, + "severity": "low", + "confidence": 1, + "category": "correctness", + "evidence": "From specs/payments.md, `../specs/payments.md` normalizes to specs/payments.md. The supplied document has the heading `## Architecture`, whose anchor is `architecture`; it has no `missing-architecture` anchor.", + "suggestion": "Change the fragment to `#architecture`.", + "symbol": "Design link", + "codeSnippet": "[Design](../specs/payments.md#missing-architecture)", + "suggestedCode": "[Design](../specs/payments.md#architecture)", + "fingerprint": "fp-b158c6f3", + "semanticFingerprint": "sf-b8a7c886" + } + ], + "md-link-renderer-drops-directory": [ + { + "id": "scripts/catalog.ts:41:drops-spec-subdirectory", + "title": "Rendered link drops the specification subdirectory", + "description": "For `specs/payments/design.md`, the function produces `./design.md`. In `specs/CATALOG.md`, that relative link resolves to `specs/design.md`, which is absent; the listed destination is `specs/payments/design.md`. Preserve the path relative to the catalog directory so the link reaches the specification.", + "file": "scripts/catalog.ts", + "line": 41, + "endLine": 41, + "severity": "low", + "confidence": 1, + "category": "correctness", + "evidence": "The changed function keeps only the substring after the last `/`, so `specs/payments/design.md` becomes `./design.md`; resolved from `specs/CATALOG.md`, the target is `specs/design.md`, not the existing `specs/payments/design.md`.", + "suggestion": "Preserve the specification's subdirectory relative to `specs/CATALOG.md`.", + "symbol": "renderSpecLink", + "codeSnippet": "function renderSpecLink(spec: string): string { return './' + spec.slice(spec.lastIndexOf('/') + 1); }", + "fingerprint": "fp-847abaea", + "semanticFingerprint": "sf-198ea78c" + } + ], + "request-transform-coil": [], + "request-transform-middleware": [], + "request-transform-unknown": [], + "request-transform-write": [ + { + "id": "media/request.ts:1:private-image-no-store", + "title": "Private image requests permit disk caching", + "description": "The policy enables disk writes while disabling disk reads. The builder reaches the `diskWrite` branch and emits `Cache-Control: no-cache`; the request passes through middleware unchanged, so the transport receives no `no-store` directive. This violates the stated requirement for private image requests and causes the transport check to reject the request.", + "file": "media/request.ts", + "line": 1, + "endLine": 1, + "severity": "medium", + "confidence": 1, + "category": "security", + "evidence": "With `diskRead: false` and `networkRead: true`, the builder condition is true. Since `diskWrite` is true, it selects `no-cache`. `applicationRequest` preserves that header and `transport` returns it without adding headers, so the value does not contain `no-store`.", + "suggestion": "Disable disk writes for this policy so the builder emits `no-cache, no-store`.", + "symbol": "policy", + "codeSnippet": "const policy = { diskRead: false, diskWrite: true, networkRead: true };", + "suggestedCode": "const policy = { diskRead: false, diskWrite: false, networkRead: true };", + "fingerprint": "fp-e5ed9555", + "semanticFingerprint": "sf-1edcf8f0" + } + ], + "request-transform-bypass": [ + { + "id": "media/request.ts:11:application-request-drops-cache-policy", + "title": "Application request drops the required no-store header", + "description": "`applicationRequest()` constructs a request with empty headers and never uses `middleware()`, which returns the request produced by `newRequest()`. That builder sets `Cache-Control` to `no-cache, no-store` for the configured policy. Consequently, `transport()` returns `undefined` for the application request and the downstream assertion fails.", + "file": "media/request.ts", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied fragment starts at line 1; the changed statement is at offset 10, so its line is 1 + 10 = 11. `middleware()` delegates to `newRequest()`, while `applicationRequest()` creates `{ headers: {} }`; `transport()` reads `request.headers[\"Cache-Control\"]`, which is absent on that request.", + "suggestion": "Build the application request using the middleware-produced headers so the required cache policy reaches the transport.", + "symbol": "applicationRequest", + "codeSnippet": "const request = { headers: {} };", + "fingerprint": "fp-dcfb2b05", + "semanticFingerprint": "sf-6a57ee42" + } + ], + "request-transform-overwrite": [ + { + "id": "media/request.ts:12:overwrites-no-store-header", + "title": "Downstream assignment removes the required no-store directive", + "description": "`newRequest()` sets `Cache-Control` to `no-cache, no-store` for the supplied policy. `applicationRequest()` then overwrites that value with `no-cache`, so `transport()` observes a header without `no-store` and `testTransport()` throws.", + "file": "media/request.ts", + "line": 12, + "endLine": 12, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "With `networkRead: true`, `diskRead: false`, and `diskWrite: false`, the builder produces `no-cache, no-store`. The changed assignment replaces it before the request reaches `transport()`.", + "suggestion": "Remove the downstream overwrite or preserve the policy-derived `no-store` directive.", + "symbol": "applicationRequest", + "codeSnippet": "request.headers[\"Cache-Control\"] = \"no-cache\";", + "fingerprint": "fp-4df97bd4", + "semanticFingerprint": "sf-158a1b67" + } + ], + "request-transform-mock": [ + { + "id": "media/request.ts:11:missing-no-store-header", + "title": "Production request omits the required no-store header", + "description": "`applicationRequest` creates an empty headers object, so the production call to `transport` receives no `Cache-Control` value. The test does not catch this: `testTransport` adds `no-cache, no-store` to the request before calling `transport`.", + "file": "media/request.ts", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "At line 11, `request.headers` is initialized empty. With the configured policy, `middleware()` supplies `Cache-Control: no-cache, no-store`, but production uses `applicationRequest()` directly and does not call the mutating test transport.", + "suggestion": "Initialize the production request using the policy-aware request builder so it carries the required header.", + "symbol": "applicationRequest", + "codeSnippet": "const request = { headers: {} };", + "suggestedCode": "const request = middleware();", + "fingerprint": "fp-a9d3a94e", + "semanticFingerprint": "sf-6a57ee42" + } + ], + "request-transform-utf8": [ + { + "id": "media/request.ts:28:truncates-utf8-sequence", + "title": "Byte truncation can make the preview invalid UTF-8", + "description": "The encoded string contains the two-byte UTF-8 sequence for “é”. Slicing to one byte keeps only its leading byte, so the unchanged fatal decoder throws instead of producing a valid UTF-8 preview.", + "file": "media/request.ts", + "line": 28, + "endLine": 28, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "For the input “é” (U+00E9), UTF-8 encoding yields bytes C3 A9. `slice(0, 1)` retains C3, which is an incomplete UTF-8 sequence; `TextDecoder(\"utf-8\", { fatal: true }).decode(preview)` rejects it.", + "suggestion": "Choose a truncation boundary that ends on a complete UTF-8 sequence before decoding.", + "codeSnippet": "const preview = encoded.slice(0, 1);", + "fingerprint": "fp-0107d05c", + "semanticFingerprint": "sf-445f6b6b" + } + ], + "generated-source-literal": [], + "generated-source-leading-newline": [], + "generated-source-escaped": [], + "generated-source-dedent": [], + "generated-source-wrong-literal": [ + { + "id": "coverage/generated_fixture.py:18:asserts-executed-line-uncovered", + "title": "Assertion expects an executed line to have zero coverage", + "description": "The test invokes `Route().route(4)`, so `checked` is 4 and the return on generated source line 6 executes. Since `ci` counts covered instructions mapped to that one-based source line, the assertion that its count is zero contradicts the exercised path.", + "file": "coverage/generated_fixture.py", + "line": 18, + "endLine": 18, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The literal witness maps `if (checked > 0) return 1` to Route.kt line 6; the JUnit input `route(4)` makes the condition true and executes the return. In the changed fragment, the origin is line 1 and the assertion is at zero-based offset 17, giving line 1 + 17 = 18.", + "suggestion": "Assert that the executed line has covered instructions.", + "symbol": "test_generated_counters", + "codeSnippet": "assert rows[6][\"ci\"] == 0", + "suggestedCode": "assert rows[6][\"ci\"] > 0", + "fingerprint": "fp-064f40d0", + "semanticFingerprint": "sf-36c4717b" + } + ], + "generated-source-wrong-leading-newline": [ + { + "id": "coverage/generated_fixture.py:19:asserts-zero-for-executed-line", + "title": "Assertion expects zero coverage on an executed line", + "description": "The generated Kotlin starts with a blank line, placing `if (checked > 0) return 1` on source line 7. The JUnit input calls `route(4)`, so that statement executes and line 7 has covered instructions. The assertion incorrectly expects its covered-instruction count to be zero.", + "file": "coverage/generated_fixture.py", + "line": 19, + "endLine": 19, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied literal line witness maps generated source line 7 to `if (checked > 0) return 1`, and `route(4)` makes the condition true. In the changed fragment, the first displayed line is the origin (line 1); the assertion is at zero-based offset 18, so 1 + 18 = line 19.", + "suggestion": "Assert that line 7 has covered instructions.", + "symbol": "test_generated_counters", + "codeSnippet": "assert rows[7][\"ci\"] == 0", + "suggestedCode": "assert rows[7][\"ci\"] > 0", + "fingerprint": "fp-4593504a", + "semanticFingerprint": "sf-bd7bdd1c" + } + ], + "generated-literal-independent-shell": [ + { + "id": "coverage/literal_handler.py:5:shell-command-injection", + "title": "Untrusted path enables shell command injection", + "description": "The handler concatenates the untrusted HTTP query parameter into a command string and executes it with `shell=True`. A value containing shell metacharacters can run additional commands.", + "file": "coverage/literal_handler.py", + "line": 5, + "endLine": 5, + "severity": "high", + "confidence": 0.99, + "category": "security", + "evidence": "In the supplied changed fragment, whose first displayed line is 1, the exact return statement is at zero-based offset 4; 1 + 4 = line 5. `user_path` is the untrusted HTTP query value, and the statement passes its concatenation into `subprocess.run` with `shell=True`, allowing shell metacharacters to alter the command.", + "suggestion": "Pass arguments as a list and leave shell execution disabled.", + "symbol": "export_report", + "codeSnippet": "return subprocess.run(\"cat \" + user_path, shell=True, check=True)", + "suggestedCode": "return subprocess.run([\"cat\", \"--\", user_path], check=True)", + "fingerprint": "fp-f56c9853", + "semanticFingerprint": "sf-8cceec26" + } + ], + "generated-literal-independent-contract": [ + { + "id": "coverage/literal_validator.py:5:zero-count-accepted", + "title": "Zero is accepted despite the positive-count contract", + "description": "The changed comparison accepts a count of 0, contrary to the documented requirement that counts be strictly positive.", + "file": "coverage/literal_validator.py", + "line": 6, + "endLine": 6, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "In the supplied fragment starting at line 1, the changed `return count >= 0` is at zero-based displayed-line offset 5, so 1 + 5 = line 6. For count 0, the comparison returns true, violating the strictly positive contract.", + "suggestion": "Use a strict greater-than comparison.", + "symbol": "accepts_count", + "codeSnippet": "return count >= 0", + "suggestedCode": "return count > 0", + "fingerprint": "fp-a1bb4ff3", + "semanticFingerprint": "sf-aef99a54" + } + ], + "session-source-signed-bootstrap": [], + "session-source-storage-alias": [], + "session-source-opaque-bootstrap": [ + { + "id": "e2e/owned-session.spec.ts:30:opaque-token-rejected", + "title": "Assertion rejects the selected opaque token", + "description": "The configured setup is `opaque.setup.ts`, which stores `opaque-token-response` as the access token. Its expiry is 10000, later than the test clock 1000, so the refresh branch does not replace it. The resulting header is `[REDACTED_SECRET]`, which does not match the three-segment token pattern; this assertion fails for the selected setup.", + "file": "e2e/owned-session.spec.ts", + "line": 30, + "endLine": 30, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The selected `opaqueSetup` persists the mocked endpoint's `access_token` value, `opaque-token-response`. The expiry guard is false at the fixed clock, so the added assertion receives `[REDACTED_SECRET]`. The supplied fragment starts at line 1; the assertion is at zero-based offset 29, giving line 30.", + "suggestion": "Assert the header expected from the selected opaque setup, or select the signed setup if the test requires a compact token.", + "symbol": "assert.match", + "codeSnippet": "assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "suggestedCode": "assert.equal(authorization, \"[REDACTED_SECRET]\");", + "fingerprint": "fp-c92562f6", + "semanticFingerprint": "sf-f98032ca" + } + ], + "session-source-expired-refresh": [ + { + "id": "e2e/owned-session.spec.ts:30:expiry-token-shape", + "title": "Assertion rejects the selected expiry response", + "description": "The configured signed setup stores expires_at as 10000, which is earlier than testClock 20000. The expiry guard therefore replaces the signed token with mockedTokenEndpoint()'s access_token, \"opaque-token-response\". The resulting authorization header is \"[REDACTED_SECRET]\", which does not match the three-segment token pattern, so this assertion fails on the selected path.", + "file": "e2e/owned-session.spec.ts", + "line": 30, + "endLine": 30, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The selected setup is signed.setup.ts; its session expires at 10000, and the fixed clock is 20000. The reached expiry branch uses the mock response whose access_token is \"opaque-token-response\". That value has no dot-separated segments, so the newly added regex rejects it.", + "suggestion": "Align the assertion with the selected expiry response, or have the expiry-path mock return a token that satisfies the asserted format.", + "symbol": "assert.match", + "codeSnippet": "assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "fingerprint": "fp-6c21326e", + "semanticFingerprint": "sf-f98032ca" + } + ], + "session-source-prefix-gap": [ + { + "id": "e2e/owned-session.spec.ts:29:missing-bearer-space", + "title": "Authorization header omits the required space", + "description": "The selected setup is `signed.setup.ts`, which stores a compact three-segment token. Concatenating it directly after `Bearer` produces a header that cannot match the next line’s required `Bearer ` prefix, so the assertion fails.", + "file": "e2e/owned-session.spec.ts", + "line": 29, + "endLine": 29, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The added statement forms `Bearer`, while the following assertion requires `Bearer `. Counting the supplied fragment from origin 1 gives target offset 28 and line 29.", + "suggestion": "Add a space after `Bearer` when constructing the header.", + "codeSnippet": "const authorization = \"Bearer\" + accessToken;", + "suggestedCode": "const authorization = \"Bearer \" + accessToken;", + "fingerprint": "fp-b818b32b", + "semanticFingerprint": "sf-1c21e885" + } + ], + "session-source-setup-unavailable": [], + "unittest-discovery-delegated-wildcard": [], + "unittest-discovery-nested-working-directory": [], + "unittest-discovery-literal-argv-pattern": [], + "unittest-discovery-excluded-by-pattern": [ + { + "id": ".github/scripts/tests/run_manifest_tests.py:9:discovery-excludes-export-tests", + "title": "Discovery omits the required export tests", + "description": "The runner’s discovery command selects only `test_manifest_core.py`, so it does not discover the required `test_manifest_export.py` module. The CI verification therefore misses those tests when invoked through this runner or its delegates.", + "file": ".github/scripts/tests/run_manifest_tests.py", + "line": 12, + "endLine": 12, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "In the supplied fragment, whose first displayed line is line 1, the exact changed return statement is at zero-based displayed-line offset 11, giving line 12 (1 + 11 = 12). With `cwd=ROOT` and `-s .github/scripts/tests`, the `-p test_manifest_core.py` pattern selects the core test file and excludes the required export test file.", + "suggestion": "Use a discovery pattern that matches both required manifest test modules.", + "symbol": "command", + "codeSnippet": "return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_core.py\", \"-v\"]", + "suggestedCode": "return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_*.py\", \"-v\"]", + "fingerprint": "fp-efef59cf", + "semanticFingerprint": "sf-e06cf7ba" + } + ], + "unittest-discovery-wrong-start-directory": [ + { + "id": ".github/scripts/tests/run_manifest_tests.py:12:discovery omits required manifest tests", + "title": "Discovery skips both required manifest test modules", + "description": "The runner starts unittest discovery in `backend/checks`, so it cannot discover the required manifest test modules under `.github/scripts/tests`. It can run the unrelated health test while leaving both required modules untested.", + "file": ".github/scripts/tests/run_manifest_tests.py", + "line": 12, + "endLine": 12, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The supplied fragment starts at line 1. The changed return statement is at zero-based displayed-line offset 11, so 1 + 11 = line 12. With `cwd=ROOT`, discovery starts at the repository-root `backend/checks` directory and the `test_manifest_*.py` pattern selects only matching files within that discovery tree. The required `test_manifest_core.py` and `test_manifest_export.py` modules are in `.github/scripts/tests`, outside that tree, so the configured verification omits them.", + "suggestion": "Set the discovery start directory to `.github/scripts/tests` so both required modules are selected.", + "symbol": "command", + "codeSnippet": "return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \"backend/checks\", \"-p\", \"test_manifest_*.py\", \"-v\"]", + "suggestedCode": "return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_*.py\", \"-v\"]", + "fingerprint": "fp-e5f25b08", + "semanticFingerprint": "sf-4b3375b9" + } + ], + "unittest-discovery-runner-unavailable": [], + "kotlin-json-implicit-nullable-omission": [], + "kotlin-json-explicit-nullable-omission": [ + { + "id": "backend/OwnedRequest.kt:11:omitted-nullable-field-rejected", + "title": "Omitted nullable field is rejected", + "description": "The payload contains `name` but omits `nullable`. Since `OwnedRequest.nullable` has no default and `probeJson` uses `explicitNulls = true`, decoding throws for the missing field, so `acceptedRequest()` fails instead of accepting the documented input.", + "file": "backend/OwnedRequest.kt", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The added statement decodes `{\"name\":\"Owned\"}` using `probeJson`; the nullable property has no default, and no exception handler converts the failure. From fragment origin 1, the added statement is at offset 10, giving line 11.", + "suggestion": "Configure this decode with `explicitNulls = false`, or give `nullable` a default of `null`.", + "symbol": "acceptedRequest", + "codeSnippet": "val decoded = probeJson.decodeFromString(raw)", + "suggestedCode": "val decoded = Json(probeJson) { explicitNulls = false }.decodeFromString(raw)", + "fingerprint": "fp-c5bea6ea", + "semanticFingerprint": "sf-5182df2a" + } + ], + "kotlin-json-implicit-missing-nonnullable": [ + { + "id": "backend/OwnedRequest.kt:11:missing-required-name", + "title": "Missing required `name` makes the accepted request fail", + "description": "`acceptedRequest` decodes `{\"nullable\":null}`, which omits the non-nullable `name` property. `OwnedRequest.name` has no default, so decoding fails with a missing-field error before the function can return. Setting `explicitNulls = false` affects omitted nullable fields; it does not make this required non-nullable field optional.", + "file": "backend/OwnedRequest.kt", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The payload at line 10 contains only `nullable`. `probeJson` is constructed from `serverJson` with `explicitNulls = false`, while `OwnedRequest.name` is non-nullable and has no default. The changed decode at line 11 therefore rejects the documented input.", + "suggestion": "Give `name` an appropriate default if this input is meant to omit it, or revise the accepted-input contract to require the field.", + "symbol": "acceptedRequest", + "codeSnippet": "val decoded = probeJson.decodeFromString(raw)", + "fingerprint": "fp-4bf5a0bf", + "semanticFingerprint": "sf-5182df2a" + } + ], + "kotlin-json-implicit-nullable-default": [], + "kotlin-json-explicit-nullable-default": [], + "kotlin-json-inherited-implicit-policy": [], + "kotlin-json-different-instance-policy": [ + { + "id": "backend/OwnedRequest.kt:11:decode-uses-strict-json-instance", + "title": "Decode uses a Json instance that rejects the documented payload", + "description": "acceptedRequest decodes with serverJson, which has explicitNulls=true. The payload omits nullable, but OwnedRequest.nullable has no default, so this decode rejects the input instead of returning its decoded value. probeJson is configured with explicitNulls=false but is not used here.", + "file": "backend/OwnedRequest.kt", + "line": 11, + "endLine": 11, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The literal fragment defines `val serverJson = Json { explicitNulls = true }` and `data class OwnedRequest(val name: String, val nullable: String?)`; the payload is `{\"name\":\"Owned\"}`. The decode call at line 11 uses serverJson. The numbered literal witness from fragment origin 1 places this call on line 11.", + "suggestion": "Use probeJson for this decode so the instance's explicitNulls=false setting applies.", + "symbol": "acceptedRequest", + "codeSnippet": "val decoded = serverJson.decodeFromString(raw)", + "suggestedCode": "val decoded = probeJson.decodeFromString(raw)", + "fingerprint": "fp-8aed4aa9", + "semanticFingerprint": "sf-3f612c8b" + } + ], + "kotlin-json-unavailable-policy": [], + "ktor-routing-installed-root": [], + "ktor-routing-delegated-root": [], + "ktor-routing-configured-root": [], + "ktor-routing-child-subtree": [ + { + "id": "backend/OwnedRoutingSelection.kt:6:selects-child-instead-of-root", + "title": "Selects the child instead of the installed root", + "description": "`installed.children.single()` selects the sole `/owned` child, not the `RoutingRoot` returned by `app.routing`. The following identity check therefore fails, so `selectForExport` throws instead of returning the complete installed root.", + "file": "backend/OwnedRoutingSelection.kt", + "line": 6, + "endLine": 6, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The setup installs one `/owned` child. `selected` is that child, while the next line requires `selected === installed`; the check fails before the function returns.", + "suggestion": "Select the installed root itself to satisfy the caller’s identity requirement.", + "symbol": "selectForExport", + "codeSnippet": "val selected = installed.children.single()", + "suggestedCode": "val selected = installed", + "fingerprint": "fp-9f7e3acb", + "semanticFingerprint": "sf-956e20c9" + } + ], + "ktor-routing-different-application": [ + { + "id": "backend/OwnedRoutingSelection.kt:5:selects-root-from-different-application", + "title": "Selects a different application's routing root", + "description": "`app.routing { route(\"/owned\") {} }` installs and returns the routing root owned by `app`. Calling `otherApp.routing {}` selects or installs a separate root because `otherApp` is a distinct application, so the identity check fails and `selectForExport` throws instead of returning the installed root.", + "file": "backend/OwnedRoutingSelection.kt", + "line": 5, + "endLine": 5, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The supplied fragment starts at line 1; the changed statement is at zero-based offset 4, so its line is 1 + 4 = 5. The stated Ktor 3.0.2 contract returns the root for the receiver application, and the scenario specifies distinct `app` and `otherApp` instances.", + "suggestion": "Use the root already returned by the installation call.", + "symbol": "selectForExport", + "codeSnippet": "val selected = otherApp.routing {}", + "suggestedCode": "val selected = installed", + "fingerprint": "fp-620ac1e2", + "semanticFingerprint": "sf-4fad4822" + } + ], + "ktor-routing-unavailable-implementation": [], + "py-pep758-314-two": [], + "py-pep758-314-three": [], + "py-pep758-314-group": [], + "py-pep758-314-parenthesized-as": [], + "py-pep758-313-list": [ + { + "id": "backend/owned_handlers.py:4:unsupported-except-syntax", + "title": "Exception clause is invalid on supported Python versions", + "description": "The project supports Python 3.13, but this unparenthesized exception list requires Python 3.14. On Python 3.13, the module fails to parse, so `catch_owned` cannot run.", + "file": "backend/owned_handlers.py", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The configured `requires-python` range is `>=3.13,<3.14`. In the supplied fragment, the first displayed line is line 1; the changed clause is at zero-based offset 3, so 1 + 3 = line 4. That clause is not valid exception syntax on the supported Python 3.13 runtime.", + "suggestion": "Use a parenthesized tuple of exception types.", + "symbol": "catch_owned", + "codeSnippet": "except ValueError, TypeError:", + "suggestedCode": "except (ValueError, TypeError):", + "fingerprint": "fp-aeccfb47", + "semanticFingerprint": "sf-5a9df965" + } + ], + "py-pep758-313-group": [ + { + "id": "backend/owned_handlers.py:4:unsupported-except-star-syntax", + "title": "Exception clause is invalid on the supported Python versions", + "description": "The project declares Python support as >=3.13,<3.14, but this unparenthesized multiple-type except* clause requires Python 3.14. On supported Python 3.13, the module fails to parse before catch_owned can run.", + "file": "backend/owned_handlers.py", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.99, + "category": "reliability", + "evidence": "The effective requires-python range is >=3.13,<3.14. Python 3.13 does not accept this clause; Python 3.14's PEP 758 grammar does. The displayed fragment starts at line 1, and the clause is at zero-based offset 3, so 1 + 3 = line 4.", + "suggestion": "Parenthesize the exception types to keep the clause valid on Python 3.13.", + "symbol": "catch_owned", + "codeSnippet": "except* ValueError, TypeError:", + "suggestedCode": "except* (ValueError, TypeError):", + "fingerprint": "fp-2fb804f0", + "semanticFingerprint": "sf-cfe648a7" + } + ], + "py-pep758-314-list-as": [ + { + "id": "backend/owned_handlers.py:4:invalid-except-alias-syntax", + "title": "Exception types need parentheses when bound with `as`", + "description": "The changed clause is invalid Python syntax: multiple exception types must be parenthesized when the handler binds them with `as`. The configured Python requirement is `>=3.14,<3.15`, so the clause prevents this module from parsing on the supported runtime.", + "file": "backend/owned_handlers.py", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The changed clause is `except ValueError, TypeError as error:`. Python 3.14 permits unparenthesized multiple exception types only without an `as` binding. In the displayed fragment, the origin is line 1 and this clause has zero-based offset 3, so 1 + 3 = line 4.", + "suggestion": "Parenthesize the exception types before the alias.", + "symbol": "catch_owned", + "codeSnippet": "except ValueError, TypeError as error:", + "suggestedCode": "except (ValueError, TypeError) as error:", + "fingerprint": "fp-00924920", + "semanticFingerprint": "sf-091103b5" + } + ], + "py-pep758-314-group-as": [ + { + "id": "backend/owned_handlers.py:4:invalid-except-star-alias", + "title": "Invalid exception-group syntax prevents the module from parsing", + "description": "The clause lists multiple exception types and binds them with `as` without parentheses. Under Python 3.14, this form is invalid syntax. The configured Python range is `>=3.14,<3.15`, so the changed handler cannot be parsed on the supported interpreter range.", + "file": "backend/owned_handlers.py", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "In the displayed changed fragment, the source origin is line 1 and the exact clause has zero-based offset 3, so 1 + 3 = line 4. Python 3.14 permits an unparenthesized exception-type list without an `as` target; with `as`, multiple types must be parenthesized. The configured `requires-python` range confirms Python 3.14 is the target.", + "suggestion": "Parenthesize the exception types before the `as` target.", + "symbol": "catch_owned", + "codeSnippet": "except* ValueError, TypeError as error:", + "suggestedCode": "except* (ValueError, TypeError) as error:", + "fingerprint": "fp-678fb46d", + "semanticFingerprint": "sf-36dcdbe7" + } + ], + "py-pep758-mixed-range": [ + { + "id": "backend/owned_handlers.py:4:unsupported-python-3.13-exception-syntax", + "title": "Exception syntax excludes supported Python 3.13", + "description": "This exception clause is accepted by Python 3.14 but not Python 3.13, which remains in the project's declared supported range. Python 3.13 therefore cannot parse this module.", + "file": "backend/owned_handlers.py", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The project requires Python >=3.13,<3.15, so Python 3.13 is supported. The independent parser observation establishes parsing under CPython 3.14.6 only. In the changed fragment starting at line 1, the function declaration is offset 0, `try` offset 1, `raise` offset 2, and the exception clause offset 3; 1 + 3 = line 4. Python 3.13 does not accept this unparenthesized multiple-exception syntax.", + "suggestion": "Parenthesize the exception types to retain compatibility with Python 3.13.", + "symbol": "catch_owned", + "codeSnippet": "except ValueError, TypeError:", + "suggestedCode": "except (ValueError, TypeError):", + "fingerprint": "fp-d648f3a2", + "semanticFingerprint": "sf-5a9df965" + } + ], + "py-pep758-unknown-range": [], + "py-pep758-stale-parser": [], + "py-pep758-unbound-handler": [ + { + "id": "backend/owned_handlers.py:4:undefined-exception-name", + "title": "Undefined exception name breaks the handler", + "description": "When a ValueError reaches this clause, Python must resolve both exception types to decide whether it matches. MissingError is neither defined nor imported, so resolving it raises NameError and the handler does not handle the ValueError.", + "file": "backend/owned_handlers.py", + "line": 4, + "endLine": 4, + "severity": "medium", + "confidence": 0.99, + "category": "correctness", + "evidence": "The changed fragment starts at line 1. The clause is at zero-based displayed-line offset 3, so 1 + 3 = line 4. The configured Python range is >=3.14,<3.15, where this comma-separated except syntax parses; the defect is the unresolved MissingError name during exception matching.", + "suggestion": "Remove MissingError from the clause or define/import the intended exception class.", + "symbol": "catch_owned", + "codeSnippet": "except ValueError, MissingError:", + "suggestedCode": "except ValueError:", + "fingerprint": "fp-8bf92113", + "semanticFingerprint": "sf-b38461f0" + } + ], + "snapshot-recovery-explicit-retain": [], + "snapshot-recovery-disposable-retain": [ + { + "id": "owned/snapshot_contract.py:62:failed-staging-not-removed", + "title": "Failed staging directory is left behind", + "description": "On the copy-failure path, `stage_payload` writes `part-a.bin` and raises `CopyFailure`, which is caught by `except OSError`. The bare re-raise leaves the newly created, unpublished staging directory in place, blocking a retry. The selected contract requires removing failed disposable staging while the lease still owns it.", + "file": "owned/snapshot_contract.py", + "line": 62, + "endLine": 62, + "severity": "medium", + "confidence": 1, + "category": "reliability", + "evidence": "The supplied probe reports `directoryPresent: true`, `declaredPublished: false`, `filesAfterFirstCall: [\"part-a.bin\"]`, `retryBlocked: true`, and `leaseStillOwned: true`. In the displayed fragment, the origin is line 56 and the exact `raise` statement is at zero-based offset 6, so 56 + 6 = line 62. The copy failure occurs before publication, and the selected contract requires this owned staging directory to be removed.", + "suggestion": "Remove the newly created staging directory before re-raising, while the lease still owns it.", + "symbol": "retained_snapshot", + "codeSnippet": "raise", + "fingerprint": "fp-2d55be00", + "semanticFingerprint": "sf-dbe5f7a3" + } + ], + "snapshot-recovery-disposable-clean": [], + "snapshot-recovery-published-report": [], + "snapshot-recovery-published-cleanup": [ + { + "id": "owned/snapshot_contract.py:84:deletes-published-bundle", + "title": "Deletes the published bundle when output reporting fails", + "description": "After the manifest is published, `report_snapshot` raises `PublishedOutputFailure`, which is an `OSError`. The handler catches it and removes the destination, violating the contract that a valid published bundle must remain when output reporting fails.", + "file": "owned/snapshot_contract.py", + "line": 84, + "endLine": 84, + "severity": "high", + "confidence": 1, + "category": "correctness", + "evidence": "In the changed fragment beginning at line 77, the `report_snapshot(...)` call is at offset 5 and the `except OSError` handler catches its `PublishedOutputFailure` (defined as an `OSError` subclass); the deletion is at offset 7, so 77 + 7 = 84. The probe reports `declaredPublished=true`, `directoryPresent=false`, and `filesAfterFirstCall=[]`, confirming published data loss on this path. The contract requires preserving the valid bundle after reporting failure.", + "suggestion": "Remove the destination deletion from this handler and re-raise the reporting failure so published output remains available.", + "symbol": "published_snapshot_deleted", + "codeSnippet": "shutil.rmtree(destination)", + "fingerprint": "fp-c3c9b4db", + "semanticFingerprint": "sf-6fbab33b" + } + ], + "snapshot-recovery-existing-destination": [ + { + "id": "owned/snapshot_contract.py:90:deletes-existing-snapshot", + "title": "Retry deletes retained snapshot evidence", + "description": "When a destination already exists, this statement deletes it before retrying. That violates the contract to preserve incomplete destinations for inspection and refuse retries that find an existing destination. The supplied probe confirms the retry proceeds and prior evidence is lost.", + "file": "owned/snapshot_contract.py", + "line": 90, + "endLine": 90, + "severity": "high", + "confidence": 1, + "category": "correctness", + "evidence": "The changed fragment starts at line 88. The deletion is at zero-based displayed-line offset 2, so 88 + 2 = 90. On the selected retry path, the contract requires refusing an existing destination; this operation removes its evidence before calling retained_snapshot. The supplied probe reports retryBlocked: false and priorEvidencePreserved: false.", + "suggestion": "Raise an error when the destination already exists, preserving the bundle and refusing the retry.", + "symbol": "overwrite_existing_snapshot", + "codeSnippet": "shutil.rmtree(destination)", + "suggestedCode": "raise FileExistsError(f\"Snapshot destination already exists: {destination}\")", + "fingerprint": "fp-85eb447f", + "semanticFingerprint": "sf-6fbab33b" + } + ], + "snapshot-recovery-changed-ownership": [], + "snapshot-recovery-policy-unavailable": [], + "snapshot-recovery-incomplete-manifest": [], + "snapshot-recovery-completed-destination": [ + { + "id": "owned/snapshot_contract.py:90:deletes-published-bundle-before-retry", + "title": "Deletes the existing published bundle before retrying", + "description": "When a retry finds an existing destination, this operation deletes it and proceeds with a replacement. If copying then fails, the valid published bundle is lost and only an incomplete destination remains. This violates the contract to refuse retries when a destination exists and preserve published data.", + "file": "owned/snapshot_contract.py", + "line": 90, + "endLine": 90, + "severity": "high", + "confidence": 1, + "category": "correctness", + "evidence": "In the changed fragment starting at source line 88, the exact operation is at zero-based displayed-line offset 2, so 88 + 2 = 90. The selected copy-failure path removes the existing destination, creates a new one, writes part-a.bin, and raises CopyFailure. The supplied fixed-probe observation confirms the manifest was valid before the call, invalid afterward, and priorEvidencePreserved was false. The contract requires refusing the retry and preserving the published bundle.", + "suggestion": "Refuse the retry when the destination already exists instead of deleting it.", + "symbol": "overwrite_existing_snapshot", + "codeSnippet": "shutil.rmtree(destination)", + "suggestedCode": "raise FileExistsError(destination)", + "fingerprint": "fp-73a10497", + "semanticFingerprint": "sf-6fbab33b" + } + ], + "fixture-values-db-file-parent": [], + "fixture-values-db-file-peer": [ + { + "id": "owned/test_fixture_values.py:89:asserts-rejection-is-false", + "title": "Assertion expects the opposite of the observed rejection", + "description": "The fixture uses the default `directory=False`, so the database file is `tmp_path / \"database\"` and its parent is `tmp_path`. The `.owned` marker is under that source root, and `tmp_path / \"snapshot\"` is inside it. `snapshot` raises `ValueError(\"destination_inside_source\")`, which `destination_rejected` catches and converts to `True`; the assertion therefore fails.", + "file": "owned/test_fixture_values.py", + "line": 89, + "endLine": 89, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The changed fragment starts at line 84. The assertion is at zero-based displayed-line offset 5, so 84 + 5 = 89. The supplied fixed-probe observations also record `databaseIsFile=true`, `sourceRoot=\".\"`, and `rejected=true`, consistent with the fixture and helper path.", + "suggestion": "Assert the observed rejection result.", + "symbol": "test_file_source_peer", + "codeSnippet": "assert rejected is False", + "suggestedCode": "assert rejected is True", + "fingerprint": "fp-64642884", + "semanticFingerprint": "sf-c621d179" + } + ], + "fixture-values-db-directory-peer": [], + "fixture-values-db-directory-child": [ + { + "id": "owned/test_fixture_values.py:105:incorrect-rejection-assertion", + "title": "Assertion expects the wrong rejection result", + "description": "With `directory=True`, the database path is `tmp_path/database/state.sqlite`, making `tmp_path/database` the source root. The helper creates `.owned` in that root, and `snapshot` raises `destination_inside_source` for the nested `snapshot` destination. `destination_rejected` catches that error and returns `True`, contradicting the assertion that `rejected` is false.", + "file": "owned/test_fixture_values.py", + "line": 105, + "endLine": 105, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "The supplied fixed execution records `databaseIsFile=true`, `sourceRoot=database`, and `rejected=true`, consistent with the constructor and helper path. In the changed fragment beginning at line 100, the exact assertion has zero-based offset 5, so 100 + 5 = line 105.", + "suggestion": "Assert that the destination was rejected.", + "symbol": "test_directory_source_child", + "codeSnippet": "assert rejected is False", + "suggestedCode": "assert rejected is True", + "fingerprint": "fp-f40373ac", + "semanticFingerprint": "sf-c621d179" + } + ], + "fixture-values-ids-default-asc": [], + "fixture-values-ids-default-inverted": [ + { + "id": "owned/test_fixture_values.py:128:assertion-order-mismatch", + "title": "Assertion expects the wrong SQLite sort order", + "description": "The query sorts request IDs ascending. With the inserted IDs `request` and `b`, the observed result is `(\"b\", \"request\")`, but the assertion expects `(\"request\", \"b\")`, so it fails.", + "file": "owned/test_fixture_values.py", + "line": 128, + "endLine": 128, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "`request()` sets `a.request_id` to `request`, and `replace()` sets `b.request_id` to `b`. `pending(now=50)` filters both pending rows because each expires at 100, then orders IDs ascending; the supplied observation confirms the result is `(\"b\", \"request\")`. The changed fragment starts at line 120; the assertion is at zero-based offset 8, so 120 + 8 = 128.", + "suggestion": "Assert the observed ascending order.", + "symbol": "test_default_id_alternate_order", + "codeSnippet": "assert result == (a.request_id, b.request_id)", + "suggestedCode": "assert result == (b.request_id, a.request_id)", + "fingerprint": "fp-8c4e0f02", + "semanticFingerprint": "sf-3bcf1109" + } + ], + "fixture-values-ids-override-asc": [], + "fixture-values-ids-override-inverted": [ + { + "id": "owned/test_fixture_values.py:150:assertion-expects-wrong-order", + "title": "Assertion expects the wrong order", + "description": "The test stores requests with IDs `a` and `b`. Both have pending state and expiry 100, so both pass `expires > 50`. `pending` defaults to ascending order with a limit of 10, and the supplied observation confirms the result is `(\"a\", \"b\")`. The assertion instead expects `(\"b\", \"a\")` and fails.", + "file": "owned/test_fixture_values.py", + "line": 150, + "endLine": 150, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "In the displayed changed fragment, the origin is line 142 and the assertion is at zero-based offset 8, so 142 + 8 = 150. The query orders by `request_id ASC` by default; both inserted rows satisfy its state and expiry predicates, and the supplied observation records `['a','b']`. The assertion's expected tuple is `('b','a')`.", + "suggestion": "Assert the ascending result order.", + "symbol": "test_overridden_id_alternate_order", + "codeSnippet": "assert result == (b.request_id, a.request_id)", + "suggestedCode": "assert result == (a.request_id, b.request_id)", + "fingerprint": "fp-42f204e0", + "semanticFingerprint": "sf-72697a2d" + } + ], + "fixture-values-ids-default-desc": [], + "fixture-values-ids-desc-inverted": [ + { + "id": "owned/test_fixture_values.py:172:descending assertion", + "title": "Descending-order assertion expects the wrong ID order", + "description": "The fixture stores IDs `request` and `b`; both rows satisfy the pending and expiry filters. `ORDER BY request_id DESC` puts `request` before `b`, matching the supplied result observation, so this assertion expects the reverse order and fails.", + "file": "owned/test_fixture_values.py", + "line": 172, + "endLine": 172, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "In the supplied fragment beginning at line 164, the assertion is at zero-based displayed-line offset 8, so 164 + 8 = 172. `request()` assigns `request_id=\"request\"`; `replace` assigns `b.request_id=\"b\"`. Both expire at 100 and have state `pending`; with `now=50`, both pass the query filters. Descending text order and the supplied observation give `(request, b)`, contradicting the asserted `(b, request)`.", + "suggestion": "Assert `a.request_id` followed by `b.request_id`.", + "symbol": "test_descending_alternate_order", + "codeSnippet": "assert result == (b.request_id, a.request_id)", + "suggestedCode": "assert result == (a.request_id, b.request_id)", + "fingerprint": "fp-a48692f0", + "semanticFingerprint": "sf-72697a2d" + } + ], + "fixture-values-ids-filtered": [], + "fixture-values-ids-unfiltered": [ + { + "id": "owned/test_fixture_values.py:196:assertion-expects-filtered-results", + "title": "Assertion expects filtered results from an unfiltered query", + "description": "The assertion expects only the active request, but `unfiltered` selects every row in ascending `request_id` order without filtering by expiry or state. The inserted IDs sort as `expired`, `request`, `terminal`, so the assertion contradicts the query result.", + "file": "owned/test_fixture_values.py", + "line": 196, + "endLine": 196, + "severity": "medium", + "confidence": 1, + "category": "correctness", + "evidence": "In the changed fragment, origin line 187 plus zero-based displayed-line offset 9 equals line 196, where this assertion appears. `active.request_id` is `request`; `unfiltered` includes all three inserted rows and orders them ascending. The supplied data observation confirms the result is `(\"expired\", \"request\", \"terminal\")`, so this assertion fails.", + "suggestion": "Assert the complete tuple returned by the unfiltered query.", + "symbol": "test_pending_alternate_query", + "codeSnippet": "assert result == (active.request_id,)", + "suggestedCode": "assert result == (\"expired\", \"request\", \"terminal\")", + "fingerprint": "fp-ff7ea373", + "semanticFingerprint": "sf-692741c7" + } + ] + } +} diff --git a/quality/bugbot/evidence/issue-971/prior-03f8e6e3-score.json b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-score.json new file mode 100644 index 000000000..52bd9bd9e --- /dev/null +++ b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-score.json @@ -0,0 +1,28 @@ +{ + "complete": true, + "completed": 174, + "passed": false, + "githubWriteAttempts": 0, + "workspaceUnchanged": true, + "score": { + "metrics": { + "expected": 80, + "actual": 83, + "matched": 73, + "precision": 0.8795180722891566, + "recall": 0.9125, + "locationAccuracy": 0.9041095890410958, + "severityAccuracy": 0.9315068493150684, + "categoryAccuracy": 1, + "f1": 0.8957055214723926, + "falsePositives": 10, + "falseNegatives": 7, + "meanLineDistance": 0.1643835616438356, + "confidenceBrierScore": 0.11406506024096379 + }, + "violations": [ + "precision 0.880 is below 0.900" + ], + "missingCases": [] + } +} diff --git a/quality/bugbot/evidence/issue-971/prior-03f8e6e3-start.json b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-start.json new file mode 100644 index 000000000..e7d6f5e17 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/prior-03f8e6e3-start.json @@ -0,0 +1,16 @@ +{ + "event": "start", + "at": "2026-11-18T05:20:48.331Z", + "cli": "codex-cli 0.169.1", + "configuration": { + "provider": "codex", + "modelProvider": "openai", + "model": "gpt-6-luna", + "effort": "xhigh" + }, + "plan": "dcb54936d1d445b16e90265dd41e333b6ca4729faed278c1c8e7e1b3ba7946a6", + "runner": "728e8c6dcd5e6c771d99db471d46284e5364c70977fc645e0ac86f5c6345d95a", + "implementation": "03f8e6e33047333797ea37ad5e85bc756db223fa", + "corpus": "640c3355aeb65c1b15454bd7f9242fa36acc12b8b3f5ef284ee06af8af36c6c6", + "gitHubMutationPorts": 0 +} diff --git a/quality/bugbot/evidence/issue-971/score-and-rows.json b/quality/bugbot/evidence/issue-971/score-and-rows.json new file mode 100644 index 000000000..99ef2a693 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/score-and-rows.json @@ -0,0 +1,478 @@ +{ + "schemaVersion": 1, + "method": "unchanged public evaluator; independent causal assessments remain separate", + "implementation": "d26d0d6cd633c3aa313ddd21235fe985860b4104", + "priorImplementation": "03f8e6e33047333797ea37ad5e85bc756db223fa", + "corpusSha256": "640c3355aeb65c1b15454bd7f9242fa36acc12b8b3f5ef284ee06af8af36c6c6", + "currentLedgerSha256": "68907c3ddcb72b71f76ea650011408e89f9714577eee33c6a66442e4257ebbf5", + "priorPredictionsSha256": "570881b101d42282aeb062be50d0aaf372b32f47a91aa0c94cc07b6713b53580", + "score": { + "metrics": { + "expected": 80, + "actual": 86, + "matched": 69, + "precision": 0.8023255813953488, + "recall": 0.8625, + "locationAccuracy": 0.9130434782608695, + "severityAccuracy": 0.9565217391304348, + "categoryAccuracy": 1, + "f1": 0.8313253012048193, + "falsePositives": 17, + "falseNegatives": 11, + "meanLineDistance": 0.08695652173913043, + "confidenceBrierScore": 0.18831162790697673 + }, + "violations": [ + "precision 0.802 is below 0.900", + "f1 0.831 is below 0.870", + "confidenceBrierScore 0.188 exceeds 0.160" + ], + "missingCases": [] + }, + "priorScore": { + "metrics": { + "expected": 80, + "actual": 83, + "matched": 73, + "precision": 0.8795180722891566, + "recall": 0.9125, + "locationAccuracy": 0.9041095890410958, + "severityAccuracy": 0.9315068493150684, + "categoryAccuracy": 1, + "f1": 0.8957055214723926, + "falsePositives": 10, + "falseNegatives": 7, + "meanLineDistance": 0.1643835616438356, + "confidenceBrierScore": 0.11406506024096379 + }, + "violations": [ + "precision 0.880 is below 0.900" + ], + "missingCases": [] + }, + "rows": [ + { + "case": "sql-bounded-query", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "queries/audit.sql:4:non-deterministic-limit-order", + "findingSha256": "277c9a99666ae3f2ef13cfb577c5889303bfe152ce732cd98dad24c1e631bb4c", + "classification": "unresolved", + "reason": "The prediction needs tied created_at values and a required stable boundary. The scenario calls the order deterministic, but supplies no schema or uniqueness constraint to establish or refute ties. The conditional SQL concern is not independently proven for the declared fixture.", + "evidence": [ + "No schema or tie witness is supplied; expected=[] is a scorer label, not independent proof." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Obtain the authored schema/ordering contract before proposing either a detector change or a corpus correction." + }, + { + "case": "rust-unchecked-input", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "src/http/limit.rs:27:malformed-limit-panics", + "findingSha256": "57aec013e45c60dc529d7c03205e629c70442f0cfe73bbe614a9e69f7bc97b98", + "classification": "taxonomy-mismatch", + "reason": "The prediction identifies the supplied parse().unwrap() panic on malformed request input. The scorer rejects security versus reliability; the severity also differs (high versus medium). No Rust process was executed in this audit.", + "evidence": [ + "Supplied request-controlled parse/unwrap line and the scenario's explicit service-panic contract." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "rust-unchecked-input", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "request-unwrap", + "findingSha256": "7a2d4e8889bf70b3a29826e015ed5c1c5e7f073049a906efab4ad7255b12ced6", + "classification": "taxonomy-mismatch", + "reason": "The prediction identifies the supplied parse().unwrap() panic on malformed request input. The scorer rejects security versus reliability; the severity also differs (high versus medium). No Rust process was executed in this audit.", + "evidence": [ + "Supplied request-controlled parse/unwrap line and the scenario's explicit service-panic contract." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "actions-readonly-metadata", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": ".github/workflows/metadata.yml:4:steps-outside-job", + "findingSha256": "b110039152424ded9688b3c799069e24cb5eea1c6ccb5fd655709572dccacc79", + "classification": "actual-causal-defect", + "reason": "The supplied added YAML has root-level steps and no jobs mapping. Read-only metadata access does not repair that workflow shape. The prediction identifies a causal defect in the supplied fixture, separately from the scorer's empty expectation.", + "evidence": [ + "Parsed YAML structure; GitHub workflow syntax places steps under jobs..steps (official documentation checked 2026-11-19)." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Submit the fixture/rubric inconsistency for separate review; do not relabel this completed campaign or suppress a supported workflow finding." + }, + { + "case": "shell-unquoted-path", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "scripts/archive.sh:14:unquoted-upload-path", + "findingSha256": "57ad734230604e6e15c387e4a92d54bf7dd1dc22f6d1ffab69945695ff9b4a5a", + "classification": "taxonomy-mismatch", + "reason": "The prediction identifies unquoted word splitting at the exact changed command. Its proposed -- and quoting repair also addresses option interpretation. The frozen security expectation differs from correctness and high differs from medium.", + "evidence": [ + "Fixed shell archive reproduction; original command and unchanged expected security taxonomy." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "shell-unquoted-path", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "unsafe-path-expansion", + "findingSha256": "fef3af872e4b7e50cae446ef9f8cffd84a16e840248178658a88a9fb64b6d77d", + "classification": "taxonomy-mismatch", + "reason": "The prediction identifies unquoted word splitting at the exact changed command. Its proposed -- and quoting repair also addresses option interpretation. The frozen security expectation differs from correctness and high differs from medium.", + "evidence": [ + "Fixed shell archive reproduction; original command and unchanged expected security taxonomy." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "react-complete-dependencies", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "src/UserPanel.tsx:42:stale-user-response", + "findingSha256": "db447ef52ea00f459ef9dd5e21ab835c38818963fb29611a289e40d27173a05d", + "classification": "unresolved", + "reason": "The stale-response hypothesis is possible for an asynchronous loader, but the fixture supplies no loadUser implementation, scheduling guarantee, cleanup elsewhere, or interaction witness. Complete dependencies alone neither proves nor refutes that separate hypothesis.", + "evidence": [ + "Only the three-line effect and its dependency intent are supplied; the actual loader contract is missing." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Request a frozen loader/interaction witness. Do not infer a production prompt defect solely from expected=[]." + }, + { + "case": "csharp-contained-path", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "Controllers/DownloadController.cs:73:ordinal-path-comparison", + "findingSha256": "5b8cf4359a28c110d7e85b9a6abcb10c3a2205e2cd74817ebbf7a1ef8f0d6eca", + "classification": "unresolved", + "reason": "The prediction assumes Windows case-insensitive path resolution and a requirement to accept differently cased contained paths. Neither supported OS/filesystem policy nor that acceptance requirement is supplied. No .NET/Windows execution is available in this audit.", + "evidence": [ + "Supplied ordinal containment check; absent target-platform and alternate-spelling contract." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Keep the platform premise unresolved; obtain the actual supported filesystem contract before a narrow correction." + }, + { + "case": "py-coverage-config-branch", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "pyproject.toml:4:coverage-threshold-not-enforced", + "findingSha256": "e2a57ff5a07677d90712b7be8346bbe442eb8194ebc4a17e90388f4688ca59e2", + "classification": "unresolved", + "reason": "coverage run collects data while reporting applies fail_under, but the excerpt does not prove the complete job has no report step or that this change promises threshold enforcement. The separate threshold hypothesis cannot be resolved from this fragment alone.", + "evidence": [ + "Supplied coverage command/configuration; no complete job or version-matched reporting observation." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Inspect the complete authored job and reporting requirement; retain the scorer FP without inventing a confirmed missed threshold defect." + }, + { + "case": "py-short-circuit-unhashable", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "src/checkpoint.py:2:accepts-object-as-steps", + "findingSha256": "b4836360df32ef823e06f4e499584ac2e4d29215d957a3fda6337e04ce5b025e", + "classification": "unresolved", + "reason": "A fixed Python control proves a mapping with an allowed string key returns True. The prediction additionally requires the whole issue_steps value to be an array; the scenario describes arbitrary persisted JSON but does not specify that container-shape contract. The concrete behavior is proven; whether it violates the intended contract remains unresolved.", + "evidence": [ + "Fixed Python mapping/list/short-circuit observations, with no consumer execution." + ], + "scope": "supplied fixture; independent repository truth remains separate from scorer labels", + "nextAction": "Obtain the checkpoint container-shape requirement. Only then propose a narrow boundary or corpus follow-up." + }, + { + "case": "py-short-circuit-unsafe-order", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "src/checkpoint.py:2:unhashable-step-crashes-validation", + "findingSha256": "61467e2c5712f3bc6db05e83a5f3baa5e52bf77499a1a242cc267d9055ac0df8", + "classification": "taxonomy-mismatch", + "reason": "Membership runs before isinstance. A list/dict step reaches set membership and raises TypeError; the prediction describes that exact path. Reliability differs from the frozen correctness label, and severity differs.", + "evidence": [ + "Fixed Python short-circuit control; supplied expression order." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "py-short-circuit-unsafe-order", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "unhashable-membership", + "findingSha256": "a6518d968ec42c0a7f3014d8b934461dc566625c0d6132556799f4ac73cdc8ed", + "classification": "taxonomy-mismatch", + "reason": "Membership runs before isinstance. A list/dict step reaches set membership and raises TypeError; the prediction describes that exact path. Reliability differs from the frozen correctness label, and severity differs.", + "evidence": [ + "Fixed Python short-circuit control; supplied expression order." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "ts-viewport-version-without-cleanup", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "src/startup.ts:2:loading-indicator-remains", + "findingSha256": "dfffdc1d3999fca2bb5363c103f8e6a2433650e5f08487224943af0d37089cda", + "classification": "taxonomy-mismatch", + "reason": "The pinned 1.0 mount appends a child and preserves the loader; the removed caller cleanup is the missing operation. The prediction follows that same version and path. Reliability differs from correctness.", + "evidence": [ + "Supplied immutable 1.0 mount source and index.html; no framework/browser execution is claimed." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "ts-viewport-version-without-cleanup", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "version-loader", + "findingSha256": "a61f95f7a54c37f539c7c13e80919cb3c816619e8a5c99a9b801b9035eff0f03", + "classification": "taxonomy-mismatch", + "reason": "The pinned 1.0 mount appends a child and preserves the loader; the removed caller cleanup is the missing operation. The prediction follows that same version and path. Reliability differs from correctness.", + "evidence": [ + "Supplied immutable 1.0 mount source and index.html; no framework/browser execution is claimed." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "kt-broad-catch-swallows-cancellation", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "storage/ReadRows.kt:5:cancellation-swallowed", + "findingSha256": "b370aab0a367062978d5e478ac6b78b02f17061333790fc7e60a825b52313fc3", + "classification": "taxonomy-mismatch", + "reason": "The scenario requires cancellation propagation and supplies no other guard. The new Throwable catch wraps that cancellation in DatabaseException/Left. The prediction identifies this same cause; reliability differs from correctness. It also reports line 5 rather than frozen line 4.", + "evidence": [ + "Separately authored Kotlin CancellationException mapping control; supplied try/catch and cancellation contract." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "kt-broad-catch-swallows-cancellation", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "swallowed-cancellation", + "findingSha256": "ac2985daeadf1e21c7316de43d8f7bd766b61b50f14514465c6ebd7e715d94ab", + "classification": "taxonomy-mismatch", + "reason": "The scenario requires cancellation propagation and supplies no other guard. The new Throwable catch wraps that cancellation in DatabaseException/Left. The prediction identifies this same cause; reliability differs from correctness. It also reports line 5 rather than frozen line 4.", + "evidence": [ + "Separately authored Kotlin CancellationException mapping control; supplied try/catch and cancellation contract." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "test-delegate-bypasses-stub", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "test/SessionReturnedState.test.ts:22:public-reader-skips-participant-binding", + "findingSha256": "8bc2ebbace1d809780788cdfb306fdefbca2079c6b8d46ec98041e5db49f76c3", + "classification": "taxonomy-mismatch", + "reason": "The public reader returns right(row) and never invokes bindSession. The new assertion therefore fails with zero participant-projection calls. The prediction describes this exact route; reliability differs from correctness.", + "evidence": [ + "observeCallPathFixture on its immutable owned fixture, independently of model output." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "test-delegate-bypasses-stub", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "test-delegate-bypasses-stub-defect", + "findingSha256": "c033f31825321ada1e07168745d8feea69c70ec98902ab28fd6287be8d9e4ae5", + "classification": "taxonomy-mismatch", + "reason": "The public reader returns right(row) and never invokes bindSession. The new assertion therefore fails with zero participant-projection calls. The prediction describes this exact route; reliability differs from correctness.", + "evidence": [ + "observeCallPathFixture on its immutable owned fixture, independently of model output." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "action-old-input-on-new-version", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": ".github/actions/publish-package/action.yml:22:wrong-problem-matcher-input", + "findingSha256": "5b48554fe5f05e9d5dcaaf4cfb5b46e47a80fb5ea3254081395a3a981213ea9d", + "classification": "taxonomy-mismatch", + "reason": "The selected revision reads enable-problem-matcher; the added problem-matcher belongs to the older revision. The default remains enabled and the supplied absent-asset contract fails registration. Correctness differs from reliability.", + "evidence": [ + "Supplied exact-revision manifest/runtime contract; this synthetic Action is not executed on GitHub." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "action-old-input-on-new-version", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "action-old-input-on-new-version-fault", + "findingSha256": "2d61be8109127807407db757d9fda7740bbe3cf0770b33aacaf9a953f95a0b57", + "classification": "taxonomy-mismatch", + "reason": "The selected revision reads enable-problem-matcher; the added problem-matcher belongs to the older revision. The default remains enabled and the supplied absent-asset contract fails registration. Correctness differs from reliability.", + "evidence": [ + "Supplied exact-revision manifest/runtime contract; this synthetic Action is not executed on GitHub." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "request-transform-write", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "media/request.ts:1:private-image-cache-policy", + "findingSha256": "a211ebce8a9c756ba6cdb11f908aaeb616d7f718cc154645ab5d24f19084e006", + "classification": "taxonomy-mismatch", + "reason": "The real authored request path emits no-cache, preserves it, and reaches a test requiring no-store. The prediction identifies that actual value and failure; security differs from correctness.", + "evidence": [ + "observeRequestTransform on the immutable owned write-policy fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "request-transform-write", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "request-transform-write", + "findingSha256": "0c79092de7ac8e46e2644adaaddf1934a1015ccf138682205b05bb4a032db4c6", + "classification": "taxonomy-mismatch", + "reason": "The real authored request path emits no-cache, preserves it, and reaches a test requiring no-store. The prediction identifies that actual value and failure; security differs from correctness.", + "evidence": [ + "observeRequestTransform on the immutable owned write-policy fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "session-source-opaque-bootstrap", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "e2e/owned-session.spec.ts:30:opaque-token-rejected", + "findingSha256": "5cc0b4dfacc51a55c619282c0f1ebae2779f931304a03116befc8d6207b0067e", + "classification": "taxonomy-mismatch", + "reason": "Configured opaque.setup.ts persists the opaque token and its future expiry skips refresh. The compact-token assertion fails on that selected token. Reliability differs from correctness.", + "evidence": [ + "observeInitialSessionSource with real Node HMAC/base64url and the immutable owned opaque fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "session-source-opaque-bootstrap", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "session-source-opaque-bootstrap", + "findingSha256": "1a303247c98634bdfbeed22bb19d87ace956f75dd110322fea0eeafa31c61a91", + "classification": "taxonomy-mismatch", + "reason": "Configured opaque.setup.ts persists the opaque token and its future expiry skips refresh. The compact-token assertion fails on that selected token. Reliability differs from correctness.", + "evidence": [ + "observeInitialSessionSource with real Node HMAC/base64url and the immutable owned opaque fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "session-source-expired-refresh", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": "e2e/owned-session.spec.ts:30:refresh-token-shape-mismatch", + "findingSha256": "49eb76e680b16ba7c18608cefef15e2d20ea3fede05a64d0fbd2c58dbf626e7b", + "classification": "taxonomy-mismatch", + "reason": "The selected signed session expires before the fixed clock; the actual refresh response supplies an opaque token. The prediction follows that replacement and failed assertion. Reliability differs from correctness.", + "evidence": [ + "observeInitialSessionSource with real Node HMAC/base64url and the immutable owned expired fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "session-source-expired-refresh", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "session-source-expired-refresh", + "findingSha256": "80d6e8df16ffe1289e11590ff687426ed396432cf24824b3f92141e8b8aca87a", + "classification": "taxonomy-mismatch", + "reason": "The selected signed session expires before the fixed clock; the actual refresh response supplies an opaque token. The prediction follows that replacement and failed assertion. Reliability differs from correctness.", + "evidence": [ + "observeInitialSessionSource with real Node HMAC/base64url and the immutable owned expired fixture." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "unittest-discovery-wrong-start-directory", + "kind": "prediction", + "index": 0, + "scorerLabel": "FP", + "id": ".github/scripts/tests/run_manifest_tests.py:9:omits-required-test-modules", + "findingSha256": "990d3b27ce89b5dc2c08a62086397803ff252cf6f6f0c69c0ce7f18ab586b779", + "classification": "taxonomy-mismatch", + "reason": "The selected start directory runs the unrelated health method and excludes both required manifest modules. The prediction explains that same actual selection. Reliability differs from correctness; the final location is the expected line 12 despite a stale line-9 string in its ID.", + "evidence": [ + "Actual fixed owned Python unittest discovery: 1 health method, 0 export methods; passing control runs 19 methods including 5 export methods." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + }, + { + "case": "unittest-discovery-wrong-start-directory", + "kind": "expected", + "index": 0, + "scorerLabel": "FN", + "id": "unittest-discovery-wrong-start-directory", + "findingSha256": "b92ba6d289918fe0bc52686904da915256f901a7487eab4c853cba73bf0ac20a", + "classification": "taxonomy-mismatch", + "reason": "The selected start directory runs the unrelated health method and excludes both required manifest modules. The prediction explains that same actual selection. Reliability differs from correctness; the final location is the expected line 12 despite a stale line-9 string in its ID.", + "evidence": [ + "Actual fixed owned Python unittest discovery: 1 health method, 0 export methods; passing control runs 19 methods including 5 export methods." + ], + "scope": "supplied synthetic fixture; no claim about a private consumer", + "nextAction": "Retain original FP/FN and calibration contribution. No production correction follows from this taxonomy difference. Any rubric proposal requires independent review and a new preregistration." + } + ], + "modelCalls": 0, + "evaluatedPrWriteAttempts": 0, + "qualification": "not-qualified; no score, label, threshold, prompt or campaign was changed" +} diff --git a/quality/bugbot/evidence/issue-971/short-circuit-probe.py b/quality/bugbot/evidence/issue-971/short-circuit-probe.py new file mode 100644 index 000000000..c86d52857 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/short-circuit-probe.py @@ -0,0 +1,26 @@ +"""Fixed owned Python primitives; no corpus/consumer source is executed.""" +import json +import sys + + +def safe(issue_steps, writable_ids): + if any(not isinstance(step, str) or step not in writable_ids for step in issue_steps): + return False + return set(issue_steps) <= writable_ids + + +def unsafe(issue_steps, writable_ids): + return all(step in writable_ids and isinstance(step, str) for step in issue_steps) + + +assert safe([[]], {"step-1"}) is False +assert safe({"step-1": False}, {"step-1"}) is True +try: + unsafe([[]], {"step-1"}) +except TypeError: + failure = "TypeError" +else: + raise AssertionError("Membership must encounter the unhashable value first") +print(json.dumps({"python": sys.version, "nested_list_rejected": True, + "mapping_container_accepted": True, "membership_first_failure": failure, + "container_contract": "not supplied; acceptance alone does not prove a defect"})) diff --git a/quality/bugbot/evidence/issue-971/unittest-observations.json b/quality/bugbot/evidence/issue-971/unittest-observations.json new file mode 100644 index 000000000..c955d0456 --- /dev/null +++ b/quality/bugbot/evidence/issue-971/unittest-observations.json @@ -0,0 +1,208 @@ +{ + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "method": "Actual Python unittest discovery/execution of separately authored fixed owned fixtures; corpus text is never read or interpreted.", + "modules": [ + { + "path": ".github/scripts/tests/test_manifest_core.py", + "sha256": "d617a487617443aef6136494dd8f4373cea1c8b8828102d2b5332839760264bd", + "methods": 14 + }, + { + "path": ".github/scripts/tests/test_manifest_export.py", + "sha256": "aa9d6360698c9a7cfcd78d73267ffff7e331b22ec636700d6036acb1a690ac19", + "methods": 5 + }, + { + "path": "backend/checks/test_manifest_health.py", + "sha256": "2169106841a988c0385adb0847b710859f0f9c4fb4f929956724b677e4cc7891", + "methods": 1 + } + ], + "observations": [ + { + "id": "unittest-discovery-delegated-wildcard", + "initialCwd": ".", + "effectiveCwd": "owned repository root", + "command": [ + "sys.executable", + "-m", + "unittest", + "discover", + "-s", + ".github/scripts/tests", + "-p", + "test_manifest_*.py", + "-v" + ], + "runnerSourceSha256": "fe525c3672b91353732b8f20b00800c599532a4995da2fa3292cd32539e31d17", + "testsPassed": 19, + "targetMethodsPassed": 5, + "moduleQualifiedOkRecords": [ + "test_core_0 (test_manifest_core.CoreTests.test_core_0) ... ok", + "test_core_1 (test_manifest_core.CoreTests.test_core_1) ... ok", + "test_core_10 (test_manifest_core.CoreTests.test_core_10) ... ok", + "test_core_11 (test_manifest_core.CoreTests.test_core_11) ... ok", + "test_core_12 (test_manifest_core.CoreTests.test_core_12) ... ok", + "test_core_13 (test_manifest_core.CoreTests.test_core_13) ... ok", + "test_core_2 (test_manifest_core.CoreTests.test_core_2) ... ok", + "test_core_3 (test_manifest_core.CoreTests.test_core_3) ... ok", + "test_core_4 (test_manifest_core.CoreTests.test_core_4) ... ok", + "test_core_5 (test_manifest_core.CoreTests.test_core_5) ... ok", + "test_core_6 (test_manifest_core.CoreTests.test_core_6) ... ok", + "test_core_7 (test_manifest_core.CoreTests.test_core_7) ... ok", + "test_core_8 (test_manifest_core.CoreTests.test_core_8) ... ok", + "test_core_9 (test_manifest_core.CoreTests.test_core_9) ... ok", + "test_export_0 (test_manifest_export.ExportTests.test_export_0) ... ok", + "test_export_1 (test_manifest_export.ExportTests.test_export_1) ... ok", + "test_export_2 (test_manifest_export.ExportTests.test_export_2) ... ok", + "test_export_3 (test_manifest_export.ExportTests.test_export_3) ... ok", + "test_export_4 (test_manifest_export.ExportTests.test_export_4) ... ok" + ], + "exit": 0 + }, + { + "id": "unittest-discovery-nested-working-directory", + "initialCwd": "backend", + "effectiveCwd": "owned repository root", + "command": [ + "sys.executable", + "-m", + "unittest", + "discover", + "-s", + ".github/scripts/tests", + "-p", + "test_manifest_*.py", + "-v" + ], + "runnerSourceSha256": "f0c9edbb275bf7aa2f0cf597bc0cd3d2ec754863b9a059cd2b9fdcba449ed041", + "testsPassed": 19, + "targetMethodsPassed": 5, + "moduleQualifiedOkRecords": [ + "test_core_0 (test_manifest_core.CoreTests.test_core_0) ... ok", + "test_core_1 (test_manifest_core.CoreTests.test_core_1) ... ok", + "test_core_10 (test_manifest_core.CoreTests.test_core_10) ... ok", + "test_core_11 (test_manifest_core.CoreTests.test_core_11) ... ok", + "test_core_12 (test_manifest_core.CoreTests.test_core_12) ... ok", + "test_core_13 (test_manifest_core.CoreTests.test_core_13) ... ok", + "test_core_2 (test_manifest_core.CoreTests.test_core_2) ... ok", + "test_core_3 (test_manifest_core.CoreTests.test_core_3) ... ok", + "test_core_4 (test_manifest_core.CoreTests.test_core_4) ... ok", + "test_core_5 (test_manifest_core.CoreTests.test_core_5) ... ok", + "test_core_6 (test_manifest_core.CoreTests.test_core_6) ... ok", + "test_core_7 (test_manifest_core.CoreTests.test_core_7) ... ok", + "test_core_8 (test_manifest_core.CoreTests.test_core_8) ... ok", + "test_core_9 (test_manifest_core.CoreTests.test_core_9) ... ok", + "test_export_0 (test_manifest_export.ExportTests.test_export_0) ... ok", + "test_export_1 (test_manifest_export.ExportTests.test_export_1) ... ok", + "test_export_2 (test_manifest_export.ExportTests.test_export_2) ... ok", + "test_export_3 (test_manifest_export.ExportTests.test_export_3) ... ok", + "test_export_4 (test_manifest_export.ExportTests.test_export_4) ... ok" + ], + "exit": 0 + }, + { + "id": "unittest-discovery-literal-argv-pattern", + "initialCwd": ".", + "effectiveCwd": "owned repository root", + "command": [ + "sys.executable", + "-m", + "unittest", + "discover", + "-s", + ".github/scripts/tests", + "-p", + "test_manifest_*.py", + "-v" + ], + "runnerSourceSha256": "dcb22a088e565aeff94b14457396c3e3a8e8e95964df35f5319e0f99f090d9cb", + "testsPassed": 19, + "targetMethodsPassed": 5, + "moduleQualifiedOkRecords": [ + "test_core_0 (test_manifest_core.CoreTests.test_core_0) ... ok", + "test_core_1 (test_manifest_core.CoreTests.test_core_1) ... ok", + "test_core_10 (test_manifest_core.CoreTests.test_core_10) ... ok", + "test_core_11 (test_manifest_core.CoreTests.test_core_11) ... ok", + "test_core_12 (test_manifest_core.CoreTests.test_core_12) ... ok", + "test_core_13 (test_manifest_core.CoreTests.test_core_13) ... ok", + "test_core_2 (test_manifest_core.CoreTests.test_core_2) ... ok", + "test_core_3 (test_manifest_core.CoreTests.test_core_3) ... ok", + "test_core_4 (test_manifest_core.CoreTests.test_core_4) ... ok", + "test_core_5 (test_manifest_core.CoreTests.test_core_5) ... ok", + "test_core_6 (test_manifest_core.CoreTests.test_core_6) ... ok", + "test_core_7 (test_manifest_core.CoreTests.test_core_7) ... ok", + "test_core_8 (test_manifest_core.CoreTests.test_core_8) ... ok", + "test_core_9 (test_manifest_core.CoreTests.test_core_9) ... ok", + "test_export_0 (test_manifest_export.ExportTests.test_export_0) ... ok", + "test_export_1 (test_manifest_export.ExportTests.test_export_1) ... ok", + "test_export_2 (test_manifest_export.ExportTests.test_export_2) ... ok", + "test_export_3 (test_manifest_export.ExportTests.test_export_3) ... ok", + "test_export_4 (test_manifest_export.ExportTests.test_export_4) ... ok" + ], + "exit": 0 + }, + { + "id": "unittest-discovery-excluded-by-pattern", + "initialCwd": ".", + "effectiveCwd": "owned repository root", + "command": [ + "sys.executable", + "-m", + "unittest", + "discover", + "-s", + ".github/scripts/tests", + "-p", + "test_manifest_core.py", + "-v" + ], + "runnerSourceSha256": "507f52c57d97d76104bc84b76cbd3886c7998374f3d1d89346dae5f412f94542", + "testsPassed": 14, + "targetMethodsPassed": 0, + "moduleQualifiedOkRecords": [ + "test_core_0 (test_manifest_core.CoreTests.test_core_0) ... ok", + "test_core_1 (test_manifest_core.CoreTests.test_core_1) ... ok", + "test_core_10 (test_manifest_core.CoreTests.test_core_10) ... ok", + "test_core_11 (test_manifest_core.CoreTests.test_core_11) ... ok", + "test_core_12 (test_manifest_core.CoreTests.test_core_12) ... ok", + "test_core_13 (test_manifest_core.CoreTests.test_core_13) ... ok", + "test_core_2 (test_manifest_core.CoreTests.test_core_2) ... ok", + "test_core_3 (test_manifest_core.CoreTests.test_core_3) ... ok", + "test_core_4 (test_manifest_core.CoreTests.test_core_4) ... ok", + "test_core_5 (test_manifest_core.CoreTests.test_core_5) ... ok", + "test_core_6 (test_manifest_core.CoreTests.test_core_6) ... ok", + "test_core_7 (test_manifest_core.CoreTests.test_core_7) ... ok", + "test_core_8 (test_manifest_core.CoreTests.test_core_8) ... ok", + "test_core_9 (test_manifest_core.CoreTests.test_core_9) ... ok" + ], + "exit": 0 + }, + { + "id": "unittest-discovery-wrong-start-directory", + "initialCwd": ".", + "effectiveCwd": "owned repository root", + "command": [ + "sys.executable", + "-m", + "unittest", + "discover", + "-s", + "backend/checks", + "-p", + "test_manifest_*.py", + "-v" + ], + "runnerSourceSha256": "ed5c157df9960c8d7259530d9f8b793a4e3b5388803c75c3fee3c8fdc301896f", + "testsPassed": 1, + "targetMethodsPassed": 0, + "moduleQualifiedOkRecords": [ + "test_health_0 (test_manifest_health.HealthTests.test_health_0) ... ok" + ], + "exit": 0 + } + ], + "unavailableRunnerCase": "No execution performed or claimed", + "consumerExecution": false, + "consumerMutation": false +}