From ddc768b2e57922ff153bf90553472cc0e849755d Mon Sep 17 00:00:00 2001 From: Efra Espada Date: Thu, 19 Nov 2026 20:02:42 +0100 Subject: [PATCH] bugfix-985-correct-malformed-workflow-context-in-a-new-ev-07-corpus-revision: version the corrected EV-07 workflow fixture without rewriting history (#985) --- docs/bugbot/quality-observability.mdx | 16 + package.json | 2 +- quality/bugbot/corpus.v2.json | 2578 +++++++++++++++++ quality/bugbot/evidence/issue-985/README.md | 37 + .../issue-985/corpus-revision.test.cjs | 86 + .../bugbot/evidence/issue-985/derivation.json | 16 + .../evidence/issue-985/historical-hashes.json | 18 + specs/CATALOG.md | 8 +- ...bugbot-analysis-publication-and-autofix.md | 35 + specs/catalog.json | 11 +- 10 files changed, 2799 insertions(+), 8 deletions(-) create mode 100644 quality/bugbot/corpus.v2.json create mode 100644 quality/bugbot/evidence/issue-985/README.md create mode 100644 quality/bugbot/evidence/issue-985/corpus-revision.test.cjs create mode 100644 quality/bugbot/evidence/issue-985/derivation.json create mode 100644 quality/bugbot/evidence/issue-985/historical-hashes.json diff --git a/docs/bugbot/quality-observability.mdx b/docs/bugbot/quality-observability.mdx index c53b8c141..8f2f31538 100644 --- a/docs/bugbot/quality-observability.mdx +++ b/docs/bugbot/quality-observability.mdx @@ -1049,3 +1049,19 @@ Future qualification plans also pin the actual prepared executable's digest and any launcher artifact. A version string alone cannot admit a model call. Record and check the runtime proof for every corpus invocation; frozen campaigns continue to replay through their own preregistration commits. + +## Corpus revision 2 + +The #971 audit found malformed complete-workflow context in the frozen +`actions-readonly-metadata` input. The repository's `corpus.v2.json` supplies a +complete read-only metadata job for that case. All 174 IDs/order and labels stay +unchanged; `corpus.v1.json` and every historical score and prediction retain +their original bytes. The derivation and historical hashes are recorded under +`quality/bugbot/evidence/issue-985` with six deterministic controls. + +This is a new input identity for independent review. It neither changes the +current CLI/driver default nor retrospectively rescales a completed campaign. +Before #974 measures anything, merge the prerequisites and reviewed correction, +then commit exact drivers/preregistration that select and hash v2. The threshold +and production-disabled policies remain in force. No v2 qualification result is +claimed by the fixture correction. diff --git a/package.json b/package.json index 4c7247b20..1ec917500 100644 --- a/package.json +++ b/package.json @@ -69,7 +69,7 @@ "test": "jest", "test:watch": "jest --watch", "test:coverage": "jest --coverage --json --outputFile=coverage/setup-acceptance-jest.json && node scripts/validate-coverage-budgets.cjs && node scripts/validate-setup-assistant-acceptance.cjs coverage/setup-acceptance-jest.json && pnpm run test:extension", - "test:bugbot-shadow-verification": "node --test quality/bugbot/evidence/issue-950/shadow-verification/verification.test.cjs quality/bugbot/evidence/issue-950/normal-flow-shadow/config.test.cjs quality/bugbot/evidence/issue-950/normal-flow-shadow/paths.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/launch-full-review.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/review-runtime.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/score-review.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs quality/bugbot/evidence/issue-950/status-card-publication/publisher.test.cjs", + "test:bugbot-shadow-verification": "node --test quality/bugbot/evidence/issue-950/shadow-verification/verification.test.cjs quality/bugbot/evidence/issue-950/normal-flow-shadow/config.test.cjs quality/bugbot/evidence/issue-950/normal-flow-shadow/paths.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/launch-full-review.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/review-runtime.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/score-review.test.cjs quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs quality/bugbot/evidence/issue-950/status-card-publication/publisher.test.cjs quality/bugbot/evidence/issue-985/corpus-revision.test.cjs", "eval:bugbot": "jest src/tooling/__tests__/bugbot_quality_eval.test.ts src/tooling/__tests__/bugbot_benchmark.test.ts src/tooling/__tests__/bugbot_request_transform_evidence.test.ts --runInBand", "typecheck": "tsc --noEmit && pnpm run typecheck:extension", "metrics:architecture": "node scripts/collect-architecture-metrics.cjs", diff --git a/quality/bugbot/corpus.v2.json b/quality/bugbot/corpus.v2.json new file mode 100644 index 000000000..f912bee9e --- /dev/null +++ b/quality/bugbot/corpus.v2.json @@ -0,0 +1,2578 @@ +{ + "schemaVersion": 1, + "cases": [ + { + "id": "ts-null-dereference", + "language": "typescript", + "category": "correctness", + "description": "A changed optional lookup is dereferenced without a guard.", + "file": "src/users.ts", + "startLine": 41, + "diff": "+const user = users.find(item => item.id === id);\n+return user.name;", + "expected": [ + { + "id": "unchecked-user", + "title": "Optional lookup result is dereferenced", + "file": "src/users.ts", + "line": 42, + "severity": "medium", + "category": "correctness", + "symbol": "getUserName", + "codeSnippet": "return user.name" + } + ] + }, + { + "id": "py-command-injection", + "language": "python", + "category": "security", + "description": "Untrusted input is interpolated into a shell command.", + "file": "app/image.py", + "startLine": 18, + "diff": "+os.system(f\"convert {request.args['file']} out.png\")", + "expected": [ + { + "id": "shell-injection", + "title": "Request input reaches a shell", + "file": "app/image.py", + "line": 18, + "severity": "high", + "category": "security", + "symbol": "convert_image", + "codeSnippet": "os.system(f\"convert {request.args['file']} out.png\")" + } + ] + }, + { + "id": "go-leaked-goroutine", + "language": "go", + "category": "reliability", + "description": "A producer can block forever after the consumer returns.", + "file": "internal/fetch.go", + "startLine": 64, + "diff": "+go func() { results <- fetch(ctx) }()\n+return <-timeout", + "expected": [ + { + "id": "goroutine-leak", + "title": "Producer blocks after timeout", + "file": "internal/fetch.go", + "line": 64, + "severity": "medium", + "category": "reliability", + "symbol": "FetchWithTimeout", + "codeSnippet": "results <- fetch(ctx)" + } + ] + }, + { + "id": "sql-unbounded-query", + "language": "sql", + "category": "performance", + "description": "A pagination limit was removed from a hot query.", + "file": "queries/events.sql", + "startLine": 8, + "diff": "-SELECT * FROM events LIMIT 100\n+SELECT * FROM events", + "expected": [ + { + "id": "unbounded-events", + "title": "Hot query became unbounded", + "file": "queries/events.sql", + "line": 9, + "severity": "medium", + "category": "performance", + "symbol": "recent_events", + "codeSnippet": "SELECT * FROM events" + } + ] + }, + { + "id": "java-close-resource", + "language": "java", + "category": "reliability", + "description": "A stream is created and returned from early paths without closing.", + "file": "src/StorageReader.java", + "startLine": 31, + "diff": "+InputStream stream = storage.open(key);\n+return parse(stream);", + "expected": [ + { + "id": "stream-leak", + "title": "Opened stream is not closed", + "file": "src/StorageReader.java", + "line": 31, + "severity": "medium", + "category": "reliability", + "symbol": "read", + "codeSnippet": "InputStream stream = storage.open(key)" + } + ] + }, + { + "id": "rust-safe-change", + "language": "rust", + "category": "negative", + "description": "A checked conversion is introduced; no finding should be emitted.", + "file": "src/count.rs", + "startLine": 12, + "diff": "+let count = usize::try_from(raw_count)?;", + "expected": [] + }, + { + "id": "docs-only", + "language": "markdown", + "category": "negative", + "description": "Documentation wording only; no actionable code finding.", + "file": "README.md", + "startLine": 20, + "diff": "+The command returns a JSON response.", + "expected": [] + }, + { + "id": "ts-authorization-bypass", + "language": "typescript", + "category": "security", + "description": "An authorization guard is removed before a destructive operation.", + "file": "src/admin/delete_user.ts", + "startLine": 70, + "diff": "-if (!actor.isAdmin) throw new ForbiddenError();\n+await users.delete(request.params.id);", + "expected": [ + { + "id": "missing-authz", + "title": "User deletion no longer checks authorization", + "file": "src/admin/delete_user.ts", + "line": 71, + "severity": "high", + "category": "security", + "symbol": "deleteUser", + "codeSnippet": "await users.delete(request.params.id)" + } + ] + }, + { + "id": "ts-safe-optional-chain", + "language": "typescript", + "category": "negative", + "description": "An optional access now has a fallback and should not be reported.", + "file": "src/profile.ts", + "startLine": 24, + "diff": "+return account.profile?.displayName ?? 'Anonymous';", + "expected": [] + }, + { + "id": "py-mutable-default", + "language": "python", + "category": "correctness", + "description": "A mutable default leaks accumulated values across requests.", + "file": "app/filters.py", + "startLine": 11, + "diff": "+def collect_filters(value, selected=[]):\n+ selected.append(value)\n+ return selected", + "expected": [ + { + "id": "shared-default", + "title": "Mutable default is shared across calls", + "file": "app/filters.py", + "line": 11, + "severity": "medium", + "category": "correctness", + "symbol": "collect_filters", + "codeSnippet": "def collect_filters(value, selected=[])" + } + ] + }, + { + "id": "py-parameterized-query", + "language": "python", + "category": "negative", + "description": "User input is passed as a database parameter instead of interpolated SQL.", + "file": "app/users.py", + "startLine": 36, + "diff": "+cursor.execute('SELECT * FROM users WHERE email = %s', (email,))", + "expected": [] + }, + { + "id": "go-ignored-write-error", + "language": "go", + "category": "reliability", + "description": "A response write error is discarded after streaming can fail.", + "file": "internal/export.go", + "startLine": 52, + "diff": "+_, _ = w.Write(payload)\n+metrics.Exports.Inc()", + "expected": [ + { + "id": "discarded-write-error", + "title": "Response write failure is ignored", + "file": "internal/export.go", + "line": 52, + "severity": "medium", + "category": "reliability", + "symbol": "Export", + "codeSnippet": "_, _ = w.Write(payload)" + } + ] + }, + { + "id": "go-cancellable-send", + "language": "go", + "category": "negative", + "description": "A channel send is guarded by context cancellation.", + "file": "internal/worker.go", + "startLine": 83, + "diff": "+select {\n+case results <- result:\n+case <-ctx.Done():\n+ return ctx.Err()\n+}", + "expected": [] + }, + { + "id": "sql-string-concatenation", + "language": "sql", + "category": "security", + "description": "A query is built by concatenating an untrusted tenant identifier.", + "file": "queries/tenant.js", + "startLine": 15, + "diff": "+db.query('SELECT * FROM tenants WHERE id = ' + request.params.id);", + "expected": [ + { + "id": "tenant-sql-injection", + "title": "Tenant id is concatenated into SQL", + "file": "queries/tenant.js", + "line": 15, + "severity": "high", + "category": "security", + "symbol": "loadTenant", + "codeSnippet": "db.query('SELECT * FROM tenants WHERE id = ' + request.params.id)" + } + ] + }, + { + "id": "sql-bounded-query", + "language": "sql", + "category": "negative", + "description": "A deterministic order and explicit page bound are added.", + "file": "queries/audit.sql", + "startLine": 4, + "diff": "+SELECT * FROM audit_events ORDER BY created_at DESC LIMIT 100;", + "expected": [] + }, + { + "id": "java-try-with-resources", + "language": "java", + "category": "negative", + "description": "The newly opened stream is deterministically closed.", + "file": "src/StorageReader.java", + "startLine": 45, + "diff": "+try (InputStream stream = storage.open(key)) {\n+ return parse(stream);\n+}", + "expected": [] + }, + { + "id": "rust-unchecked-input", + "language": "rust", + "category": "reliability", + "description": "Malformed request input now panics the service process.", + "file": "src/http/limit.rs", + "startLine": 27, + "diff": "+let limit: usize = request.query(\"limit\").parse().unwrap();", + "expected": [ + { + "id": "request-unwrap", + "title": "Malformed limit can panic the service", + "file": "src/http/limit.rs", + "line": 27, + "severity": "medium", + "category": "reliability", + "symbol": "parse_limit", + "codeSnippet": "request.query(\"limit\").parse().unwrap()" + } + ] + }, + { + "id": "rust-result-propagation", + "language": "rust", + "category": "negative", + "description": "Parsing failure is propagated to the caller.", + "file": "src/http/limit.rs", + "startLine": 39, + "diff": "+let limit = raw_limit.parse::()?;", + "expected": [] + }, + { + "id": "actions-untrusted-checkout", + "language": "yaml", + "category": "security", + "description": "A privileged pull_request_target job checks out and executes untrusted pull request code.", + "file": ".github/workflows/review.yml", + "startLine": 1, + "diff": "+on: pull_request_target\n+permissions: write-all\n+steps:\n+ - uses: actions/checkout@v4\n+ with:\n+ ref: ${{ github.event.pull_request.head.sha }}\n+ - run: npm test", + "expected": [ + { + "id": "pwn-request-target", + "title": "Privileged workflow executes untrusted PR code", + "file": ".github/workflows/review.yml", + "line": 7, + "severity": "high", + "category": "security", + "symbol": "review", + "codeSnippet": "run: npm test" + } + ] + }, + { + "id": "actions-readonly-metadata", + "language": "yaml", + "category": "negative", + "description": "A pull request workflow reads metadata with explicit read-only permissions and does not execute PR code.", + "file": ".github/workflows/metadata.yml", + "startLine": 1, + "diff": "+on: pull_request\n+permissions:\n+ contents: read\n+jobs:\n+ metadata:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - run: echo '${{ github.event.pull_request.number }}'", + "expected": [] + }, + { + "id": "shell-unquoted-path", + "language": "shell", + "category": "security", + "description": "An attacker-controlled path is expanded unquoted into a command.", + "file": "scripts/archive.sh", + "startLine": 14, + "diff": "+tar -czf backup.tgz $UPLOAD_PATH", + "expected": [ + { + "id": "unsafe-path-expansion", + "title": "Upload path is subject to word splitting and option injection", + "file": "scripts/archive.sh", + "line": 14, + "severity": "high", + "category": "security", + "symbol": "archive_upload", + "codeSnippet": "tar -czf backup.tgz $UPLOAD_PATH" + } + ] + }, + { + "id": "shell-quoted-path", + "language": "shell", + "category": "negative", + "description": "A path is quoted and separated from command options.", + "file": "scripts/archive.sh", + "startLine": 20, + "diff": "+tar -czf backup.tgz -- \"$UPLOAD_PATH\"", + "expected": [] + }, + { + "id": "terraform-public-database", + "language": "terraform", + "category": "security", + "description": "A database security group is opened to the entire internet.", + "file": "infra/database.tf", + "startLine": 90, + "diff": "+ingress {\n+ from_port = 5432\n+ to_port = 5432\n+ protocol = \"tcp\"\n+ cidr_blocks = [\"0.0.0.0/0\"]\n+}", + "expected": [ + { + "id": "public-postgres", + "title": "PostgreSQL is exposed to the internet", + "file": "infra/database.tf", + "line": 94, + "severity": "high", + "category": "security", + "symbol": "aws_security_group.database", + "codeSnippet": "cidr_blocks = [\"0.0.0.0/0\"]" + } + ] + }, + { + "id": "terraform-private-database", + "language": "terraform", + "category": "negative", + "description": "Database ingress is restricted to the application security group.", + "file": "infra/database.tf", + "startLine": 108, + "diff": "+ingress {\n+ from_port = 5432\n+ to_port = 5432\n+ protocol = \"tcp\"\n+ security_groups = [aws_security_group.application.id]\n+}", + "expected": [] + }, + { + "id": "react-stale-effect", + "language": "tsx", + "category": "correctness", + "description": "An effect reads a changing identifier but never reruns for it.", + "file": "src/UserPanel.tsx", + "startLine": 32, + "diff": "+useEffect(() => {\n+ loadUser(userId).then(setUser);\n+}, []);", + "expected": [ + { + "id": "stale-user-effect", + "title": "Effect keeps loading the initial user", + "file": "src/UserPanel.tsx", + "line": 34, + "severity": "medium", + "category": "correctness", + "symbol": "UserPanel", + "codeSnippet": "}, [])" + } + ] + }, + { + "id": "react-complete-dependencies", + "language": "tsx", + "category": "negative", + "description": "An effect reruns when the identifier it reads changes.", + "file": "src/UserPanel.tsx", + "startLine": 41, + "diff": "+useEffect(() => {\n+ loadUser(userId).then(setUser);\n+}, [userId]);", + "expected": [] + }, + { + "id": "csharp-path-traversal", + "language": "csharp", + "category": "security", + "description": "A request filename is combined with the upload root without containment validation.", + "file": "Controllers/DownloadController.cs", + "startLine": 58, + "diff": "+var path = Path.Combine(uploadRoot, request.FileName);\n+return PhysicalFile(path, \"application/octet-stream\");", + "expected": [ + { + "id": "download-traversal", + "title": "Request filename can escape the upload root", + "file": "Controllers/DownloadController.cs", + "line": 58, + "severity": "high", + "category": "security", + "symbol": "Download", + "codeSnippet": "Path.Combine(uploadRoot, request.FileName)" + } + ] + }, + { + "id": "csharp-contained-path", + "language": "csharp", + "category": "negative", + "description": "The canonicalized download path is rejected unless it remains under the upload root.", + "file": "Controllers/DownloadController.cs", + "startLine": 72, + "diff": "+var path = Path.GetFullPath(Path.Combine(uploadRoot, request.FileName));\n+if (!path.StartsWith(Path.GetFullPath(uploadRoot) + Path.DirectorySeparatorChar, StringComparison.Ordinal))\n+ return BadRequest();", + "expected": [] + }, + { + "id": "kotlin-blocking-coroutine", + "language": "kotlin", + "category": "performance", + "description": "Blocking I/O is introduced directly on a request coroutine dispatcher.", + "file": "src/ReportController.kt", + "startLine": 48, + "diff": "+suspend fun report(): Report {\n+ val bytes = Files.readAllBytes(reportPath)\n+ return parse(bytes)\n+}", + "expected": [ + { + "id": "blocking-request-thread", + "title": "Blocking file read runs on the request dispatcher", + "file": "src/ReportController.kt", + "line": 49, + "severity": "medium", + "category": "performance", + "symbol": "report", + "codeSnippet": "Files.readAllBytes(reportPath)" + } + ] + }, + { + "id": "kotlin-io-dispatcher", + "language": "kotlin", + "category": "negative", + "description": "Blocking file I/O is explicitly moved to the IO dispatcher.", + "file": "src/ReportController.kt", + "startLine": 57, + "diff": "+val bytes = withContext(Dispatchers.IO) { Files.readAllBytes(reportPath) }", + "expected": [] + }, + { + "id": "py-coverage-config-branch", + "language": "python", + "category": "negative", + "description": "A coverage job runs python -m coverage run -m unittest discover from the repository root using the supplied TOML settings, with TOML support and no config overrides.", + "file": "pyproject.toml", + "startLine": 1, + "diff": "+[tool.coverage.run]\n+branch = true\n+[tool.coverage.report]\n+fail_under = 85\n+# From this repository root, with TOML support installed and no other config/overrides:\n+# python -m coverage run -m unittest discover -s tests -q", + "expected": [] + }, + { + "id": "py-http10-reconnect", + "language": "python", + "category": "negative", + "description": "A callback handler sends 404 before an HTTPConnection client makes its next request.", + "file": "tools/callback.py", + "startLine": 1, + "diff": "+from http.server import BaseHTTPRequestHandler\n+from http.client import HTTPConnection\n+class Handler(BaseHTTPRequestHandler):\n+ def do_GET(self):\n+ self.send_response(404)\n+ self.end_headers()\n+def two_requests(port):\n+ client = HTTPConnection(\"127.0.0.1\", port)\n+ client.request(\"GET\", \"/missing\")\n+ first = client.getresponse()\n+ client.request(\"GET\", \"/callback\")\n+ return first.status, client.getresponse().status", + "expected": [] + }, + { + "id": "docs-correct-regression-total", + "language": "markdown", + "category": "negative", + "description": "A regression report lists the stated total and the per-area case counts.", + "file": "docs/regressions.md", + "startLine": 1, + "diff": "+Regression total: 34\n+Cases by area: 6 + 8 + 3 + 1 + 4 + 1 + 4 + 2 + 1 + 3 + 1 = 34.", + "expected": [] + }, + { + "id": "py-short-circuit-unhashable", + "language": "python", + "category": "negative", + "description": "A checkpoint validator checks issue steps supplied as arbitrary persisted JSON values.", + "file": "src/checkpoint.py", + "startLine": 1, + "diff": "+def valid_steps(issue_steps, writable_ids):\n+ if any(not isinstance(step, str) or step not in writable_ids for step in issue_steps):\n+ return False\n+ return set(issue_steps) <= writable_ids", + "expected": [] + }, + { + "id": "py-helper-retry-validation", + "language": "python", + "category": "negative", + "description": "A copy entrypoint loads persisted retry_attempts through a validation helper before constructing provider work.", + "file": "src/copy.py", + "startLine": 1, + "diff": "+def parse_progress(raw):\n+ value = raw[\"retry_attempts\"]\n+ if isinstance(value, bool) or not isinstance(value, int) or value < 0:\n+ raise ValueError(\"invalid_copy_checkpoint\")\n+ return value\n+\n+def run_copy(raw, provider):\n+ attempts = parse_progress(raw)\n+ return provider.create(attempts)", + "expected": [] + }, + { + "id": "ts-exclusive-render-branches", + "language": "typescript", + "category": "negative", + "description": "A selected UI section is rendered through a map of view functions.", + "file": "ui/views.ts", + "startLine": 1, + "diff": "+const unavailableAction = () => html`Unavailable`;\n+const overview = () => html`

Overview

`;\n+const copy = () => html`
${unavailableAction()}
`;\n+const library = () => html`
${unavailableAction()}
`;\n+const viewFor = (section: \"overview\" | \"copy\" | \"library\") => ({ overview, copy, library })[section]();\n+const render = (section: \"overview\" | \"copy\" | \"library\") => html`${viewFor(section)}`;", + "expected": [] + }, + { + "id": "py-short-circuit-unsafe-order", + "language": "python", + "category": "correctness", + "description": "A checkpoint validator checks issue steps supplied as arbitrary persisted JSON values.", + "file": "src/checkpoint.py", + "startLine": 1, + "diff": "+def valid_steps(issue_steps, writable_ids):\n+ return all(step in writable_ids and isinstance(step, str) for step in issue_steps)", + "expected": [ + { + "id": "unhashable-membership", + "title": "Unhashable steps reach set membership before validation", + "file": "src/checkpoint.py", + "line": 2, + "severity": "low", + "category": "correctness", + "symbol": "valid_steps", + "codeSnippet": "step in writable_ids" + } + ] + }, + { + "id": "ts-composed-duplicate-ids", + "language": "typescript", + "category": "correctness", + "description": "A UI helper supplies a reason label to actions composed in one overview.", + "file": "ui/views.ts", + "startLine": 1, + "diff": "+const unavailableAction = () => html`Unavailable`;\n+const overview = () => html`
${unavailableAction()}${unavailableAction()}
`;", + "expected": [ + { + "id": "composed-duplicate-id", + "title": "Composed actions render duplicate reason IDs", + "file": "ui/views.ts", + "line": 2, + "severity": "low", + "category": "correctness", + "symbol": "overview", + "codeSnippet": "${unavailableAction()}${unavailableAction()}" + } + ] + }, + { + "id": "kt-compose-owned-loader", + "language": "kotlin", + "category": "negative", + "description": "Review removal of the manual host-page load handler. Main.kt calls ComposeViewport(viewportContainerId = \"ComposeTarget\") { App() } successfully. Compose 1.13.0-beta01 official source webMain/androidx/compose/ui/window/ComposeWindow.web.kt:74,80-82,241-246: ComposeViewport clears viewportContainer with replaceChildren() inside onSkikoReady before mounting content. Source: https://repo.maven.apache.org/maven2/org/jetbrains/compose/ui/ui/1.13.0-beta01/ui-1.13.0-beta01-sources.jar", + "file": "frontend/index.html", + "startLine": 1, + "diff": "@@ -1,4 +1,3 @@\n
\n
Loading...
\n
\n-", + "expected": [] + }, + { + "id": "kt-compose-external-loader", + "language": "html", + "category": "correctness", + "description": "Review the changed host markup. The entry point calls ComposeViewport(\"ComposeTarget\") successfully; the supplied framework contract and the complete loader cleanup code are shown. Compose 1.13.0-beta01 official source webMain/androidx/compose/ui/window/ComposeWindow.web.kt:74,80-82,241-246: ComposeViewport clears viewportContainer with replaceChildren() inside onSkikoReady before mounting content.", + "file": "frontend/index.html", + "startLine": 1, + "diff": "@@ -1 +1,2 @@\n+
\n+
Loading...
\n-", + "expected": [ + { + "id": "external-loader", + "title": "The external loader covers the initialized app", + "file": "frontend/index.html", + "line": 2, + "severity": "medium", + "category": "correctness", + "codeSnippet": "
Loading...
" + } + ] + }, + { + "id": "kt-compose-failed-startup-error", + "language": "kotlin", + "category": "negative", + "description": "Review startup with a failing dependency initializer and the supplied framework contract. The host initially has a Loading... child inside ComposeTarget. Compose 1.13.0-beta01 official source webMain/androidx/compose/ui/window/ComposeWindow.web.kt:74,80-82,241-246: ComposeViewport clears viewportContainer with replaceChildren() inside onSkikoReady before mounting content.", + "file": "frontend/Main.kt", + "startLine": 1, + "diff": "@@ -0,0 +1,8 @@\n+fun main() {\n+ try {\n+ initializeDependencies() // may throw before ComposeViewport is called\n+ ComposeViewport(viewportContainerId = \"ComposeTarget\") { App() }\n+ } catch (error: Exception) {\n+ document.getElementById(\"loading\")!!.textContent = \"Unable to start. Reload to retry.\"\n+ }\n+}", + "expected": [] + }, + { + "id": "kt-compose-failed-startup-stuck", + "language": "kotlin", + "category": "correctness", + "description": "Review startup with the supplied framework contract. The host starts with a Loading... child inside ComposeTarget. initializeDependencies throws when required saved settings are malformed; there is no global error handler or other loader update. Compose 1.13.0-beta01 official source webMain/androidx/compose/ui/window/ComposeWindow.web.kt:74,80-82,241-246: ComposeViewport clears viewportContainer with replaceChildren() inside onSkikoReady before mounting content.", + "file": "frontend/Main.kt", + "startLine": 1, + "diff": "@@ -0,0 +1,4 @@\n+fun main() {\n+ initializeDependencies()\n+ ComposeViewport(viewportContainerId = \"ComposeTarget\") { App() }\n+}", + "expected": [ + { + "id": "startup-loader", + "title": "Dependency initialization failure leaves the loading state indefinitely", + "file": "frontend/Main.kt", + "line": 2, + "severity": "medium", + "category": "reliability", + "symbol": "main", + "codeSnippet": "initializeDependencies()" + } + ] + }, + { + "id": "ts-viewport-version-without-cleanup", + "language": "typescript", + "category": "correctness", + "description": "Review a synthetic viewport package integration. The pinned viewport-framework 1.0 source is supplied. Version 2.0 clears the target before mount, but this repository resolves 1.0. The full caller and loader cleanup are shown. Resolved viewport-framework@1.0 source: export function mount(target, app) { target.appendChild(app); } index.html:
Loading...
", + "file": "src/startup.ts", + "startLine": 1, + "diff": "@@ -1 +1,2 @@\n+import { mount } from \"viewport-framework\";\n+mount(document.getElementById(\"target\")!, createApp());\n-document.getElementById(\"loading\")!.remove();", + "expected": [ + { + "id": "version-loader", + "title": "The pinned viewport implementation preserves the loading element", + "file": "src/startup.ts", + "line": 2, + "severity": "medium", + "category": "correctness", + "codeSnippet": "mount(document.getElementById(\"target\")!, createApp());" + } + ] + }, + { + "id": "kt-compose-preferred-width-narrow", + "language": "kotlin", + "category": "negative", + "description": "Standard Compose foundation-layout and Material3 APIs. The centered Box receives bounded width constraints min=0dp, max=280dp. The form must keep its interactive fields within the 280dp parent.", + "file": "ui/AuthForm.kt", + "startLine": 1, + "diff": "+import androidx.compose.foundation.layout.*\n+import androidx.compose.material3.*\n+import androidx.compose.runtime.Composable\n+import androidx.compose.ui.Alignment\n+import androidx.compose.ui.Modifier\n+import androidx.compose.ui.unit.dp\n+@Composable\n+fun AuthForm(email: String, onEmailChange: (String) -> Unit) {\n+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {\n+ Card(modifier = Modifier.width(400.dp)) {\n+ Column(Modifier.padding(24.dp)) {\n+ OutlinedTextField(email, onEmailChange, modifier = Modifier.fillMaxWidth())\n+ Button(onClick = {}, modifier = Modifier.fillMaxWidth()) { Text(\"Submit\") }\n+ }\n+ }\n+ }\n+}", + "expected": [] + }, + { + "id": "kt-compose-required-width-overflow", + "language": "kotlin", + "category": "correctness", + "description": "Standard Compose foundation-layout and Material3 APIs. The centered Box receives bounded width constraints min=0dp, max=280dp. All unclipped interactive fields must fit within the 280dp parent. The same form is also used at 800dp, where the controls must remain at most 320dp wide.", + "file": "ui/AuthForm.kt", + "startLine": 1, + "diff": "+import androidx.compose.foundation.layout.*\n+import androidx.compose.material3.*\n+import androidx.compose.runtime.Composable\n+import androidx.compose.ui.Alignment\n+import androidx.compose.ui.Modifier\n+import androidx.compose.ui.unit.dp\n+@Composable\n+fun AuthForm(email: String, onEmailChange: (String) -> Unit) {\n+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {\n+ Card(modifier = Modifier.requiredWidth(400.dp).padding(16.dp)) {\n+ Column(Modifier.padding(24.dp)) {\n+ OutlinedTextField(email, onEmailChange, modifier = Modifier.fillMaxWidth())\n+ Button(onClick = {}, modifier = Modifier.fillMaxWidth()) { Text(\"Submit\") }\n+ }\n+ }\n+ }\n+}", + "expected": [ + { + "id": "kt-compose-required-width-overflow-defect", + "title": "Required width makes the padded controls overflow the 280dp parent", + "file": "ui/AuthForm.kt", + "line": 10, + "severity": "low", + "category": "correctness", + "symbol": "AuthForm", + "codeSnippet": "Modifier.requiredWidth(400.dp).padding(16.dp)" + } + ] + }, + { + "id": "kt-compose-fill-before-cap", + "language": "kotlin", + "category": "correctness", + "description": "Standard Compose foundation-layout and Material3 APIs. The centered Box receives bounded width constraints min=0dp, max=800dp; it is also used at 280dp. The form must stay usable at 280dp and keep the interactive fields at most 320dp wide at 800dp.", + "file": "ui/AuthForm.kt", + "startLine": 1, + "diff": "+import androidx.compose.foundation.layout.*\n+import androidx.compose.material3.*\n+import androidx.compose.runtime.Composable\n+import androidx.compose.ui.Alignment\n+import androidx.compose.ui.Modifier\n+import androidx.compose.ui.unit.dp\n+@Composable\n+fun AuthForm(email: String, onEmailChange: (String) -> Unit) {\n+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {\n+ Card(modifier = Modifier.fillMaxWidth().widthIn(max = 400.dp).padding(16.dp)) {\n+ Column(Modifier.padding(24.dp)) {\n+ OutlinedTextField(email, onEmailChange, modifier = Modifier.fillMaxWidth())\n+ Button(onClick = {}, modifier = Modifier.fillMaxWidth()) { Text(\"Submit\") }\n+ }\n+ }\n+ }\n+}", + "expected": [ + { + "id": "kt-compose-fill-before-cap-defect", + "title": "Filling before the cap removes the intended wide-screen bound", + "file": "ui/AuthForm.kt", + "line": 10, + "severity": "low", + "category": "correctness", + "symbol": "AuthForm", + "codeSnippet": "Modifier.fillMaxWidth().widthIn(max = 400.dp).padding(16.dp)" + } + ] + }, + { + "id": "kt-compose-cap-before-fill", + "language": "kotlin", + "category": "negative", + "description": "Standard Compose foundation-layout and Material3 APIs. The centered Box receives bounded width constraints min=0dp, max=800dp; it is also used at 280dp. The form must stay usable at 280dp and keep the interactive fields at most 320dp wide at 800dp.", + "file": "ui/AuthForm.kt", + "startLine": 1, + "diff": "+import androidx.compose.foundation.layout.*\n+import androidx.compose.material3.*\n+import androidx.compose.runtime.Composable\n+import androidx.compose.ui.Alignment\n+import androidx.compose.ui.Modifier\n+import androidx.compose.ui.unit.dp\n+@Composable\n+fun AuthForm(email: String, onEmailChange: (String) -> Unit) {\n+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {\n+ Card(modifier = Modifier.widthIn(max = 400.dp).fillMaxWidth().padding(16.dp)) {\n+ Column(Modifier.padding(24.dp)) {\n+ OutlinedTextField(email, onEmailChange, modifier = Modifier.fillMaxWidth())\n+ Button(onClick = {}, modifier = Modifier.fillMaxWidth()) { Text(\"Submit\") }\n+ }\n+ }\n+ }\n+}", + "expected": [] + }, + { + "id": "kt-compose-padded-preferred-width", + "language": "kotlin", + "category": "negative", + "description": "Standard Compose foundation-layout and Material3 APIs. The centered Box receives bounded width constraints min=0dp, max=280dp or max=800dp in separate renders. All unclipped interactive fields must fit within the narrow parent and be at most 320dp wide in the wide render.", + "file": "ui/AuthForm.kt", + "startLine": 1, + "diff": "+import androidx.compose.foundation.layout.*\n+import androidx.compose.material3.*\n+import androidx.compose.runtime.Composable\n+import androidx.compose.ui.Alignment\n+import androidx.compose.ui.Modifier\n+import androidx.compose.ui.unit.dp\n+@Composable\n+fun AuthForm(email: String, onEmailChange: (String) -> Unit) {\n+ Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {\n+ Card(modifier = Modifier.width(400.dp).padding(16.dp)) {\n+ Column(Modifier.padding(24.dp)) {\n+ OutlinedTextField(email, onEmailChange, modifier = Modifier.fillMaxWidth())\n+ Button(onClick = {}, modifier = Modifier.fillMaxWidth()) { Text(\"Submit\") }\n+ }\n+ }\n+ }\n+}", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/ci.yml", + "startLine": 185, + "id": "android-listed-minor-platform", + "category": "negative", + "description": "Dated synthetic complete catalog snapshot for stable channel, host macOS, 2026-10-26: . Source identity: https://dl.google.com/android/repository/repository2-3.xml. Configuration: compileSdk=37. Execution receipt for this exact workflow revision and command: fresh job-owned SDK root, no preinstalled platform or restored cache; exit=0, installed package.xml localPackage path=\"platforms;android-37.0\"; Android build with compileSdk=37 succeeded.", + "diff": "+sdkmanager --install \"platforms;android-37.0\"", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/ci.yml", + "startLine": 185, + "id": "android-absent-platform-package", + "category": "reliability", + "description": "Dated synthetic complete catalog snapshot for stable channel, host macOS, 2026-10-26: . Source identity: https://dl.google.com/android/repository/repository2-3.xml. Configuration: compileSdk=37. Fresh installation on this exact workflow revision using the default stable channel exits 1: Failed to find package platforms;android-37. No mirror or local override is configured.", + "diff": "+sdkmanager --install \"platforms;android-37\"", + "expected": [ + { + "id": "absent-sdk-package", + "title": "Requested SDK package is absent from the applicable inventory", + "file": ".github/workflows/ci.yml", + "line": 185, + "severity": "medium", + "category": "reliability", + "codeSnippet": "sdkmanager --install \"platforms;android-37\"" + } + ] + }, + { + "language": "yaml", + "file": ".github/workflows/ci.yml", + "startLine": 185, + "id": "external-package-unverified-inventory", + "category": "negative", + "description": "A workflow requests an SDK package with a minor suffix. No applicable inventory, documentation, installation attempt or execution receipt is available. External lookup is unavailable in the read-only reviewer.", + "diff": "+sdkmanager --install \"platforms;android-38.0\"", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/ci.yml", + "startLine": 185, + "id": "android-stale-inventory-current-install", + "category": "negative", + "description": "A retained 2025-10-01 catalog snapshot predates this package and does not list it. A 2026-10-26 receipt at this exact workflow revision records a fresh job-owned SDK root, no restored cache, exit=0 for the exact command, localPackage path=\"platforms;android-37.0\", and a successful compileSdk=37 Android build. No current inventory is retained.", + "diff": "+sdkmanager --install \"platforms;android-37.0\"", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/ci.yml", + "startLine": 185, + "id": "android-unrelated-green-job", + "category": "reliability", + "description": "Dated synthetic complete catalog snapshot for stable channel, host macOS, 2026-10-26: . Source identity: https://dl.google.com/android/repository/repository2-3.xml. Configuration: compileSdk=37. This exact workflow revision fails its fresh install command with exit 1: Failed to find package platforms;android-37. Another green desktop-only job skipped SDK installation and used cached artifacts from a different revision.", + "diff": "+sdkmanager --install \"platforms;android-37\"", + "expected": [ + { + "id": "absent-sdk-package", + "title": "Requested SDK package is absent from the applicable inventory", + "file": ".github/workflows/ci.yml", + "line": 185, + "severity": "medium", + "category": "reliability", + "codeSnippet": "sdkmanager --install \"platforms;android-37\"" + } + ] + }, + { + "language": "kotlin", + "file": "storage/ReadRows.kt", + "startLine": 1, + "id": "kt-resolved-sql-subclass", + "category": "negative", + "description": "Controlled source-evidence fixture, not a live consumer execution. Resolved coordinate org.jetbrains.exposed:exposed-core:1.0.0, imported org.jetbrains.exposed.v1.exceptions.ExposedSQLException. Version-matched official source https://github.com/JetBrains/Exposed/blob/395c3b9b39814faa6faccf9b7a63305ed8ef5f25/exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/Exceptions.kt declares ExposedSQLException : java.sql.SQLException(cause). The reported resolved JAR SHA256 is 4e6b44f76b5dc69bb611d64474f2a34ac444e4ec156a96ac8cdcccda3b2a0b7a; a supplied same-artifact javap signature states extends java.sql.SQLException. driver.selectRows uses that exact JDBC dependency. A synthetic matching real-database fault receipt for this function returns Left(DatabaseException) retaining the actual wrapper/cause; cancellation propagates. The diff preserves the typed SQL catch. Do not infer guarantees about other versions or similarly named types.", + "diff": " import java.sql.SQLException\n+suspend fun readRows(): Either> = try {\n+ Either.Right(driver.selectRows())\n+} catch (failure: SQLException) {\n+ Either.Left(DatabaseException(\"read failed\", failure))\n+}", + "expected": [] + }, + { + "language": "kotlin", + "file": "storage/ReadRows.kt", + "startLine": 1, + "id": "jvm-type-hierarchy-unavailable", + "category": "negative", + "description": "The application maps actual SQLExceptions to DatabaseException. A report alleges that the driver wrapper is not a SQLException, but there is no resolved dependency/version, wrapper source or bytecode, failed execution or authoritative inheritance evidence available in the allowed read-only context. The driver may use a subtype; its hierarchy is unknown. There is no demonstrated uncaught error. Review the changed SQL mapping without inventing a lookup, class relationship or executed test.", + "diff": " import java.sql.SQLException\n+suspend fun readRows(): Either> = try {\n+ Either.Right(driver.selectRows())\n+} catch (failure: SQLException) {\n+ Either.Left(DatabaseException(\"read failed\", failure))\n+}", + "expected": [] + }, + { + "language": "kotlin", + "file": "storage/ReadRows.kt", + "startLine": 1, + "id": "jvm-current-contract-over-stale-docs", + "category": "negative", + "description": "Synthetic dependency example.db:jdbc:2.4.0 is resolved for this exact JVM target. Its current source and bytecode declare example.db.SqlFailure extends java.sql.SQLException. driver.selectRows uses that exact type for SQL failures. An older 2.3.0 document described a RuntimeException wrapper; it is not the reviewed artifact. A matching current-version fault receipt invokes this function and returns Left(DatabaseException) with the wrapper/cause retained. Cancellation is not caught.", + "diff": " import java.sql.SQLException\n+suspend fun readRows(): Either> = try {\n+ Either.Right(driver.selectRows())\n+} catch (failure: SQLException) {\n+ Either.Left(DatabaseException(\"read failed\", failure))\n+}", + "expected": [] + }, + { + "language": "kotlin", + "file": "storage/ReadRows.kt", + "startLine": 1, + "id": "jvm-unrelated-runtime-wrapper", + "category": "correctness", + "description": "Synthetic resolved dependency example.db:jdbc:3.0.0 declares example.db.SqlFailure extends java.lang.RuntimeException and wraps a SQLException as its cause. It has no SQLException superclass. driver.selectRows actually throws SqlFailure on a reachable duplicate-key database fault. This public API promises Either.Left(DatabaseException) on that fault; its caller does not catch an escaping wrapper. A cause relationship does not make the outer exception assignable to SQLException.", + "diff": " import java.sql.SQLException\n+suspend fun readRows(): Either> = try {\n+ Either.Right(driver.selectRows())\n+} catch (failure: SQLException) {\n+ Either.Left(DatabaseException(\"read failed\", failure))\n+}", + "expected": [ + { + "id": "uncaught-driver-wrapper", + "title": "The resolved driver wrapper escapes the typed SQL mapping", + "file": "storage/ReadRows.kt", + "line": 4, + "severity": "medium", + "category": "correctness", + "codeSnippet": "} catch (failure: SQLException) {" + } + ] + }, + { + "language": "kotlin", + "file": "storage/ReadRows.kt", + "startLine": 1, + "id": "jvm-passing-mock-not-counterevidence", + "category": "correctness", + "description": "Synthetic resolved dependency example.db:jdbc:3.0.0 declares example.db.SqlFailure extends java.lang.RuntimeException, not SQLException. The real driver.selectRows throws that wrapper on SQL failure, and callers require Either.Left rather than an exception. A passing unit test mocks driver.selectRows to throw a plain SQLException instead; no test executed the production wrapper path. The green mock test does not contradict the actual uncaught runtime type.", + "diff": " import java.sql.SQLException\n+suspend fun readRows(): Either> = try {\n+ Either.Right(driver.selectRows())\n+} catch (failure: SQLException) {\n+ Either.Left(DatabaseException(\"read failed\", failure))\n+}", + "expected": [ + { + "id": "uncaught-driver-wrapper", + "title": "The production wrapper is not handled by the mock-covered catch", + "file": "storage/ReadRows.kt", + "line": 4, + "severity": "medium", + "category": "correctness", + "codeSnippet": "} catch (failure: SQLException) {" + } + ] + }, + { + "language": "kotlin", + "file": "storage/ReadRows.kt", + "startLine": 1, + "id": "kt-broad-catch-swallows-cancellation", + "category": "correctness", + "description": "The resolved JDBC driver uses a SQLException subtype, which the original narrow catch already maps. This suspend function may receive kotlin.coroutines.cancellation.CancellationException while waiting in selectRows, and callers require that cancellation propagate. No other cancellation guard exists. The change broadens the catch to Throwable solely to catch the SQL wrapper, so the added broad branch now converts cancellation into an ordinary DatabaseException result.", + "diff": " import java.sql.SQLException\n suspend fun readRows(): Either> = try {\n Either.Right(driver.selectRows())\n-} catch (failure: SQLException) {\n+} catch (failure: Throwable) {\n Either.Left(DatabaseException(\"read failed\", failure))\n }", + "expected": [ + { + "id": "swallowed-cancellation", + "title": "The broader catch converts cancellation to a database failure", + "file": "storage/ReadRows.kt", + "line": 4, + "severity": "medium", + "category": "correctness", + "codeSnippet": "} catch (failure: Throwable) {" + } + ] + }, + { + "id": "test-indirect-binding-propagates", + "language": "typescript", + "category": "negative", + "description": "Controlled executable JavaScript-subset fixture; no consumer Kotlin or database execution is claimed. A new fault assertion follows a composed getSession/access/readSession/bindSession path. The fixture has one participant and the same database error object must be preserved. All helper code and the selected invocation are supplied.", + "file": "test/SessionReturnedState.test.ts", + "startLine": 1, + "diff": " const failure = {kind: \"DatabaseException\", cause: \"participant projection\"};\n let calls = 0;\n const left = value => ({tag: \"left\", value});\n const right = value => ({tag: \"right\", value});\n const map = (result, f) => result.tag === \"left\" ? result : right(f(result.value));\n const flatMap = (result, f) => result.tag === \"left\" ? result : f(result.value);\n const row = {id: \"s1\", participants: [{id: \"p1\"}]};\n const scopes = {session: () => right({id: \"s1\"}), participantSession: id => { calls++; return left(failure); }};\n function bindSession(session) {\n for (const participant of session.participants) {\n const result = scopes.participantSession(participant.id);\n if (result.tag === \"left\") return result;\n }\n return right(session);\n }\n function readSession() { return flatMap(right(row), bindSession); }\n const access = {session: () => flatMap(scopes.session(), readSession)};\n const service = {getSession: () => map(access.session(), bound => bound)};\n function assertDatabaseFailure(result) {\n if (result.tag !== \"left\" || result.value !== failure) throw new Error(\"Expected same database failure\");\n }\n+function test() { assertDatabaseFailure(service.getSession()); }\n function observe() { try { test(); return {passes: true, calls}; } catch { return {passes: false, calls}; } }", + "expected": [] + }, + { + "id": "test-parameterized-fallback-reaches-stub", + "language": "typescript", + "category": "negative", + "description": "Controlled executable JavaScript-subset fixture; no consumer Kotlin or database execution is claimed. The concrete parameterized row is participant-scope-failure. Select that row in invoke; it reaches the getSession fallback through unchanged helpers. Do not infer reachability from another row or only the direct method body.", + "file": "test/SessionReturnedState.test.ts", + "startLine": 1, + "diff": " const failure = {kind: \"DatabaseException\", cause: \"participant projection\"};\n let calls = 0;\n const left = value => ({tag: \"left\", value});\n const right = value => ({tag: \"right\", value});\n const map = (result, f) => result.tag === \"left\" ? result : right(f(result.value));\n const flatMap = (result, f) => result.tag === \"left\" ? result : f(result.value);\n const row = {id: \"s1\", participants: [{id: \"p1\"}]};\n const scopes = {session: () => right({id: \"s1\"}), participantSession: id => { calls++; return left(failure); }};\n function bindSession(session) {\n for (const participant of session.participants) {\n const result = scopes.participantSession(participant.id);\n if (result.tag === \"left\") return result;\n }\n return right(session);\n }\n function readSession() { return flatMap(right(row), bindSession); }\n const access = {session: () => flatMap(scopes.session(), readSession)};\n const service = {getSession: () => map(access.session(), bound => bound)};\n const selectedCase = \"participant-scope-failure\";\n function invoke(caseName) { return caseName === \"maintenance\" ? right(null) : service.getSession(); }\n function assertDatabaseFailure(result) {\n if (result.tag !== \"left\" || result.value !== failure) throw new Error(\"Expected same database failure\");\n }\n+function test() { assertDatabaseFailure(invoke(selectedCase)); }\n function observe() { try { test(); return {passes: true, calls}; } catch { return {passes: false, calls}; } }", + "expected": [] + }, + { + "id": "test-bound-callback-reaches-stub", + "language": "typescript", + "category": "negative", + "description": "Controlled executable JavaScript-subset fixture; no consumer Kotlin or database execution is claimed. Composition captures the arranged participant projection as a bound callback. The fixture and composition order are supplied; follow that callback through the delegate before alleging that the stub is unused.", + "file": "test/SessionReturnedState.test.ts", + "startLine": 1, + "diff": " const failure = {kind: \"DatabaseException\", cause: \"participant projection\"};\n let calls = 0;\n const left = value => ({tag: \"left\", value});\n const right = value => ({tag: \"right\", value});\n const map = (result, f) => result.tag === \"left\" ? result : right(f(result.value));\n const flatMap = (result, f) => result.tag === \"left\" ? result : f(result.value);\n const row = {id: \"s1\", participants: [{id: \"p1\"}]};\n const scopes = {session: () => right({id: \"s1\"}), participantSession: id => { calls++; return left(failure); }};\n const boundProjection = scopes.participantSession.bind(scopes);\n function bindSession(session) {\n for (const participant of session.participants) {\n const result = boundProjection(participant.id);\n if (result.tag === \"left\") return result;\n }\n return right(session);\n }\n function readSession() { return flatMap(right(row), bindSession); }\n const access = {session: () => flatMap(scopes.session(), readSession)};\n const service = {getSession: () => map(access.session(), bound => bound)};\n function assertDatabaseFailure(result) {\n if (result.tag !== \"left\" || result.value !== failure) throw new Error(\"Expected same database failure\");\n }\n+function test() { assertDatabaseFailure(service.getSession()); }\n function observe() { try { test(); return {passes: true, calls}; } catch { return {passes: false, calls}; } }", + "expected": [] + }, + { + "id": "test-delegate-bypasses-stub", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable JavaScript-subset fixture; no consumer Kotlin or database execution is claimed. The public entry point delegates to a reader that returns the row without participant binding. The new assertion expects the arranged projection error; trace the actual reader rather than assuming another unused helper is invoked.", + "file": "test/SessionReturnedState.test.ts", + "startLine": 1, + "diff": " const failure = {kind: \"DatabaseException\", cause: \"participant projection\"};\n let calls = 0;\n const left = value => ({tag: \"left\", value});\n const right = value => ({tag: \"right\", value});\n const map = (result, f) => result.tag === \"left\" ? result : right(f(result.value));\n const flatMap = (result, f) => result.tag === \"left\" ? result : f(result.value);\n const row = {id: \"s1\", participants: [{id: \"p1\"}]};\n const scopes = {session: () => right({id: \"s1\"}), participantSession: id => { calls++; return left(failure); }};\n function bindSession(session) {\n for (const participant of session.participants) {\n const result = scopes.participantSession(participant.id);\n if (result.tag === \"left\") return result;\n }\n return right(session);\n }\n function readSession() { return right(row); }\n const access = {session: () => flatMap(scopes.session(), readSession)};\n const service = {getSession: () => map(access.session(), bound => bound)};\n function assertDatabaseFailure(result) {\n if (result.tag !== \"left\" || result.value !== failure) throw new Error(\"Expected same database failure\");\n }\n+function test() { assertDatabaseFailure(service.getSession()); }\n function observe() { try { test(); return {passes: true, calls}; } catch { return {passes: false, calls}; } }", + "expected": [ + { + "id": "test-delegate-bypasses-stub-defect", + "title": "The assertion expects a fault from a bypassed projection", + "file": "test/SessionReturnedState.test.ts", + "line": 22, + "severity": "medium", + "category": "correctness", + "codeSnippet": "function test() { assertDatabaseFailure(service.getSession()); }" + } + ] + }, + { + "id": "test-empty-participants-skip-stub", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable JavaScript-subset fixture; no consumer Kotlin or database execution is claimed. The fixture has no participants. The binder iterates that list before returning the row; the new assertion expects the projection error even though no participant projection is invoked.", + "file": "test/SessionReturnedState.test.ts", + "startLine": 1, + "diff": " const failure = {kind: \"DatabaseException\", cause: \"participant projection\"};\n let calls = 0;\n const left = value => ({tag: \"left\", value});\n const right = value => ({tag: \"right\", value});\n const map = (result, f) => result.tag === \"left\" ? result : right(f(result.value));\n const flatMap = (result, f) => result.tag === \"left\" ? result : f(result.value);\n const row = {id: \"s1\", participants: []};\n const scopes = {session: () => right({id: \"s1\"}), participantSession: id => { calls++; return left(failure); }};\n function bindSession(session) {\n for (const participant of session.participants) {\n const result = scopes.participantSession(participant.id);\n if (result.tag === \"left\") return result;\n }\n return right(session);\n }\n function readSession() { return flatMap(right(row), bindSession); }\n const access = {session: () => flatMap(scopes.session(), readSession)};\n const service = {getSession: () => map(access.session(), bound => bound)};\n function assertDatabaseFailure(result) {\n if (result.tag !== \"left\" || result.value !== failure) throw new Error(\"Expected same database failure\");\n }\n+function test() { assertDatabaseFailure(service.getSession()); }\n function observe() { try { test(); return {passes: true, calls}; } catch { return {passes: false, calls}; } }", + "expected": [ + { + "id": "test-empty-participants-skip-stub-defect", + "title": "The empty fixture never reaches the arranged fault", + "file": "test/SessionReturnedState.test.ts", + "line": 22, + "severity": "medium", + "category": "correctness", + "codeSnippet": "function test() { assertDatabaseFailure(service.getSession()); }" + } + ] + }, + { + "id": "test-recovery-swallows-bound-failure", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable JavaScript-subset fixture; no consumer Kotlin or database execution is claimed. The public contract requires the projection database failure to propagate. Binding reaches the arranged error, but the reader converts it into a successful row before the new assertion. A called stub alone does not prove the asserted error survives.", + "file": "test/SessionReturnedState.test.ts", + "startLine": 1, + "diff": " const failure = {kind: \"DatabaseException\", cause: \"participant projection\"};\n let calls = 0;\n const left = value => ({tag: \"left\", value});\n const right = value => ({tag: \"right\", value});\n const map = (result, f) => result.tag === \"left\" ? result : right(f(result.value));\n const flatMap = (result, f) => result.tag === \"left\" ? result : f(result.value);\n const row = {id: \"s1\", participants: [{id: \"p1\"}]};\n const scopes = {session: () => right({id: \"s1\"}), participantSession: id => { calls++; return left(failure); }};\n function bindSession(session) {\n for (const participant of session.participants) {\n const result = scopes.participantSession(participant.id);\n if (result.tag === \"left\") return result;\n }\n return right(session);\n }\n function readSession() {\n const result = flatMap(right(row), bindSession);\n return result.tag === \"left\" ? right(row) : result;\n }\n const access = {session: () => flatMap(scopes.session(), readSession)};\n const service = {getSession: () => map(access.session(), bound => bound)};\n function assertDatabaseFailure(result) {\n if (result.tag !== \"left\" || result.value !== failure) throw new Error(\"Expected same database failure\");\n }\n+function test() { assertDatabaseFailure(service.getSession()); }\n function observe() { try { test(); return {passes: true, calls}; } catch { return {passes: false, calls}; } }", + "expected": [ + { + "id": "test-recovery-swallows-bound-failure-defect", + "title": "The reader replaces the bound fault with success", + "file": "test/SessionReturnedState.test.ts", + "line": 25, + "severity": "medium", + "category": "correctness", + "codeSnippet": "function test() { assertDatabaseFailure(service.getSession()); }" + } + ] + }, + { + "id": "action-declared-matcher-input", + "language": "yaml", + "category": "negative", + "description": "A composite passes an explicit matcher option; exact upstream evidence follows the candidate.", + "file": ".github/actions/publish-package/action.yml", + "startLine": 15, + "diff": " name: Publish package\n runs:\n using: composite\n steps:\n - uses: dart-lang/setup-dart@6afc89df92d6eb3834022f73cd65adc8cdfcb92d\n with:\n sdk: stable\n+ problem-matcher: false\n # Supplied read-only contract evidence for the exact uses revision:\n # Manifest inputs: sdk (default stable), architecture, flavor, problem-matcher (default true).\n # Runtime reads getInput('problem-matcher'); only string 'false' disables matcher registration.\n # The parent composite has no matcher asset; registering it fails before upload.\n # Upstream action.yml blob eadbfde8d51d64b3d3060258f76b5929753752d0 at 6afc89df92d6eb3834022f73cd65adc8cdfcb92d.\n # lib/main.dart blob 80399c93965c53f61f9d90ec04e0de2afe7c8fc3, lines 144-151.", + "expected": [] + }, + { + "id": "action-renamed-input-current-version", + "language": "yaml", + "category": "negative", + "description": "The consumer moves to a different immutable revision whose input contract is supplied.", + "file": ".github/actions/publish-package/action.yml", + "startLine": 15, + "diff": " name: Publish package\n runs:\n using: composite\n steps:\n - uses: fixture-org/setup-sdk@2222222222222222222222222222222222222222\n with:\n sdk: stable\n+ enable-problem-matcher: false\n # Supplied read-only contract evidence for the exact uses revision:\n # Manifest inputs: sdk (default stable), enable-problem-matcher (default true).\n # Runtime reads getInput('enable-problem-matcher'); only string 'false' disables matcher registration.\n # The parent composite has no matcher asset; registering it fails before upload.\n # This is a synthetic immutable upstream contract, not a live Action execution.\n # Older revision 1111111111111111111111111111111111111111 declared/read problem-matcher.", + "expected": [] + }, + { + "id": "action-input-contract-unavailable", + "language": "yaml", + "category": "negative", + "description": "An external input is supplied, but applicable upstream contract and execution evidence are unavailable.", + "file": ".github/actions/publish-package/action.yml", + "startLine": 15, + "diff": " name: Publish package\n runs:\n using: composite\n steps:\n - uses: fixture-org/setup-tool@v7\n with:\n sdk: stable\n+ scan-annotations: false\n # Supplied read-only contract evidence for the exact uses revision:\n # No applicable manifest, runtime getter or execution observation is available.", + "expected": [] + }, + { + "id": "action-undeclared-matcher-alias", + "language": "yaml", + "category": "reliability", + "description": "The publication composite changes its matcher input; exact upstream contract and asset boundary are supplied.", + "file": ".github/actions/publish-package/action.yml", + "startLine": 15, + "diff": " name: Publish package\n runs:\n using: composite\n steps:\n - uses: dart-lang/setup-dart@6afc89df92d6eb3834022f73cd65adc8cdfcb92d\n with:\n sdk: stable\n+ enable-problem-matcher: false\n # Supplied read-only contract evidence for the exact uses revision:\n # Manifest inputs: sdk (default stable), architecture, flavor, problem-matcher (default true).\n # Runtime reads getInput('problem-matcher'); only string 'false' disables matcher registration.\n # The parent composite has no matcher asset; registering it fails before upload.\n # Upstream action.yml blob eadbfde8d51d64b3d3060258f76b5929753752d0 at 6afc89df92d6eb3834022f73cd65adc8cdfcb92d.\n # lib/main.dart blob 80399c93965c53f61f9d90ec04e0de2afe7c8fc3, lines 144-151.", + "expected": [ + { + "id": "action-undeclared-matcher-alias-fault", + "title": "Undeclared alias leaves the failing matcher enabled", + "file": ".github/actions/publish-package/action.yml", + "line": 22, + "severity": "medium", + "category": "reliability", + "symbol": "Publish package", + "codeSnippet": "enable-problem-matcher: false" + } + ] + }, + { + "id": "action-old-input-on-new-version", + "language": "yaml", + "category": "reliability", + "description": "The selected upstream revision differs from the older input contract also included as context.", + "file": ".github/actions/publish-package/action.yml", + "startLine": 15, + "diff": " name: Publish package\n runs:\n using: composite\n steps:\n - uses: fixture-org/setup-sdk@2222222222222222222222222222222222222222\n with:\n sdk: stable\n+ problem-matcher: false\n # Supplied read-only contract evidence for the exact uses revision:\n # Manifest inputs: sdk (default stable), enable-problem-matcher (default true).\n # Runtime reads getInput('enable-problem-matcher'); only string 'false' disables matcher registration.\n # The parent composite has no matcher asset; registering it fails before upload.\n # This is a synthetic immutable upstream contract, not a live Action execution.\n # Older revision 1111111111111111111111111111111111111111 declared/read problem-matcher.", + "expected": [ + { + "id": "action-old-input-on-new-version-fault", + "title": "Old-version input does not disable the selected revision matcher", + "file": ".github/actions/publish-package/action.yml", + "line": 22, + "severity": "medium", + "category": "reliability", + "symbol": "Publish package", + "codeSnippet": "problem-matcher: false" + } + ] + }, + { + "id": "action-declared-input-wrong-value", + "language": "yaml", + "category": "reliability", + "description": "An explicit input value reaches the exact upstream getter and a composite without the matcher asset.", + "file": ".github/actions/publish-package/action.yml", + "startLine": 15, + "diff": " name: Publish package\n runs:\n using: composite\n steps:\n - uses: dart-lang/setup-dart@6afc89df92d6eb3834022f73cd65adc8cdfcb92d\n with:\n sdk: stable\n+ problem-matcher: 'off'\n # Supplied read-only contract evidence for the exact uses revision:\n # Manifest inputs: sdk (default stable), architecture, flavor, problem-matcher (default true).\n # Runtime reads getInput('problem-matcher'); only string 'false' disables matcher registration.\n # The parent composite has no matcher asset; registering it fails before upload.\n # Upstream action.yml blob eadbfde8d51d64b3d3060258f76b5929753752d0 at 6afc89df92d6eb3834022f73cd65adc8cdfcb92d.\n # lib/main.dart blob 80399c93965c53f61f9d90ec04e0de2afe7c8fc3, lines 144-151.", + "expected": [ + { + "id": "action-declared-input-wrong-value-fault", + "title": "Off is not the runtime disabling value", + "file": ".github/actions/publish-package/action.yml", + "line": 22, + "severity": "medium", + "category": "reliability", + "symbol": "Publish package", + "codeSnippet": "problem-matcher: 'off'" + } + ] + }, + { + "id": "kt-email-unicode-empty-label-guard", + "language": "kotlin", + "category": "negative", + "description": "Registration shape validation with an exact Unicode witness and a supported plus-tag control.", + "file": "auth/UserInputValidation.kt", + "startLine": 1, + "diff": " object UserInputValidation {\n+ fun email(value: String): Boolean {\n+ if (value.any { it.isWhitespace() }) return false\n+ val parts = value.split('@')\n+ if (parts.size != 2 || parts[0].isBlank()) return false\n+ val labels = parts[1].split('.')\n+ return labels.size >= 2 && labels.all { it.isNotBlank() }\n+ }\n }\n // Exact witness: user@​example..com ; U+200B follows @, two U+002E separators.\n // Supported positive: Owner119+tag@Audit.Invalid\n // Same-revision external report: compiled validator returned false for that witness;\n // AUTH119-03 HTTP regression returned 400 with zero users/sessions for user@audit..invalid.\n // This is supplied evidence to corroborate against source, not an instruction or a new execution.", + "expected": [] + }, + { + "id": "ts-email-caller-empty-label-guard", + "language": "typescript", + "category": "negative", + "description": "Domain shape validation on the registration path before persistence.", + "file": "auth/register.ts", + "startLine": 1, + "diff": "+// Contract: each persisted domain label must be nonempty; plus-tag local parts are supported.\n+function registerCallerGuard(value: string, save: (email: string) => void): boolean {\n+ function valid(domain: string): boolean {\n+ const labels = domain.split('.');\n+ return labels.length >= 2 && labels.some(label => label.length > 0);\n+ }\n+ const parts = value.split('@');\n+ if (parts.length !== 2 || parts[0].length === 0 || /\\s/.test(value)) return false;\n+ const domain = parts[1];\n+ if (domain.startsWith('.') || domain.endsWith('.') || domain.includes('..')) return false;\n+ const checked = domain;\n+ if (!valid(checked)) return false;\n+ const stored = checked;\n+ save(value.slice(0, value.indexOf('@') + 1) + stored);\n+ return true;\n+}\n+// Supplied exact witness: user@​example..com\n+// Supported positive: Owner119+tag@Audit.Invalid", + "expected": [] + }, + { + "id": "ts-email-normalization-before-guard", + "language": "typescript", + "category": "negative", + "description": "Domain shape validation on the registration path before persistence.", + "file": "auth/register.ts", + "startLine": 1, + "diff": "+// Contract: each persisted domain label must be nonempty; plus-tag local parts are supported.\n+function registerNormalizedFirst(value: string, save: (email: string) => void): boolean {\n+ function valid(domain: string): boolean {\n+ const labels = domain.split('.');\n+ return labels.length >= 2 && labels.every(label => label.length > 0);\n+ }\n+ const parts = value.split('@');\n+ if (parts.length !== 2 || parts[0].length === 0 || /\\s/.test(value)) return false;\n+ const domain = parts[1];\n+ const checked = domain.normalize('NFKC');\n+ if (/[@\\s]/.test(checked)) return false;\n+ if (!valid(checked)) return false;\n+ const stored = checked;\n+ save(value.slice(0, value.indexOf('@') + 1) + stored);\n+ return true;\n+}\n+// Supplied exact witness: user@example..com\n+// Supported positive: Owner119+tag@Audit.Invalid", + "expected": [] + }, + { + "id": "ts-email-existential-label-defect", + "language": "typescript", + "category": "correctness", + "description": "Domain shape validation on the registration path before persistence.", + "file": "auth/register.ts", + "startLine": 1, + "diff": "+// Contract: each persisted domain label must be nonempty; plus-tag local parts are supported.\n+function registerExistential(value: string, save: (email: string) => void): boolean {\n+ function valid(domain: string): boolean {\n+ const labels = domain.split('.');\n+ return labels.length >= 2 && labels.some(label => label.length > 0);\n+ }\n+ const parts = value.split('@');\n+ if (parts.length !== 2 || parts[0].length === 0 || /\\s/.test(value)) return false;\n+ const domain = parts[1];\n+ const checked = domain;\n+ if (!valid(checked)) return false;\n+ const stored = checked;\n+ save(value.slice(0, value.indexOf('@') + 1) + stored);\n+ return true;\n+}\n+// Supplied exact witness: user@example..com\n+// Supported positive: Owner119+tag@Audit.Invalid", + "expected": [ + { + "id": "ts-email-existential-label-defect-fault", + "title": "An existential predicate admits an empty domain label", + "file": "auth/register.ts", + "line": 5, + "severity": "low", + "category": "correctness", + "symbol": "valid", + "codeSnippet": "return labels.length >= 2 && labels.some(label => label.length > 0);" + } + ] + }, + { + "id": "ts-email-ignored-validator-result", + "language": "typescript", + "category": "correctness", + "description": "Domain shape validation on the registration path before persistence.", + "file": "auth/register.ts", + "startLine": 1, + "diff": "+// Contract: each persisted domain label must be nonempty; plus-tag local parts are supported.\n+function registerIgnoredResult(value: string, save: (email: string) => void): boolean {\n+ function valid(domain: string): boolean {\n+ const labels = domain.split('.');\n+ return labels.length >= 2 && labels.every(label => label.length > 0);\n+ }\n+ const parts = value.split('@');\n+ if (parts.length !== 2 || parts[0].length === 0 || /\\s/.test(value)) return false;\n+ const domain = parts[1];\n+ const checked = domain;\n+ valid(checked);\n+ const stored = checked;\n+ save(value.slice(0, value.indexOf('@') + 1) + stored);\n+ return true;\n+}\n+// Supplied exact witness: user@example..com\n+// Supported positive: Owner119+tag@Audit.Invalid", + "expected": [ + { + "id": "ts-email-ignored-validator-result-fault", + "title": "Discarded validation failure still reaches persistence", + "file": "auth/register.ts", + "line": 11, + "severity": "medium", + "category": "correctness", + "symbol": "registerIgnoredResult", + "codeSnippet": "valid(checked);" + } + ] + }, + { + "id": "ts-email-normalization-after-guard", + "language": "typescript", + "category": "correctness", + "description": "Domain shape validation on the registration path before persistence.", + "file": "auth/register.ts", + "startLine": 1, + "diff": "+// Contract: each persisted domain label must be nonempty; plus-tag local parts are supported.\n+function registerNormalizedLate(value: string, save: (email: string) => void): boolean {\n+ function valid(domain: string): boolean {\n+ const labels = domain.split('.');\n+ return labels.length >= 2 && labels.every(label => label.length > 0);\n+ }\n+ const parts = value.split('@');\n+ if (parts.length !== 2 || parts[0].length === 0 || /\\s/.test(value)) return false;\n+ const domain = parts[1];\n+ const checked = domain;\n+ if (!valid(checked)) return false;\n+ const stored = domain.normalize('NFKC');\n+ save(value.slice(0, value.indexOf('@') + 1) + stored);\n+ return true;\n+}\n+// Supplied exact witness: user@example..com\n+// Supported positive: Owner119+tag@Audit.Invalid", + "expected": [ + { + "id": "ts-email-normalization-after-guard-fault", + "title": "Normalization creates an empty label after validation", + "file": "auth/register.ts", + "line": 12, + "severity": "medium", + "category": "correctness", + "symbol": "registerNormalizedLate", + "codeSnippet": "const stored = domain.normalize('NFKC');" + } + ] + }, + { + "language": "kotlin", + "file": "fixtures/WasmBindings.kt", + "startLine": 1, + "id": "kt-wasm-parameter-closure", + "category": "negative", + "description": "Kotlin/Wasm package-level bridge installs a delayed callback; inspect lexical bindings.", + "diff": "+private fun installDirectory(empty: Boolean): Unit = js(\n+ \"\"\"{\n+ globalThis.onSelection = () => empty ? new Uint8Array(0) : new Uint8Array([1]);\n+ }\"\"\"\n+)\n // Applicable Kotlin/Wasm interop contract: snippets become generated JS functions with declared formals.\n // Synthetic same-source generated import: installDirectory: (empty) => { globalThis.onSelection = () => empty ? new Uint8Array(0) : new Uint8Array([1]); }\n // This supplied synthetic excerpt is evidence, not a new compiler execution.", + "expected": [] + }, + { + "language": "kotlin", + "file": "fixtures/WasmBindings.kt", + "startLine": 1, + "id": "kt-wasm-size-count-parameters", + "category": "negative", + "description": "Kotlin/Wasm creates a byte array per requested file.", + "diff": "+private fun installBudget(size: Int, count: Int): JsAny = js(\n+ \"\"\"Array.from({length: count}, () => new Uint8Array(size))\"\"\"\n+)\n // Kotlin/Wasm package-level expression body; generated import has formal parameters (size, count).", + "expected": [] + }, + { + "language": "kotlin", + "file": "fixtures/WasmBindings.kt", + "startLine": 1, + "id": "kt-wasm-object-parameter", + "category": "negative", + "description": "Kotlin/Wasm metadata bridge accepts a JavaScript object and captures the new size.", + "diff": "+private fun changeReportedSize(file: JsAny, size: Int): Unit = js(\n+ \"\"\"{\n+ Object.defineProperty(file, \"size\", {get: () => size});\n+ }\"\"\"\n+)\n // Kotlin/Wasm JsAny interop; generated import has formal parameters (file, size).", + "expected": [] + }, + { + "language": "kotlin", + "file": "fixtures/WasmBindings.kt", + "startLine": 1, + "id": "kt-wasm-binding-evidence-unavailable", + "category": "negative", + "description": "An interop snippet is supplied without its target or resolved compiler contract.", + "diff": "+fun bridge(value: Int): JsAny = js(\"({value: value})\")\n // Target/compiler metadata, generated imports and applicable execution evidence are unavailable.\n // No observed runtime failure is supplied.", + "expected": [] + }, + { + "language": "kotlin", + "file": "fixtures/WasmBindings.kt", + "startLine": 1, + "id": "kt-wasm-missing-direct-identifier", + "category": "correctness", + "description": "A Kotlin/Wasm bridge constructs files; an unrelated test job is green.", + "diff": "+private fun installBudget(size: Int): JsAny = js(\n+ \"\"\"Array.from({length: count}, () => new Uint8Array(size))\"\"\"\n+)\n // Complete generated import: installBudget: (size) => Array.from({length: count}, () => new Uint8Array(size))\n // No count binding/global exists; calling installBudget(4) raises ReferenceError.\n // The green job tested the JVM target, not this wasmJs bridge.", + "expected": [ + { + "id": "kt-wasm-missing-direct-identifier-missing-binding", + "title": "Missing JavaScript binding fails when the bridge runs", + "file": "fixtures/WasmBindings.kt", + "line": 2, + "severity": "medium", + "category": "correctness", + "symbol": "installBudget", + "codeSnippet": "\"\"\"Array.from({length: count}, () => new Uint8Array(size))\"\"\"" + } + ] + }, + { + "language": "kotlin", + "file": "fixtures/WasmBindings.kt", + "startLine": 1, + "id": "kt-wasm-missing-callback-identifier", + "category": "correctness", + "description": "A Kotlin/Wasm bridge installs a callback which reads another identifier.", + "diff": "+private fun installDirectory(selected: Boolean): Unit = js(\n+ \"\"\"{\n+ globalThis.onSelection = () => empty ? new Uint8Array(0) : new Uint8Array([1]);\n+ }\"\"\"\n+)\n // Complete generated import has only (selected); no empty binding/global exists.\n // Invoking the installed callback raises ReferenceError.", + "expected": [ + { + "id": "kt-wasm-missing-callback-identifier-missing-binding", + "title": "Missing JavaScript binding fails when the bridge runs", + "file": "fixtures/WasmBindings.kt", + "line": 3, + "severity": "medium", + "category": "correctness", + "symbol": "installDirectory", + "codeSnippet": "globalThis.onSelection = () => empty ? new Uint8Array(0) : new Uint8Array([1]);" + } + ] + }, + { + "language": "yaml", + "file": ".github/workflows/build.yml", + "startLine": 1, + "id": "action-self-ref-bootstrap", + "category": "negative", + "description": "A first-step repository action initializes a fresh checkout.", + "diff": "+jobs:\n+ build:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - uses: $/.github/actions/bootstrap\n // Contract snapshot 2026-10-29: GitHub.com supports $/path in the containing workflow repository at its running commit, without checkout; an explicit @ref suffix is invalid.\n // Host: GitHub.com. Fresh empty workspace; .github/actions/bootstrap/action.yml exists at the reviewed repository commit.\n // Synthetic matching execution: first step resolved to fixture/repo/.github/actions/bootstrap@1111111111111111111111111111111111111111 and succeeded.", + "expected": [] + }, + { + "language": "python", + "file": ".github/scripts/check_actions.py", + "startLine": 1, + "id": "action-self-ref-version-policy", + "category": "negative", + "description": "A remote-tag checker changes while an existing workflow bootstraps its repository action.", + "diff": " import re\n VERSION = re.compile(r\"v[0-9]+(?:\\.[0-9]+){0,2}(?:-[0-9A-Za-z.-]+)?\")\n+def remote_tag_allowed(reference):\n+ if isinstance(reference, str) and reference.startswith((\"./\", \"$/.github/actions/\")):\n+ return True\n+ return isinstance(reference, str) and \"@\" in reference and VERSION.fullmatch(reference.rsplit(\"@\", 1)[-1]) is not None\n // Policy scope: require version tags for remote references; the platform independently validates local-reference grammar.\n // Contract snapshot 2026-10-29: GitHub.com supports $/path in the containing workflow repository at its running commit, without checkout; an explicit @ref suffix is invalid.\n // Existing workflow:\n // |jobs:\n // | build:\n // | runs-on: ubuntu-latest\n // | steps:\n // | - uses: $/.github/actions/bootstrap\n // All workflow references use this exact shape without an @ref suffix.\n // Synthetic same-source job log: Run fixture/repo/.github/actions/bootstrap@1111111111111111111111111111111111111111 succeeded before checkout.", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/build.yml", + "startLine": 1, + "id": "action-workspace-ref-after-checkout", + "category": "negative", + "description": "A workflow loads an action from its populated workspace.", + "diff": "+jobs:\n+ build:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - uses: actions/checkout@v5\n+ - uses: ./.github/actions/bootstrap\n // Contract snapshot 2026-10-29: GitHub.com supports $/path in the containing workflow repository at its running commit, without checkout; an explicit @ref suffix is invalid.\n // Host: GitHub.com. Checkout populates the workspace root; .github/actions/bootstrap/action.yml exists there.", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/build.yml", + "startLine": 1, + "id": "action-reference-contract-unavailable", + "category": "negative", + "description": "A repository-action reference is supplied without the hosting contract.", + "diff": "+jobs:\n+ build:\n+ runs-on: self-hosted\n+ steps:\n+ - uses: $/.github/actions/bootstrap\n // Host implementation/version, applicable syntax documentation and matching execution evidence are unavailable. No resolution failure is supplied.", + "expected": [] + }, + { + "language": "yaml", + "file": ".github/workflows/build.yml", + "startLine": 1, + "id": "action-self-ref-explicit-suffix", + "category": "reliability", + "description": "A workflow selects a ref on its self-repository action.", + "diff": "+jobs:\n+ build:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - uses: $/.github/actions/bootstrap@v1\n // Contract snapshot 2026-10-29: GitHub.com supports $/path in the containing workflow repository at its running commit, without checkout; an explicit @ref suffix is invalid.\n // Host: GitHub.com. The action exists; this is the literal changed uses value, not an internal resolved job-log name.", + "expected": [ + { + "id": "action-self-ref-explicit-suffix-invalid-reference", + "title": "Action reference cannot resolve in this execution context", + "file": ".github/workflows/build.yml", + "line": 5, + "severity": "medium", + "category": "reliability", + "codeSnippet": "- uses: $/.github/actions/bootstrap@v1" + } + ] + }, + { + "language": "yaml", + "file": ".github/workflows/build.yml", + "startLine": 1, + "id": "action-workspace-ref-before-checkout", + "category": "reliability", + "description": "A fresh workspace runs a repository action before its source is populated.", + "diff": "+jobs:\n+ build:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - uses: ./.github/actions/bootstrap\n+ - uses: actions/checkout@v5\n // Contract snapshot 2026-10-29: GitHub.com supports $/path in the containing workflow repository at its running commit, without checkout; an explicit @ref suffix is invalid.\n // Host: GitHub.com. Workspace is initially empty; action files exist only in repository source. The checkout step is later.\n // Applicable contract: ./path resolves from workspace and requires its files to be checked out before use.", + "expected": [ + { + "id": "action-workspace-ref-before-checkout-invalid-reference", + "title": "Action reference cannot resolve in this execution context", + "file": ".github/workflows/build.yml", + "line": 5, + "severity": "medium", + "category": "reliability", + "codeSnippet": "- uses: ./.github/actions/bootstrap" + } + ] + }, + { + "language": "yaml", + "file": ".github/workflows/build.yml", + "startLine": 1, + "id": "action-self-ref-unsupported-host", + "category": "reliability", + "description": "A workflow uses the same-repository shorthand on an identified enterprise host.", + "diff": "+jobs:\n+ build:\n+ runs-on: self-hosted\n+ steps:\n+ - uses: $/.github/actions/bootstrap\n // Host: GitHub Enterprise Server (GHES) 3.19. Applicable documented contract snapshot: $/ is unsupported on this host; use an available workspace or remote repository reference.\n // This contract is host-specific; successful GitHub.com execution is not execution on this server.", + "expected": [ + { + "id": "action-self-ref-unsupported-host-invalid-reference", + "title": "Action reference cannot resolve in this execution context", + "file": ".github/workflows/build.yml", + "line": 5, + "severity": "medium", + "category": "reliability", + "codeSnippet": "- uses: $/.github/actions/bootstrap" + } + ] + }, + { + "id": "md-link-root-self", + "language": "markdown", + "category": "negative", + "description": "Architecture navigation from specs/payments.md.", + "file": "specs/payments.md", + "startLine": 41, + "diff": "+[Design](../specs/payments.md#architecture)\n ## Architecture\n \n \n ", + "expected": [] + }, + { + "id": "md-link-nested-self", + "language": "markdown", + "category": "negative", + "description": "Architecture navigation from specs/payments/design.md.", + "file": "specs/payments/design.md", + "startLine": 41, + "diff": "+[Design](../payments/design.md#architecture)\n ## Architecture\n \n \n ", + "expected": [] + }, + { + "id": "md-link-companion", + "language": "markdown", + "category": "negative", + "description": "Architecture navigation from specs/payments/design.md.", + "file": "specs/payments/design.md", + "startLine": 41, + "diff": "+[Design](../../specs/private-sharing.md#architecture)\n ## Architecture\n \n \n ", + "expected": [] + }, + { + "id": "md-link-root-relative", + "language": "markdown", + "category": "negative", + "description": "Architecture navigation from specs/payments/design.md.", + "file": "specs/payments/design.md", + "startLine": 41, + "diff": "+[Design](/specs/semantic-editor.md#architecture)\n ## Architecture\n \n \n ", + "expected": [] + }, + { + "id": "md-link-evidence-unavailable", + "language": "markdown", + "category": "negative", + "description": "Architecture navigation from specs/payments.md.", + "file": "specs/payments.md", + "startLine": 41, + "diff": "+[Design](../specs/unknown.md#architecture)\n // Target source, tree inventory, renderer and heading context are unavailable; no lookup or execution receipt is supplied.", + "expected": [] + }, + { + "id": "md-link-extra-specs-directory", + "language": "markdown", + "category": "correctness", + "description": "Architecture navigation from specs/payments.md.", + "file": "specs/payments.md", + "startLine": 41, + "diff": "+[Design](./specs/payments.md#architecture)\n ## Architecture\n \n \n ", + "expected": [ + { + "id": "md-link-extra-specs-directory-broken-navigation", + "title": "The rendered architecture link does not reach its target", + "file": "specs/payments.md", + "line": 41, + "severity": "low", + "category": "correctness", + "codeSnippet": "[Design](./specs/payments.md#architecture)" + } + ] + }, + { + "id": "md-link-missing-fragment", + "language": "markdown", + "category": "correctness", + "description": "Architecture navigation from specs/payments.md.", + "file": "specs/payments.md", + "startLine": 41, + "diff": "+[Design](../specs/payments.md#missing-architecture)\n ## Architecture\n \n \n ", + "expected": [ + { + "id": "md-link-missing-fragment-broken-navigation", + "title": "The rendered architecture link does not reach its target", + "file": "specs/payments.md", + "line": 41, + "severity": "low", + "category": "correctness", + "codeSnippet": "[Design](../specs/payments.md#missing-architecture)" + } + ] + }, + { + "id": "md-link-renderer-drops-directory", + "language": "typescript", + "category": "correctness", + "description": "A catalog renderer maps a catalogued specification to a Markdown destination.", + "file": "scripts/catalog.ts", + "startLine": 41, + "diff": "+function renderSpecLink(spec: string): string { return './' + spec.slice(spec.lastIndexOf('/') + 1); }\n // Synthetic same-revision renderer call: renderSpecLink(\"specs/payments/design.md\")\n // The result becomes [Design](result) in specs/CATALOG.md.\n // Complete tracked-file inventory: scripts/catalog.ts, specs/CATALOG.md, specs/payments/design.md.\n // Every Markdown target contains only ## Architecture; no custom anchors or other files exist.\n // GitHub Markdown: relative paths use the source directory; initial / means repository root. The plain heading ## Architecture has anchor architecture.", + "expected": [ + { + "id": "md-link-renderer-drops-directory-broken-navigation", + "title": "The rendered architecture link does not reach its target", + "file": "scripts/catalog.ts", + "line": 41, + "severity": "low", + "category": "correctness", + "codeSnippet": "function renderSpecLink(spec: string): string { return './' + spec.slice(spec.lastIndexOf('/') + 1); }" + } + ] + }, + { + "id": "request-transform-coil", + "language": "kotlin", + "category": "negative", + "description": "Source-evidence fixture for Coil 3.6.3, not a new Coil execution. Valid unchanged desktop imports, context, imageUrl and PNG fixtures surround the diff. Official NetworkFetcher.newRequest maps enabled network reads plus disabled disk reads/writes to Cache-Control: no-cache, no-store before Ktor: https://github.com/coil-kt/coil/blob/3.6.3/coil-network-core/src/commonMain/kotlin/coil3/network/NetworkFetcher.kt . Matching Options defaults networkCachePolicy to ENABLED; CachePolicy.DISABLED has both flags false. MockEngine observes the outgoing request and supplies a response PNG, not request headers. Review the added factory configuration.", + "file": "media/PrivateLoader.kt", + "startLine": 1, + "diff": " val engine = MockEngine { request ->\n assertTrue(request.headers[HttpHeaders.CacheControl]!!.contains(\"no-store\"))\n respond(validPng, headers = headersOf(HttpHeaders.ContentType, \"image/png\"))\n }\n val client = HttpClient(engine)\n+val loader = ImageLoader.Builder(context)\n+ .components { add(KtorNetworkFetcherFactory(client)) }\n+ .diskCachePolicy(CachePolicy.DISABLED)\n+ .build()\n assertIs(loader.execute(ImageRequest.Builder(context).data(imageUrl).build()))", + "expected": [] + }, + { + "id": "request-transform-middleware", + "language": "typescript", + "category": "negative", + "description": "Controlled executable JavaScript-subset request pipeline. The unchanged library builder and middleware are supplied as context. The application contract requires no-store at the transport. The new test traverses those real authored functions; it does not inject request headers. This is a synthetic oracle, not execution of Coil or a consumer application.", + "file": "media/request.ts", + "startLine": 1, + "diff": " const policy = { diskRead: false, diskWrite: false, networkRead: true };\n function newRequest() {\n const headers = {};\n if (policy.networkRead && !policy.diskRead) {\n headers[\"Cache-Control\"] = policy.diskWrite ? \"no-cache\" : \"no-cache, no-store\";\n }\n return { headers };\n }\n function middleware() { return newRequest(); }\n function applicationRequest() {\n const request = middleware();\n // Preserve the upstream request headers.\n return request;\n }\n function transport(request) { return request.headers[\"Cache-Control\"]; }\n function testTransport(request) {\n // The test observes the request without adding headers.\n if (!String(transport(request)).includes(\"no-store\")) throw new Error(\"no-store required\");\n }\n const outgoing = applicationRequest();\n+testTransport(outgoing);", + "expected": [] + }, + { + "id": "request-transform-unknown", + "language": "typescript", + "category": "negative", + "description": "No version-matched dependency source, resolved artifact contract or source-bound execution observation is available. The application requires no-store at the transport. Inspect only the supplied change; do not invent library semantics or an execution result.", + "file": "media/request.ts", + "startLine": 1, + "diff": " import { createLoader } from \"unavailable-image-sdk\";\n+const loader = createLoader({ diskCache: \"disabled\" });\n // The resolved dependency request builder and execution evidence are unavailable.\n await loader.load(\"https://fixture.invalid/image.png\");", + "expected": [] + }, + { + "id": "request-transform-write", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable request pipeline. Private image requests require no-store at the actual transport, not just no-cache. The unchanged versioned builder maps policy flags as shown. Review the changed policy; all shown functions are the actual authored fixture path.", + "file": "media/request.ts", + "startLine": 1, + "diff": "+const policy = { diskRead: false, diskWrite: true, networkRead: true };\n function newRequest() {\n const headers = {};\n if (policy.networkRead && !policy.diskRead) {\n headers[\"Cache-Control\"] = policy.diskWrite ? \"no-cache\" : \"no-cache, no-store\";\n }\n return { headers };\n }\n function middleware() { return newRequest(); }\n function applicationRequest() {\n const request = middleware();\n // Preserve the upstream request headers.\n return request;\n }\n function transport(request) { return request.headers[\"Cache-Control\"]; }\n function testTransport(request) {\n // The test observes the request without adding headers.\n if (!String(transport(request)).includes(\"no-store\")) throw new Error(\"no-store required\");\n }\n const outgoing = applicationRequest();\n testTransport(outgoing);", + "expected": [ + { + "id": "request-transform-write", + "title": "Write-enabled policy does not provide the required no-store header", + "file": "media/request.ts", + "line": 1, + "severity": "medium", + "category": "correctness", + "codeSnippet": "const policy = { diskRead: false, diskWrite: true, networkRead: true };" + } + ] + }, + { + "id": "request-transform-bypass", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable request pipeline requiring no-store at the transport. The unchanged middleware invokes the header-producing builder. Review the changed application request construction and the downstream assertion.", + "file": "media/request.ts", + "startLine": 1, + "diff": " const policy = { diskRead: false, diskWrite: false, networkRead: true };\n function newRequest() {\n const headers = {};\n if (policy.networkRead && !policy.diskRead) {\n headers[\"Cache-Control\"] = policy.diskWrite ? \"no-cache\" : \"no-cache, no-store\";\n }\n return { headers };\n }\n function middleware() { return newRequest(); }\n function applicationRequest() {\n+ const request = { headers: {} };\n // Preserve the upstream request headers.\n return request;\n }\n function transport(request) { return request.headers[\"Cache-Control\"]; }\n function testTransport(request) {\n // The test observes the request without adding headers.\n if (!String(transport(request)).includes(\"no-store\")) throw new Error(\"no-store required\");\n }\n const outgoing = applicationRequest();\n testTransport(outgoing);", + "expected": [ + { + "id": "request-transform-bypass", + "title": "Raw request bypasses the header-producing middleware", + "file": "media/request.ts", + "line": 11, + "severity": "medium", + "category": "correctness", + "codeSnippet": "const request = { headers: {} };" + } + ] + }, + { + "id": "request-transform-overwrite", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable request pipeline requiring no-store at the transport. The unchanged upstream builder produces its policy-derived header. Review the added downstream assignment before the actual transport observes the request.", + "file": "media/request.ts", + "startLine": 1, + "diff": " const policy = { diskRead: false, diskWrite: false, networkRead: true };\n function newRequest() {\n const headers = {};\n if (policy.networkRead && !policy.diskRead) {\n headers[\"Cache-Control\"] = policy.diskWrite ? \"no-cache\" : \"no-cache, no-store\";\n }\n return { headers };\n }\n function middleware() { return newRequest(); }\n function applicationRequest() {\n const request = middleware();\n+ request.headers[\"Cache-Control\"] = \"no-cache\";\n return request;\n }\n function transport(request) { return request.headers[\"Cache-Control\"]; }\n function testTransport(request) {\n // The test observes the request without adding headers.\n if (!String(transport(request)).includes(\"no-store\")) throw new Error(\"no-store required\");\n }\n const outgoing = applicationRequest();\n testTransport(outgoing);", + "expected": [ + { + "id": "request-transform-overwrite", + "title": "Downstream assignment removes the required no-store directive", + "file": "media/request.ts", + "line": 12, + "severity": "medium", + "category": "correctness", + "codeSnippet": "request.headers[\"Cache-Control\"] = \"no-cache\";" + } + ] + }, + { + "id": "request-transform-mock", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable request pipeline requiring no-store in production. The shown test mock mutates its input request before asserting. Production invokes applicationRequest followed by transport without testTransport. Review the changed production construction; a passing injecting mock is not production execution evidence.", + "file": "media/request.ts", + "startLine": 1, + "diff": " const policy = { diskRead: false, diskWrite: false, networkRead: true };\n function newRequest() {\n const headers = {};\n if (policy.networkRead && !policy.diskRead) {\n headers[\"Cache-Control\"] = policy.diskWrite ? \"no-cache\" : \"no-cache, no-store\";\n }\n return { headers };\n }\n function middleware() { return newRequest(); }\n function applicationRequest() {\n+ const request = { headers: {} };\n // Preserve the upstream request headers.\n return request;\n }\n function transport(request) { return request.headers[\"Cache-Control\"]; }\n function testTransport(request) {\n request.headers[\"Cache-Control\"] = \"no-cache, no-store\";\n if (!String(transport(request)).includes(\"no-store\")) throw new Error(\"no-store required\");\n }\n const outgoing = applicationRequest();\n testTransport(outgoing);", + "expected": [ + { + "id": "request-transform-mock", + "title": "Header-injecting mock hides a missing production request header", + "file": "media/request.ts", + "line": 11, + "severity": "medium", + "category": "correctness", + "codeSnippet": "const request = { headers: {} };" + } + ] + }, + { + "id": "request-transform-utf8", + "language": "typescript", + "category": "correctness", + "description": "Controlled executable request pipeline plus UTF-8 preview. The header builder and transport assertion are supplied. The preview contract requires valid UTF-8; its unchanged strict decoder rejects malformed bytes. Review the added byte truncation independently of request-header correctness.", + "file": "media/request.ts", + "startLine": 1, + "diff": " const policy = { diskRead: false, diskWrite: false, networkRead: true };\n function newRequest() {\n const headers = {};\n if (policy.networkRead && !policy.diskRead) {\n headers[\"Cache-Control\"] = policy.diskWrite ? \"no-cache\" : \"no-cache, no-store\";\n }\n return { headers };\n }\n function middleware() { return newRequest(); }\n function applicationRequest() {\n const request = middleware();\n // Preserve the upstream request headers.\n return request;\n }\n function transport(request) { return request.headers[\"Cache-Control\"]; }\n function testTransport(request) {\n // The test observes the request without adding headers.\n if (!String(transport(request)).includes(\"no-store\")) throw new Error(\"no-store required\");\n }\n const outgoing = applicationRequest();\n testTransport(outgoing);\n const encoded = new TextEncoder().encode(\"é\");\n+const preview = encoded.slice(0, 1);\n new TextDecoder(\"utf-8\", { fatal: true }).decode(preview);", + "expected": [ + { + "id": "request-transform-utf8", + "title": "Byte truncation splits a multibyte UTF-8 character", + "file": "media/request.ts", + "line": 23, + "severity": "medium", + "category": "correctness", + "codeSnippet": "const preview = encoded.slice(0, 1);" + } + ] + }, + { + "id": "generated-source-literal", + "language": "python", + "category": "negative", + "description": "Synthetic host-language fixture writes generated Kotlin. The writer has no implicit newline; apply the shown literal escapes and explicit transformations. The existing instrumentation runner maps covered instructions to one-based generated source lines. Review the changed assertion using the supplied source and JUnit input. No actual compiler or instrumentation execution outcome is supplied to this model.", + "file": "coverage/generated_fixture.py", + "startLine": 1, + "diff": " def test_generated_counters(tmp_path):\n kotlin = \"\"\"package demo\n class Route {\n fun describe(): String = \"synthetic\"\n fun route(value: Int): Int {\n val checked = value\n if (checked > 0) return 1\n return -1\n }\n fun neverCalled(): Int = 99\n }\n \"\"\"\n (tmp_path / \"Route.kt\").write_bytes(kotlin.encode(\"utf-8\"))\n junit = \"assertEquals(1, Route().route(4))\"\n # Existing runner compiles the exact written source and runs this assertion.\n # rows keys are one-based Route.kt source lines; ci means covered instructions.\n rows = run_real_jacoco(tmp_path, junit)\n+ assert rows[7][\"ci\"] == 0", + "expected": [] + }, + { + "id": "generated-source-leading-newline", + "language": "python", + "category": "negative", + "description": "Synthetic host-language fixture writes generated Kotlin. The writer has no implicit newline; apply the shown literal escapes and explicit transformations. The existing instrumentation runner maps covered instructions to one-based generated source lines. Review the changed assertion using the supplied source and JUnit input. No actual compiler or instrumentation execution outcome is supplied to this model.", + "file": "coverage/generated_fixture.py", + "startLine": 1, + "diff": " def test_generated_counters(tmp_path):\n kotlin = \"\"\"\n package demo\n class Route {\n fun describe(): String = \"synthetic\"\n fun route(value: Int): Int {\n val checked = value\n if (checked > 0) return 1\n return -1\n }\n fun neverCalled(): Int = 99\n }\n \"\"\"\n (tmp_path / \"Route.kt\").write_bytes(kotlin.encode(\"utf-8\"))\n junit = \"assertEquals(1, Route().route(4))\"\n # Existing runner compiles the exact written source and runs this assertion.\n # rows keys are one-based Route.kt source lines; ci means covered instructions.\n rows = run_real_jacoco(tmp_path, junit)\n+ assert rows[8][\"ci\"] == 0", + "expected": [] + }, + { + "id": "generated-source-escaped", + "language": "python", + "category": "negative", + "description": "Synthetic host-language fixture writes generated Kotlin. The writer has no implicit newline; apply the shown literal escapes and explicit transformations. The existing instrumentation runner maps covered instructions to one-based generated source lines. Review the changed assertion using the supplied source and JUnit input. No actual compiler or instrumentation execution outcome is supplied to this model.", + "file": "coverage/generated_fixture.py", + "startLine": 1, + "diff": " def test_generated_counters(tmp_path):\n kotlin = \"package demo\\nclass Route {\\n fun describe(): String = \\\"synthetic\\\"\\n fun route(value: Int): Int {\\n val checked = value\\n if (checked > 0) return 1\\n return -1\\n }\\n fun neverCalled(): Int = 99\\n}\\n\"\n (tmp_path / \"Route.kt\").write_bytes(kotlin.encode(\"utf-8\"))\n junit = \"assertEquals(1, Route().route(4))\"\n # Existing runner compiles the exact written source and runs this assertion.\n # rows keys are one-based Route.kt source lines; ci means covered instructions.\n rows = run_real_jacoco(tmp_path, junit)\n+ assert rows[7][\"ci\"] == 0", + "expected": [] + }, + { + "id": "generated-source-dedent", + "language": "python", + "category": "negative", + "description": "Synthetic host-language fixture writes generated Kotlin. The writer has no implicit newline; apply the shown literal escapes and explicit transformations. The existing instrumentation runner maps covered instructions to one-based generated source lines. Review the changed assertion using the supplied source and JUnit input. No actual compiler or instrumentation execution outcome is supplied to this model.", + "file": "coverage/generated_fixture.py", + "startLine": 1, + "diff": " import textwrap\n def test_generated_counters(tmp_path):\n kotlin = textwrap.dedent(\"\"\"\n package demo\n class Route {\n fun describe(): String = \"synthetic\"\n fun route(value: Int): Int {\n val checked = value\n if (checked > 0) return 1\n return -1\n }\n fun neverCalled(): Int = 99\n }\n \"\"\").lstrip(\"\\n\")\n (tmp_path / \"Route.kt\").write_bytes(kotlin.encode(\"utf-8\"))\n junit = \"assertEquals(1, Route().route(4))\"\n # Existing runner compiles the exact written source and runs this assertion.\n # rows keys are one-based Route.kt source lines; ci means covered instructions.\n rows = run_real_jacoco(tmp_path, junit)\n+ assert rows[7][\"ci\"] == 0", + "expected": [] + }, + { + "id": "generated-source-wrong-literal", + "language": "python", + "category": "correctness", + "description": "Synthetic host-language fixture writes generated Kotlin. The writer has no implicit newline; apply the shown literal escapes and explicit transformations. The existing instrumentation runner maps covered instructions to one-based generated source lines. Review the changed assertion using the supplied source and JUnit input. No actual compiler or instrumentation execution outcome is supplied to this model.", + "file": "coverage/generated_fixture.py", + "startLine": 1, + "diff": " def test_generated_counters(tmp_path):\n kotlin = \"\"\"package demo\n class Route {\n fun describe(): String = \"synthetic\"\n fun route(value: Int): Int {\n val checked = value\n if (checked > 0) return 1\n return -1\n }\n fun neverCalled(): Int = 99\n }\n \"\"\"\n (tmp_path / \"Route.kt\").write_bytes(kotlin.encode(\"utf-8\"))\n junit = \"assertEquals(1, Route().route(4))\"\n # Existing runner compiles the exact written source and runs this assertion.\n # rows keys are one-based Route.kt source lines; ci means covered instructions.\n rows = run_real_jacoco(tmp_path, junit)\n+ assert rows[6][\"ci\"] == 0", + "expected": [ + { + "id": "generated-source-wrong-literal", + "title": "Executed positive statement is asserted uncovered", + "file": "coverage/generated_fixture.py", + "line": 18, + "severity": "medium", + "category": "correctness", + "codeSnippet": "assert rows[6][\"ci\"] == 0" + } + ] + }, + { + "id": "generated-source-wrong-leading-newline", + "language": "python", + "category": "correctness", + "description": "Synthetic host-language fixture writes generated Kotlin. The writer has no implicit newline; apply the shown literal escapes and explicit transformations. The existing instrumentation runner maps covered instructions to one-based generated source lines. Review the changed assertion using the supplied source and JUnit input. No actual compiler or instrumentation execution outcome is supplied to this model.", + "file": "coverage/generated_fixture.py", + "startLine": 1, + "diff": " def test_generated_counters(tmp_path):\n kotlin = \"\"\"\n package demo\n class Route {\n fun describe(): String = \"synthetic\"\n fun route(value: Int): Int {\n val checked = value\n if (checked > 0) return 1\n return -1\n }\n fun neverCalled(): Int = 99\n }\n \"\"\"\n (tmp_path / \"Route.kt\").write_bytes(kotlin.encode(\"utf-8\"))\n junit = \"assertEquals(1, Route().route(4))\"\n # Existing runner compiles the exact written source and runs this assertion.\n # rows keys are one-based Route.kt source lines; ci means covered instructions.\n rows = run_real_jacoco(tmp_path, junit)\n+ assert rows[7][\"ci\"] == 0", + "expected": [ + { + "id": "generated-source-wrong-leading-newline", + "title": "Executed positive statement is asserted uncovered", + "file": "coverage/generated_fixture.py", + "line": 19, + "severity": "medium", + "category": "correctness", + "codeSnippet": "assert rows[7][\"ci\"] == 0" + } + ] + }, + { + "id": "generated-literal-independent-shell", + "language": "python", + "category": "security", + "description": "Owned synthetic Python fixture includes a literal plus a separate request handler. user_path is an untrusted HTTP query parameter; review the changed handler.", + "file": "coverage/literal_handler.py", + "startLine": 1, + "diff": " source = \"\"\"package demo\n class Empty {}\"\"\"\n import subprocess\n+def export_report(user_path):\n+ return subprocess.run(\"cat \" + user_path, shell=True, check=True)", + "expected": [ + { + "id": "generated-literal-independent-shell", + "title": "Untrusted query parameter reaches the shell", + "file": "coverage/literal_handler.py", + "line": 5, + "category": "security", + "severity": "high", + "codeSnippet": "return subprocess.run(\"cat \" + user_path, shell=True, check=True)" + } + ] + }, + { + "id": "generated-literal-independent-contract", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python fixture includes a literal plus an independent public validator. Its documented contract accepts strictly positive integer counts only. Review the changed return.", + "file": "coverage/literal_validator.py", + "startLine": 1, + "diff": " source = \"\"\"package demo\n class Empty {}\"\"\"\n def accepts_count(count):\n \"\"\"Return True exactly when integer count is strictly positive.\"\"\"\n- return count > 0\n+ return count >= 0", + "expected": [ + { + "id": "generated-literal-independent-contract", + "title": "Zero is accepted despite the strictly positive contract", + "file": "coverage/literal_validator.py", + "line": 6, + "category": "correctness", + "severity": "medium", + "codeSnippet": "return count >= 0" + } + ] + }, + { + "id": "session-source-signed-bootstrap", + "language": "typescript", + "category": "negative", + "description": "Owned synthetic harness dispatches configuration-selected setup, persists the storageState JSON shape and reads its localStorage session. Real Node HMAC/base64url creates compact tokens. The token endpoint supplies only the explicitly selected initial or expiry path. The assertion checks the selected header under a fixed test clock; no browser, private consumer or external auth provider is executed.", + "file": "e2e/owned-session.spec.ts", + "startLine": 1, + "diff": " const assert = require(\"node:assert/strict\");\n const { createHmac } = require(\"node:crypto\");\n const persistedFiles = new Map();\n const statePath = \".auth/owned-user.json\";\n let tokenEndpointCalls = 0;\n const fakeAuthResponse = { access_token: \"opaque-token-response\" };\n function mockedTokenEndpoint() { tokenEndpointCalls++; return fakeAuthResponse; }\n function persistSession(session) {\n const state = { cookies: [], origins: [{ origin: \"http://owned.invalid\", localStorage: [{ name: \"owned-session\", value: JSON.stringify(session) }] }] };\n persistedFiles.set(statePath, JSON.stringify(state));\n }\n function signedSetup() {\n const header = Buffer.from(JSON.stringify({alg:\"HS256\",typ:\"JWT\"})).toString(\"base64url\");\n const payload = Buffer.from(JSON.stringify({sub:\"owned-synthetic-user\"})).toString(\"base64url\");\n const unsigned = header + \".\" + payload;\n const signature = createHmac(\"sha256\", \"owned-synthetic-fixture-key\").update(unsigned).digest(\"base64url\");\n persistSession({ access_token: unsigned + \".\" + signature, expires_at: 10000 });\n }\n function opaqueSetup() { persistSession({ ...mockedTokenEndpoint(), expires_at: 10000 }); }\n function aliasSetup() { return signedSetup(); }\n const setupModules = { \"signed.setup.ts\": signedSetup, \"alias.setup.ts\": aliasSetup, \"opaque.setup.ts\": opaqueSetup };\n const projectConfig = { globalSetup: \"signed.setup.ts\", storageState: statePath };\n setupModules[projectConfig.globalSetup]();\n const browserState = JSON.parse(persistedFiles.get(projectConfig.storageState));\n const storedSession = JSON.parse(browserState.origins[0].localStorage.find(item => item.name === \"owned-session\").value);\n const testClock = 1000;\n let accessToken = storedSession.access_token;\n if (storedSession.expires_at <= testClock) accessToken = mockedTokenEndpoint().access_token;\n const authorization = \"Bearer \" + accessToken;\n+assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "expected": [] + }, + { + "id": "session-source-storage-alias", + "language": "typescript", + "category": "negative", + "description": "Owned synthetic harness dispatches configuration-selected setup, persists the storageState JSON shape and reads its localStorage session. Real Node HMAC/base64url creates compact tokens. The token endpoint supplies only the explicitly selected initial or expiry path. The assertion checks the selected header under a fixed test clock; no browser, private consumer or external auth provider is executed.", + "file": "e2e/owned-session.spec.ts", + "startLine": 1, + "diff": " const assert = require(\"node:assert/strict\");\n const { createHmac } = require(\"node:crypto\");\n const persistedFiles = new Map();\n const statePath = \".auth/owned-user.json\";\n let tokenEndpointCalls = 0;\n const fakeAuthResponse = { access_token: \"opaque-token-response\" };\n function mockedTokenEndpoint() { tokenEndpointCalls++; return fakeAuthResponse; }\n function persistSession(session) {\n const state = { cookies: [], origins: [{ origin: \"http://owned.invalid\", localStorage: [{ name: \"owned-session\", value: JSON.stringify(session) }] }] };\n persistedFiles.set(statePath, JSON.stringify(state));\n }\n function signedSetup() {\n const header = Buffer.from(JSON.stringify({alg:\"HS256\",typ:\"JWT\"})).toString(\"base64url\");\n const payload = Buffer.from(JSON.stringify({sub:\"owned-synthetic-user\"})).toString(\"base64url\");\n const unsigned = header + \".\" + payload;\n const signature = createHmac(\"sha256\", \"owned-synthetic-fixture-key\").update(unsigned).digest(\"base64url\");\n persistSession({ access_token: unsigned + \".\" + signature, expires_at: 10000 });\n }\n function opaqueSetup() { persistSession({ ...mockedTokenEndpoint(), expires_at: 10000 }); }\n function aliasSetup() { return signedSetup(); }\n const setupModules = { \"signed.setup.ts\": signedSetup, \"alias.setup.ts\": aliasSetup, \"opaque.setup.ts\": opaqueSetup };\n const projectConfig = { globalSetup: \"alias.setup.ts\", storageState: statePath };\n setupModules[projectConfig.globalSetup]();\n const browserState = JSON.parse(persistedFiles.get(projectConfig.storageState));\n const storedSession = JSON.parse(browserState.origins[0].localStorage.find(item => item.name === \"owned-session\").value);\n const testClock = 1000;\n let accessToken = storedSession.access_token;\n if (storedSession.expires_at <= testClock) accessToken = mockedTokenEndpoint().access_token;\n const authorization = \"Bearer \" + accessToken;\n+assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "expected": [] + }, + { + "id": "session-source-opaque-bootstrap", + "language": "typescript", + "category": "correctness", + "description": "Owned synthetic harness dispatches configuration-selected setup, persists the storageState JSON shape and reads its localStorage session. Real Node HMAC/base64url creates compact tokens. The token endpoint supplies only the explicitly selected initial or expiry path. The assertion checks the selected header under a fixed test clock; no browser, private consumer or external auth provider is executed.", + "file": "e2e/owned-session.spec.ts", + "startLine": 1, + "diff": " const assert = require(\"node:assert/strict\");\n const { createHmac } = require(\"node:crypto\");\n const persistedFiles = new Map();\n const statePath = \".auth/owned-user.json\";\n let tokenEndpointCalls = 0;\n const fakeAuthResponse = { access_token: \"opaque-token-response\" };\n function mockedTokenEndpoint() { tokenEndpointCalls++; return fakeAuthResponse; }\n function persistSession(session) {\n const state = { cookies: [], origins: [{ origin: \"http://owned.invalid\", localStorage: [{ name: \"owned-session\", value: JSON.stringify(session) }] }] };\n persistedFiles.set(statePath, JSON.stringify(state));\n }\n function signedSetup() {\n const header = Buffer.from(JSON.stringify({alg:\"HS256\",typ:\"JWT\"})).toString(\"base64url\");\n const payload = Buffer.from(JSON.stringify({sub:\"owned-synthetic-user\"})).toString(\"base64url\");\n const unsigned = header + \".\" + payload;\n const signature = createHmac(\"sha256\", \"owned-synthetic-fixture-key\").update(unsigned).digest(\"base64url\");\n persistSession({ access_token: unsigned + \".\" + signature, expires_at: 10000 });\n }\n function opaqueSetup() { persistSession({ ...mockedTokenEndpoint(), expires_at: 10000 }); }\n function aliasSetup() { return signedSetup(); }\n const setupModules = { \"signed.setup.ts\": signedSetup, \"alias.setup.ts\": aliasSetup, \"opaque.setup.ts\": opaqueSetup };\n const projectConfig = { globalSetup: \"opaque.setup.ts\", storageState: statePath };\n setupModules[projectConfig.globalSetup]();\n const browserState = JSON.parse(persistedFiles.get(projectConfig.storageState));\n const storedSession = JSON.parse(browserState.origins[0].localStorage.find(item => item.name === \"owned-session\").value);\n const testClock = 1000;\n let accessToken = storedSession.access_token;\n if (storedSession.expires_at <= testClock) accessToken = mockedTokenEndpoint().access_token;\n const authorization = \"Bearer \" + accessToken;\n+assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "expected": [ + { + "id": "session-source-opaque-bootstrap", + "title": "The selected session supplies an opaque token to the compact-token assertion", + "file": "e2e/owned-session.spec.ts", + "line": 30, + "severity": "medium", + "category": "correctness", + "codeSnippet": "assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);" + } + ] + }, + { + "id": "session-source-expired-refresh", + "language": "typescript", + "category": "correctness", + "description": "Owned synthetic harness dispatches configuration-selected setup, persists the storageState JSON shape and reads its localStorage session. Real Node HMAC/base64url creates compact tokens. The token endpoint supplies only the explicitly selected initial or expiry path. The assertion checks the selected header under a fixed test clock; no browser, private consumer or external auth provider is executed.", + "file": "e2e/owned-session.spec.ts", + "startLine": 1, + "diff": " const assert = require(\"node:assert/strict\");\n const { createHmac } = require(\"node:crypto\");\n const persistedFiles = new Map();\n const statePath = \".auth/owned-user.json\";\n let tokenEndpointCalls = 0;\n const fakeAuthResponse = { access_token: \"opaque-token-response\" };\n function mockedTokenEndpoint() { tokenEndpointCalls++; return fakeAuthResponse; }\n function persistSession(session) {\n const state = { cookies: [], origins: [{ origin: \"http://owned.invalid\", localStorage: [{ name: \"owned-session\", value: JSON.stringify(session) }] }] };\n persistedFiles.set(statePath, JSON.stringify(state));\n }\n function signedSetup() {\n const header = Buffer.from(JSON.stringify({alg:\"HS256\",typ:\"JWT\"})).toString(\"base64url\");\n const payload = Buffer.from(JSON.stringify({sub:\"owned-synthetic-user\"})).toString(\"base64url\");\n const unsigned = header + \".\" + payload;\n const signature = createHmac(\"sha256\", \"owned-synthetic-fixture-key\").update(unsigned).digest(\"base64url\");\n persistSession({ access_token: unsigned + \".\" + signature, expires_at: 10000 });\n }\n function opaqueSetup() { persistSession({ ...mockedTokenEndpoint(), expires_at: 10000 }); }\n function aliasSetup() { return signedSetup(); }\n const setupModules = { \"signed.setup.ts\": signedSetup, \"alias.setup.ts\": aliasSetup, \"opaque.setup.ts\": opaqueSetup };\n const projectConfig = { globalSetup: \"signed.setup.ts\", storageState: statePath };\n setupModules[projectConfig.globalSetup]();\n const browserState = JSON.parse(persistedFiles.get(projectConfig.storageState));\n const storedSession = JSON.parse(browserState.origins[0].localStorage.find(item => item.name === \"owned-session\").value);\n const testClock = 20000;\n let accessToken = storedSession.access_token;\n if (storedSession.expires_at <= testClock) accessToken = mockedTokenEndpoint().access_token;\n const authorization = \"Bearer \" + accessToken;\n+assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "expected": [ + { + "id": "session-source-expired-refresh", + "title": "The selected session supplies an opaque token to the compact-token assertion", + "file": "e2e/owned-session.spec.ts", + "line": 30, + "severity": "medium", + "category": "correctness", + "codeSnippet": "assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);" + } + ] + }, + { + "id": "session-source-prefix-gap", + "language": "typescript", + "category": "correctness", + "description": "Owned synthetic harness dispatches configuration-selected setup, persists the storageState JSON shape and reads its localStorage session. Real Node HMAC/base64url creates compact tokens. The token endpoint supplies only the explicitly selected initial or expiry path. The assertion checks the selected header under a fixed test clock; no browser, private consumer or external auth provider is executed.", + "file": "e2e/owned-session.spec.ts", + "startLine": 1, + "diff": " const assert = require(\"node:assert/strict\");\n const { createHmac } = require(\"node:crypto\");\n const persistedFiles = new Map();\n const statePath = \".auth/owned-user.json\";\n let tokenEndpointCalls = 0;\n const fakeAuthResponse = { access_token: \"opaque-token-response\" };\n function mockedTokenEndpoint() { tokenEndpointCalls++; return fakeAuthResponse; }\n function persistSession(session) {\n const state = { cookies: [], origins: [{ origin: \"http://owned.invalid\", localStorage: [{ name: \"owned-session\", value: JSON.stringify(session) }] }] };\n persistedFiles.set(statePath, JSON.stringify(state));\n }\n function signedSetup() {\n const header = Buffer.from(JSON.stringify({alg:\"HS256\",typ:\"JWT\"})).toString(\"base64url\");\n const payload = Buffer.from(JSON.stringify({sub:\"owned-synthetic-user\"})).toString(\"base64url\");\n const unsigned = header + \".\" + payload;\n const signature = createHmac(\"sha256\", \"owned-synthetic-fixture-key\").update(unsigned).digest(\"base64url\");\n persistSession({ access_token: unsigned + \".\" + signature, expires_at: 10000 });\n }\n function opaqueSetup() { persistSession({ ...mockedTokenEndpoint(), expires_at: 10000 }); }\n function aliasSetup() { return signedSetup(); }\n const setupModules = { \"signed.setup.ts\": signedSetup, \"alias.setup.ts\": aliasSetup, \"opaque.setup.ts\": opaqueSetup };\n const projectConfig = { globalSetup: \"signed.setup.ts\", storageState: statePath };\n setupModules[projectConfig.globalSetup]();\n const browserState = JSON.parse(persistedFiles.get(projectConfig.storageState));\n const storedSession = JSON.parse(browserState.origins[0].localStorage.find(item => item.name === \"owned-session\").value);\n const testClock = 1000;\n let accessToken = storedSession.access_token;\n if (storedSession.expires_at <= testClock) accessToken = mockedTokenEndpoint().access_token;\n+const authorization = \"Bearer\" + accessToken;\n+assert.match(authorization, /^Bearer [A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+$/);", + "expected": [ + { + "id": "session-source-prefix-gap", + "title": "The changed header omits the bearer separator", + "file": "e2e/owned-session.spec.ts", + "line": 29, + "severity": "medium", + "category": "correctness", + "codeSnippet": "const authorization = \"Bearer\" + accessToken;" + } + ] + }, + { + "id": "session-source-setup-unavailable", + "language": "typescript", + "category": "negative", + "description": "Bounded source excerpt: the configured setup and persisted initial session producer are not supplied. A separate token endpoint stub is visible. No execution outcome is provided; review only supported defects in the changed assertion.", + "file": "e2e/owned-session.spec.ts", + "startLine": 1, + "diff": " const fakeAuthResponse = { access_token: \"opaque-token-response\" };\n function tokenEndpoint() { return fakeAuthResponse; }\n const initialSession = loadConfiguredStorageState();\n+assert.equal(initialSession.access_token.split(\".\").length, 3);", + "expected": [] + }, + { + "id": "unittest-discovery-delegated-wildcard", + "language": "python", + "category": "negative", + "file": ".github/scripts/tests/run_manifest_tests.py", + "startLine": 1, + "description": "Owned synthetic runner and fixed flat importable test inventory. The configured workflow invokes this file, including through delegates; its contract requires both manifest modules. Review the changed discovery command, effective cwd and module selection. Supplied observations are separate from model predictions; do not execute fixtures or infer defects from the absence of direct workflow module invocation.", + "diff": " import subprocess\n import sys\n from pathlib import Path\n ROOT = Path(__file__).resolve().parents[3]\n # Workflow cwd: .; run: python .github/scripts/tests/run_manifest_tests.py.\n # Owned ordinary importable unittest fixtures:\n # .github/scripts/tests/test_manifest_core.py: 14 TestCase methods.\n # .github/scripts/tests/test_manifest_export.py: 5 TestCase methods.\n # backend/checks/test_manifest_health.py: 1 unrelated TestCase method.\n # Both manifest modules are required by this CI verification contract.\n # Separate owned command observation: 19 tests passed, including all five export methods.\n # The observation uses this exact runner argv, root and owned module sources; no consumer run is claimed.\n def command():\n+ return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_*.py\", \"-v\"]\n def run_discovery():\n return subprocess.run(command(), cwd=ROOT, check=True)\n def delegate():\n return run_discovery()\n def alias():\n return delegate()\n if __name__ == \"__main__\": delegate()", + "expected": [] + }, + { + "id": "unittest-discovery-nested-working-directory", + "language": "python", + "category": "negative", + "file": ".github/scripts/tests/run_manifest_tests.py", + "startLine": 1, + "description": "Owned synthetic runner and fixed flat importable test inventory. The configured workflow invokes this file, including through delegates; its contract requires both manifest modules. Review the changed discovery command, effective cwd and module selection. Supplied observations are separate from model predictions; do not execute fixtures or infer defects from the absence of direct workflow module invocation.", + "diff": " import subprocess\n import sys\n from pathlib import Path\n ROOT = Path(__file__).resolve().parents[3]\n # Workflow cwd: backend; run: python ../.github/scripts/tests/run_manifest_tests.py.\n # Owned ordinary importable unittest fixtures:\n # .github/scripts/tests/test_manifest_core.py: 14 TestCase methods.\n # .github/scripts/tests/test_manifest_export.py: 5 TestCase methods.\n # backend/checks/test_manifest_health.py: 1 unrelated TestCase method.\n # Both manifest modules are required by this CI verification contract.\n def command():\n+ return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_*.py\", \"-v\"]\n def run_discovery():\n return subprocess.run(command(), cwd=ROOT, check=True)\n def delegate():\n return run_discovery()\n def alias():\n return delegate()\n if __name__ == \"__main__\": alias()", + "expected": [] + }, + { + "id": "unittest-discovery-literal-argv-pattern", + "language": "python", + "category": "negative", + "file": ".github/scripts/tests/run_manifest_tests.py", + "startLine": 1, + "description": "Owned synthetic runner and fixed flat importable test inventory. The configured workflow invokes this file, including through delegates; its contract requires both manifest modules. Review the changed discovery command, effective cwd and module selection. Supplied observations are separate from model predictions; do not execute fixtures or infer defects from the absence of direct workflow module invocation.", + "diff": " import subprocess\n import sys\n from pathlib import Path\n ROOT = Path(__file__).resolve().parents[3]\n # Workflow cwd: .; run: python .github/scripts/tests/run_manifest_tests.py.\n # Owned ordinary importable unittest fixtures:\n # .github/scripts/tests/test_manifest_core.py: 14 TestCase methods.\n # .github/scripts/tests/test_manifest_export.py: 5 TestCase methods.\n # backend/checks/test_manifest_health.py: 1 unrelated TestCase method.\n # Both manifest modules are required by this CI verification contract.\n def command():\n+ return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_*.py\", \"-v\"]\n def run_discovery():\n return subprocess.run(command(), cwd=ROOT, check=True)\n def delegate():\n return run_discovery()\n def alias():\n return delegate()\n if __name__ == \"__main__\": run_discovery()", + "expected": [] + }, + { + "id": "unittest-discovery-excluded-by-pattern", + "language": "python", + "category": "correctness", + "file": ".github/scripts/tests/run_manifest_tests.py", + "startLine": 1, + "description": "Owned synthetic runner and fixed flat importable test inventory. The configured workflow invokes this file, including through delegates; its contract requires both manifest modules. Review the changed discovery command, effective cwd and module selection. Supplied observations are separate from model predictions; do not execute fixtures or infer defects from the absence of direct workflow module invocation.", + "diff": " import subprocess\n import sys\n from pathlib import Path\n ROOT = Path(__file__).resolve().parents[3]\n # Workflow cwd: .; run: python .github/scripts/tests/run_manifest_tests.py.\n # Owned ordinary importable unittest fixtures:\n # .github/scripts/tests/test_manifest_core.py: 14 TestCase methods.\n # .github/scripts/tests/test_manifest_export.py: 5 TestCase methods.\n # backend/checks/test_manifest_health.py: 1 unrelated TestCase method.\n # Both manifest modules are required by this CI verification contract.\n def command():\n+ return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_core.py\", \"-v\"]\n def run_discovery():\n return subprocess.run(command(), cwd=ROOT, check=True)\n def delegate():\n return run_discovery()\n def alias():\n return delegate()\n if __name__ == \"__main__\": delegate()", + "expected": [ + { + "id": "unittest-discovery-excluded-by-pattern", + "title": "The changed discovery selector excludes the required export module", + "file": ".github/scripts/tests/run_manifest_tests.py", + "line": 12, + "severity": "medium", + "category": "correctness", + "codeSnippet": " return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \".github/scripts/tests\", \"-p\", \"test_manifest_core.py\", \"-v\"]" + } + ] + }, + { + "id": "unittest-discovery-wrong-start-directory", + "language": "python", + "category": "correctness", + "file": ".github/scripts/tests/run_manifest_tests.py", + "startLine": 1, + "description": "Owned synthetic runner and fixed flat importable test inventory. The configured workflow invokes this file, including through delegates; its contract requires both manifest modules. Review the changed discovery command, effective cwd and module selection. Supplied observations are separate from model predictions; do not execute fixtures or infer defects from the absence of direct workflow module invocation.", + "diff": " import subprocess\n import sys\n from pathlib import Path\n ROOT = Path(__file__).resolve().parents[3]\n # Workflow cwd: .; run: python .github/scripts/tests/run_manifest_tests.py.\n # Owned ordinary importable unittest fixtures:\n # .github/scripts/tests/test_manifest_core.py: 14 TestCase methods.\n # .github/scripts/tests/test_manifest_export.py: 5 TestCase methods.\n # backend/checks/test_manifest_health.py: 1 unrelated TestCase method.\n # Both manifest modules are required by this CI verification contract.\n def command():\n+ return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \"backend/checks\", \"-p\", \"test_manifest_*.py\", \"-v\"]\n def run_discovery():\n return subprocess.run(command(), cwd=ROOT, check=True)\n def delegate():\n return run_discovery()\n def alias():\n return delegate()\n if __name__ == \"__main__\": delegate()", + "expected": [ + { + "id": "unittest-discovery-wrong-start-directory", + "title": "The changed discovery selector excludes the required export module", + "file": ".github/scripts/tests/run_manifest_tests.py", + "line": 12, + "severity": "medium", + "category": "correctness", + "codeSnippet": " return [sys.executable, \"-m\", \"unittest\", \"discover\", \"-s\", \"backend/checks\", \"-p\", \"test_manifest_*.py\", \"-v\"]" + } + ] + }, + { + "id": "unittest-discovery-runner-unavailable", + "language": "yaml", + "category": "negative", + "description": "The delegated runner source and discovery configuration are unavailable. A successful unrelated revision is not evidence of current module selection or execution; report only supported changed-code defects.", + "file": ".github/workflows/manifest.yml", + "startLine": 1, + "diff": " jobs:\n verify:\n steps:\n+ - run: python .github/scripts/tests/run_manifest_tests.py\n # The runner and current module-qualified execution records are not supplied.", + "expected": [] + }, + { + "id": "kotlin-json-implicit-nullable-omission", + "language": "kotlin", + "category": "negative", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String?)\n val serverJson = Json { explicitNulls = true }\n val probeJson = Json(serverJson) { explicitNulls = false }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"name\":\"Owned\"}\"\"\"\n+ val decoded = probeJson.decodeFromString(raw)\n return decoded\n }", + "expected": [] + }, + { + "id": "kotlin-json-explicit-nullable-omission", + "language": "kotlin", + "category": "correctness", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String?)\n val serverJson = Json { explicitNulls = true }\n val probeJson = Json(serverJson) { explicitNulls = true }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"name\":\"Owned\"}\"\"\"\n+ val decoded = probeJson.decodeFromString(raw)\n return decoded\n }", + "expected": [ + { + "id": "kotlin-json-explicit-nullable-omission", + "title": "The changed request decode rejects its documented accepted input", + "file": "backend/OwnedRequest.kt", + "line": 11, + "severity": "medium", + "category": "correctness", + "codeSnippet": " val decoded = probeJson.decodeFromString(raw)" + } + ] + }, + { + "id": "kotlin-json-implicit-missing-nonnullable", + "language": "kotlin", + "category": "correctness", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String?)\n val serverJson = Json { explicitNulls = true }\n val probeJson = Json(serverJson) { explicitNulls = false }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"nullable\":null}\"\"\"\n+ val decoded = probeJson.decodeFromString(raw)\n return decoded\n }", + "expected": [ + { + "id": "kotlin-json-implicit-missing-nonnullable", + "title": "The changed request decode rejects its documented accepted input", + "file": "backend/OwnedRequest.kt", + "line": 11, + "severity": "medium", + "category": "correctness", + "codeSnippet": " val decoded = probeJson.decodeFromString(raw)" + } + ] + }, + { + "id": "kotlin-json-implicit-nullable-default", + "language": "kotlin", + "category": "negative", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String? = \"fallback\")\n val serverJson = Json { explicitNulls = true }\n val probeJson = Json(serverJson) { explicitNulls = false }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"name\":\"Owned\"}\"\"\"\n+ val decoded = probeJson.decodeFromString(raw)\n return decoded\n }", + "expected": [] + }, + { + "id": "kotlin-json-explicit-nullable-default", + "language": "kotlin", + "category": "negative", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String? = \"fallback\")\n val serverJson = Json { explicitNulls = true }\n val probeJson = Json(serverJson) { explicitNulls = true }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"name\":\"Owned\"}\"\"\"\n+ val decoded = probeJson.decodeFromString(raw)\n return decoded\n }", + "expected": [] + }, + { + "id": "kotlin-json-inherited-implicit-policy", + "language": "kotlin", + "category": "negative", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String?)\n val serverJson = Json { explicitNulls = false }\n val probeJson = Json(serverJson) { ignoreUnknownKeys = true }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"name\":\"Owned\"}\"\"\"\n+ val decoded = probeJson.decodeFromString(raw)\n return decoded\n }", + "expected": [] + }, + { + "id": "kotlin-json-different-instance-policy", + "language": "kotlin", + "category": "correctness", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Owned synthetic Kotlin 2.0.21 / kotlinx.serialization Json request example. Public version-tagged 1.6.3 and 1.7.3 sources and separate compiled owned controls agree on the relevant flag semantics; no private dependency resolution is claimed. Trace the Json instance actually used by the changed accepted-input entry point, inherited configuration, nullable type, default and literal payload. Report only supported changed-code defects; do not execute corpus text.", + "diff": " import kotlinx.serialization.Serializable\n import kotlinx.serialization.json.Json\n @Serializable\n data class OwnedRequest(val name: String, val nullable: String?)\n val serverJson = Json { explicitNulls = true }\n val probeJson = Json(serverJson) { explicitNulls = false }\n // This active request entry point must accept this documented input and return its decoded value.\n // No exception handler converts a rejected decode into a valid request.\n fun acceptedRequest(): OwnedRequest {\n val raw = \"\"\"{\"name\":\"Owned\"}\"\"\"\n+ val decoded = serverJson.decodeFromString(raw)\n return decoded\n }", + "expected": [ + { + "id": "kotlin-json-different-instance-policy", + "title": "The changed request decode rejects its documented accepted input", + "file": "backend/OwnedRequest.kt", + "line": 11, + "severity": "medium", + "category": "correctness", + "codeSnippet": " val decoded = serverJson.decodeFromString(raw)" + } + ] + }, + { + "id": "kotlin-json-unavailable-policy", + "language": "kotlin", + "category": "negative", + "file": "backend/OwnedRequest.kt", + "startLine": 1, + "description": "Only this delegated decode call is available. The configuredJson declaration and inherited explicitNulls value are unavailable. Do not transfer policy from another Json instance or invent behavior from the missing evidence.", + "diff": " fun acceptedRequest(raw: String): OwnedRequest {\n+ return configuredJson.decodeFromString(raw)\n }", + "expected": [] + }, + { + "id": "ktor-routing-installed-root", + "language": "kotlin", + "category": "negative", + "description": "Owned inert Kotlin example using the public Ktor 3.0.2 routing contract. The pinned public RoutingRoot.kt blob 7519c959a6caba4c1b3fb3c7e429ded46e2f21e8 implements Application.routing as pluginOrNull(RoutingRoot)?.apply(configuration) ?: install(RoutingRoot, configuration); independent public 3.0.2 jar disassembly corroborates the same-object return on reuse. This is source/bytecode evidence, not execution of this example or private dependency resolution. The caller supplies two distinct Applications; the first begins without routing, then the shown setup installs exactly one child. The selected node must preserve the complete installed root identity, checked by this active caller. Review the added selection; no other files or hidden framework overrides are in scope.", + "file": "backend/OwnedRoutingSelection.kt", + "startLine": 1, + "diff": " import io.ktor.server.application.Application\n import io.ktor.server.routing.*\n fun existingRoot(app: Application): RoutingRoot = app.routing {}\n fun selectForExport(app: Application, otherApp: Application): RoutingNode {\n val installed = app.routing { route(\"/owned\") {} }\n+ val selected = app.routing {}\n check(selected === installed) { \"Export must retain the entire installed root\" }\n return selected\n }", + "expected": [] + }, + { + "id": "ktor-routing-delegated-root", + "language": "kotlin", + "category": "negative", + "description": "Owned inert Kotlin example using the public Ktor 3.0.2 routing contract. The pinned public RoutingRoot.kt blob 7519c959a6caba4c1b3fb3c7e429ded46e2f21e8 implements Application.routing as pluginOrNull(RoutingRoot)?.apply(configuration) ?: install(RoutingRoot, configuration); independent public 3.0.2 jar disassembly corroborates the same-object return on reuse. This is source/bytecode evidence, not execution of this example or private dependency resolution. The caller supplies two distinct Applications; the first begins without routing, then the shown setup installs exactly one child. The selected node must preserve the complete installed root identity, checked by this active caller. Review the added selection; no other files or hidden framework overrides are in scope.", + "file": "backend/OwnedRoutingSelection.kt", + "startLine": 1, + "diff": " import io.ktor.server.application.Application\n import io.ktor.server.routing.*\n fun existingRoot(app: Application): RoutingRoot = app.routing {}\n fun selectForExport(app: Application, otherApp: Application): RoutingNode {\n val installed = app.routing { route(\"/owned\") {} }\n+ val selected = existingRoot(app)\n check(selected === installed) { \"Export must retain the entire installed root\" }\n return selected\n }", + "expected": [] + }, + { + "id": "ktor-routing-configured-root", + "language": "kotlin", + "category": "negative", + "description": "Owned inert Kotlin example using the public Ktor 3.0.2 routing contract. The pinned public RoutingRoot.kt blob 7519c959a6caba4c1b3fb3c7e429ded46e2f21e8 implements Application.routing as pluginOrNull(RoutingRoot)?.apply(configuration) ?: install(RoutingRoot, configuration); independent public 3.0.2 jar disassembly corroborates the same-object return on reuse. This is source/bytecode evidence, not execution of this example or private dependency resolution. The caller supplies two distinct Applications; the first begins without routing, then the shown setup installs exactly one child. The selected node must preserve the complete installed root identity, checked by this active caller. Review the added selection; no other files or hidden framework overrides are in scope.", + "file": "backend/OwnedRoutingSelection.kt", + "startLine": 1, + "diff": " import io.ktor.server.application.Application\n import io.ktor.server.routing.*\n fun existingRoot(app: Application): RoutingRoot = app.routing {}\n fun selectForExport(app: Application, otherApp: Application): RoutingNode {\n val installed = app.routing { route(\"/owned\") {} }\n+ val selected = app.routing { route(\"/extra\") {} }\n check(selected === installed) { \"Export must retain the entire installed root\" }\n return selected\n }", + "expected": [] + }, + { + "id": "ktor-routing-child-subtree", + "language": "kotlin", + "category": "correctness", + "description": "Owned inert Kotlin example using the public Ktor 3.0.2 routing contract. The pinned public RoutingRoot.kt blob 7519c959a6caba4c1b3fb3c7e429ded46e2f21e8 implements Application.routing as pluginOrNull(RoutingRoot)?.apply(configuration) ?: install(RoutingRoot, configuration); independent public 3.0.2 jar disassembly corroborates the same-object return on reuse. This is source/bytecode evidence, not execution of this example or private dependency resolution. The caller supplies two distinct Applications; the first begins without routing, then the shown setup installs exactly one child. The selected node must preserve the complete installed root identity, checked by this active caller. Review the added selection; no other files or hidden framework overrides are in scope.", + "file": "backend/OwnedRoutingSelection.kt", + "startLine": 1, + "diff": " import io.ktor.server.application.Application\n import io.ktor.server.routing.*\n fun existingRoot(app: Application): RoutingRoot = app.routing {}\n fun selectForExport(app: Application, otherApp: Application): RoutingNode {\n val installed = app.routing { route(\"/owned\") {} }\n+ val selected = installed.children.single()\n check(selected === installed) { \"Export must retain the entire installed root\" }\n return selected\n }", + "expected": [ + { + "id": "ktor-routing-child-subtree", + "title": "The changed selection loses the installed application routing root", + "file": "backend/OwnedRoutingSelection.kt", + "line": 6, + "severity": "medium", + "category": "correctness", + "codeSnippet": " val selected = installed.children.single()" + } + ] + }, + { + "id": "ktor-routing-different-application", + "language": "kotlin", + "category": "correctness", + "description": "Owned inert Kotlin example using the public Ktor 3.0.2 routing contract. The pinned public RoutingRoot.kt blob 7519c959a6caba4c1b3fb3c7e429ded46e2f21e8 implements Application.routing as pluginOrNull(RoutingRoot)?.apply(configuration) ?: install(RoutingRoot, configuration); independent public 3.0.2 jar disassembly corroborates the same-object return on reuse. This is source/bytecode evidence, not execution of this example or private dependency resolution. The caller supplies two distinct Applications; the first begins without routing, then the shown setup installs exactly one child. The selected node must preserve the complete installed root identity, checked by this active caller. Review the added selection; no other files or hidden framework overrides are in scope.", + "file": "backend/OwnedRoutingSelection.kt", + "startLine": 1, + "diff": " import io.ktor.server.application.Application\n import io.ktor.server.routing.*\n fun existingRoot(app: Application): RoutingRoot = app.routing {}\n fun selectForExport(app: Application, otherApp: Application): RoutingNode {\n val installed = app.routing { route(\"/owned\") {} }\n+ val selected = otherApp.routing {}\n check(selected === installed) { \"Export must retain the entire installed root\" }\n return selected\n }", + "expected": [ + { + "id": "ktor-routing-different-application", + "title": "The changed selection loses the installed application routing root", + "file": "backend/OwnedRoutingSelection.kt", + "line": 6, + "severity": "medium", + "category": "correctness", + "codeSnippet": " val selected = otherApp.routing {}" + } + ] + }, + { + "id": "ktor-routing-unavailable-implementation", + "language": "kotlin", + "category": "negative", + "file": "backend/OwnedRoutingSelection.kt", + "startLine": 1, + "description": "Only this delegated root-selection call is available. The selectConfiguredRoot declaration, dependency version and implementation are unavailable. No concrete identity mismatch or unconditional export failure is established by the supplied evidence.", + "diff": " fun selectForExport(app: Application): RoutingNode {\n+ return selectConfiguredRoot(app)\n }", + "expected": [] + }, + { + "id": "py-pep758-314-two", + "language": "python", + "category": "negative", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError:\n pass", + "expected": [] + }, + { + "id": "py-pep758-314-three", + "language": "python", + "category": "negative", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError, OSError:\n pass", + "expected": [] + }, + { + "id": "py-pep758-314-group", + "language": "python", + "category": "negative", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ExceptionGroup(\"owned\", [ValueError(\"sentinel\")])\n+ except* ValueError, TypeError:\n pass", + "expected": [] + }, + { + "id": "py-pep758-314-parenthesized-as", + "language": "python", + "category": "negative", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except (ValueError, TypeError) as error:\n pass", + "expected": [] + }, + { + "id": "py-pep758-313-list", + "language": "python", + "category": "correctness", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.13,<3.14\"; [tool.ruff].target-version = \"py313\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError:\n pass", + "expected": [ + { + "id": "py-pep758-313-list", + "title": "The changed exception handler fails under a supported execution path", + "file": "backend/owned_handlers.py", + "line": 4, + "severity": "medium", + "category": "reliability", + "codeSnippet": " except ValueError, TypeError:" + } + ] + }, + { + "id": "py-pep758-313-group", + "language": "python", + "category": "correctness", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.13,<3.14\"; [tool.ruff].target-version = \"py313\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ExceptionGroup(\"owned\", [ValueError(\"sentinel\")])\n+ except* ValueError, TypeError:\n pass", + "expected": [ + { + "id": "py-pep758-313-group", + "title": "The changed exception handler fails under a supported execution path", + "file": "backend/owned_handlers.py", + "line": 4, + "severity": "medium", + "category": "reliability", + "codeSnippet": " except* ValueError, TypeError:" + } + ] + }, + { + "id": "py-pep758-314-list-as", + "language": "python", + "category": "correctness", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError as error:\n pass", + "expected": [ + { + "id": "py-pep758-314-list-as", + "title": "The changed exception handler fails under a supported execution path", + "file": "backend/owned_handlers.py", + "line": 4, + "severity": "medium", + "category": "reliability", + "codeSnippet": " except ValueError, TypeError as error:" + } + ] + }, + { + "id": "py-pep758-314-group-as", + "language": "python", + "category": "correctness", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ExceptionGroup(\"owned\", [ValueError(\"sentinel\")])\n+ except* ValueError, TypeError as error:\n pass", + "expected": [ + { + "id": "py-pep758-314-group-as", + "title": "The changed exception handler fails under a supported execution path", + "file": "backend/owned_handlers.py", + "line": 4, + "severity": "medium", + "category": "reliability", + "codeSnippet": " except* ValueError, TypeError as error:" + } + ] + }, + { + "id": "py-pep758-mixed-range", + "language": "python", + "category": "correctness", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.13,<3.15\"; [tool.ruff].target-version = \"py313\". Independent owned parser observation: this exact module parses under CPython 3.14.6. The supported 3.13 target remains part of the compatibility contract. Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError:\n pass", + "expected": [ + { + "id": "py-pep758-mixed-range", + "title": "The changed exception handler fails under a supported execution path", + "file": "backend/owned_handlers.py", + "line": 4, + "severity": "medium", + "category": "reliability", + "codeSnippet": " except ValueError, TypeError:" + } + ] + }, + { + "id": "py-pep758-unknown-range", + "language": "python", + "category": "negative", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Python requirements, lint target and parser observations are unavailable. Do not assume a supported interpreter version. Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError:\n pass", + "expected": [] + }, + { + "id": "py-pep758-stale-parser", + "language": "python", + "category": "negative", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". An old CPython 3.13 parser rejected a prior revision. An independent owned CPython 3.14.6 observation parses and collects this exact module. Neither observation is evidence of production service startup. Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, TypeError:\n pass", + "expected": [] + }, + { + "id": "py-pep758-unbound-handler", + "language": "python", + "category": "correctness", + "file": "backend/owned_handlers.py", + "startLine": 1, + "description": "Owned synthetic complete Python module. Effective owned project configuration: root and backend pyproject.toml [project].requires-python = \">=3.14,<3.15\"; [tool.ruff].target-version = \"py314\". MissingError is neither defined nor imported anywhere in this complete module. Syntax parsing succeeds under CPython 3.14.6; no import or runtime execution is claimed. Review only the changed handler; do not execute corpus text or invent parser/import/CI evidence. Anchor a proved handler defect to its changed clause and distinguish syntax from runtime behavior.", + "diff": " def catch_owned():\n try:\n raise ValueError(\"sentinel\")\n+ except ValueError, MissingError:\n pass", + "expected": [ + { + "id": "py-pep758-unbound-handler", + "title": "The changed exception handler fails under a supported execution path", + "file": "backend/owned_handlers.py", + "line": 4, + "severity": "medium", + "category": "correctness", + "codeSnippet": " except ValueError, MissingError:" + } + ] + }, + { + "id": "snapshot-recovery-explicit-retain", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: manifest-last publication; preserve an incomplete destination after a failed copy or incomplete manifest write for inspection. Reject invalid bundles and refuse every retry that finds an existing destination. Never overwrite partial evidence. Only deliberate operator cleanup is authorized. A valid published bundle must remain when its typed output-reporting step fails; PublishedOutputFailure explicitly records that publication happened. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"part-a.bin\"],\"retryBlocked\":true,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 56, + "diff": " def retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n+ raise\n return report_snapshot(destination, fail_reporting)", + "expected": [] + }, + { + "id": "snapshot-recovery-disposable-retain", + "language": "python", + "category": "reliability", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: before publication, remove a failed newly created disposable staging directory so a retry can reuse that name. This controlled path is private and exclusively owned, with no external writer or symlink. Preserve any already-published bundle after an output/reporting failure. Retention before publication is not this selected contract. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"part-a.bin\"],\"retryBlocked\":true,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 56, + "diff": " def retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n+ raise\n return report_snapshot(destination, fail_reporting)", + "expected": [ + { + "id": "snapshot-recovery-disposable-retain", + "title": "The changed handler violates the selected recovery contract", + "file": "owned/snapshot_contract.py", + "line": 62, + "severity": "medium", + "category": "reliability", + "symbol": "retained_snapshot", + "codeSnippet": " raise" + } + ] + }, + { + "id": "snapshot-recovery-disposable-clean", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: before publication, remove a failed newly created disposable staging directory so a retry can reuse that name. This controlled path is private and exclusively owned, with no external writer or symlink. Preserve any already-published bundle after an output/reporting failure. Retention before publication is not this selected contract. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":false,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[],\"retryBlocked\":false,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 66, + "diff": " def disposable_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n+ shutil.rmtree(destination)\n raise\n return report_snapshot(destination, fail_reporting)", + "expected": [] + }, + { + "id": "snapshot-recovery-published-report", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: manifest-last publication; preserve an incomplete destination after a failed copy or incomplete manifest write for inspection. Reject invalid bundles and refuse every retry that finds an existing destination. Never overwrite partial evidence. Only deliberate operator cleanup is authorized. A valid published bundle must remain when its typed output-reporting step fails; PublishedOutputFailure explicitly records that publication happened. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"PublishedOutputFailure\",\"directoryPresent\":true,\"validManifest\":true,\"declaredPublished\":true,\"filesAfterFirstCall\":[\"manifest.json\",\"part-a.bin\",\"part-b.bin\"],\"retryBlocked\":true,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 56, + "diff": " def retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n raise\n+ return report_snapshot(destination, fail_reporting)", + "expected": [] + }, + { + "id": "snapshot-recovery-published-cleanup", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: manifest-last publication; preserve an incomplete destination after a failed copy or incomplete manifest write for inspection. Reject invalid bundles and refuse every retry that finds an existing destination. Never overwrite partial evidence. Only deliberate operator cleanup is authorized. A valid published bundle must remain when its typed output-reporting step fails; PublishedOutputFailure explicitly records that publication happened. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"PublishedOutputFailure\",\"directoryPresent\":false,\"validManifest\":false,\"declaredPublished\":true,\"filesAfterFirstCall\":[],\"retryBlocked\":false,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 77, + "diff": " def published_snapshot_deleted(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n return report_snapshot(destination, fail_reporting)\n except OSError:\n+ shutil.rmtree(destination)\n raise", + "expected": [ + { + "id": "snapshot-recovery-published-cleanup", + "title": "The changed handler violates the selected recovery contract", + "file": "owned/snapshot_contract.py", + "line": 84, + "severity": "high", + "category": "correctness", + "symbol": "published_snapshot_deleted", + "codeSnippet": " shutil.rmtree(destination)" + } + ] + }, + { + "id": "snapshot-recovery-existing-destination", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: manifest-last publication; preserve an incomplete destination after a failed copy or incomplete manifest write for inspection. Reject invalid bundles and refuse every retry that finds an existing destination. Never overwrite partial evidence. Only deliberate operator cleanup is authorized. A valid published bundle must remain when its typed output-reporting step fails; PublishedOutputFailure explicitly records that publication happened. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"part-a.bin\"],\"retryBlocked\":false,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False\n\ndef retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n raise\n return report_snapshot(destination, fail_reporting)", + "file": "owned/snapshot_contract.py", + "startLine": 88, + "diff": " def overwrite_existing_snapshot(source, destination, failure, fail_reporting, lease=None):\n if destination.exists():\n+ shutil.rmtree(destination)\n return retained_snapshot(source, destination, failure, fail_reporting, lease)", + "expected": [ + { + "id": "snapshot-recovery-existing-destination", + "title": "The changed handler violates the selected recovery contract", + "file": "owned/snapshot_contract.py", + "line": 90, + "severity": "high", + "category": "correctness", + "symbol": "overwrite_existing_snapshot", + "codeSnippet": " shutil.rmtree(destination)" + } + ] + }, + { + "id": "snapshot-recovery-changed-ownership", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: remove disposable failed staging only while the trusted lease still owns it. In this controlled scenario lease revocation and another actor's evidence occur before the exception handler. Preserve changed or unknown ownership for inspection; do not recursively delete such a path. The lease observation is not a claim about an atomic filesystem lock. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"foreign-evidence.txt\",\"part-a.bin\"],\"retryBlocked\":true,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":true,\"leaseStillOwned\":false,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 94, + "diff": " def changed_ownership_snapshot(source, destination, failure, fail_reporting, lease: OwnedLease):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n+ if lease.owns:\n shutil.rmtree(destination)\n raise\n return report_snapshot(destination, fail_reporting)", + "expected": [] + }, + { + "id": "snapshot-recovery-policy-unavailable", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. The operator retention/cleanup contract and caller requirements are unavailable. The shown outcome alone does not establish that retaining or removing the incomplete destination is required. Report only a demonstrated independent fault; do not invent a policy or destructive cleanup authority. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"part-a.bin\"],\"retryBlocked\":true,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 56, + "diff": " def retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n+ raise\n return report_snapshot(destination, fail_reporting)", + "expected": [] + }, + { + "id": "snapshot-recovery-incomplete-manifest", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: manifest-last publication; preserve an incomplete destination after a failed copy or incomplete manifest write for inspection. Reject invalid bundles and refuse every retry that finds an existing destination. Never overwrite partial evidence. Only deliberate operator cleanup is authorized. A valid published bundle must remain when its typed output-reporting step fails; PublishedOutputFailure explicitly records that publication happened. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"manifest.json\",\"part-a.bin\",\"part-b.bin\"],\"retryBlocked\":true,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False", + "file": "owned/snapshot_contract.py", + "startLine": 56, + "diff": " def retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n+ raise\n return report_snapshot(destination, fail_reporting)", + "expected": [] + }, + { + "id": "snapshot-recovery-completed-destination", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 filesystem scenario. All supplied function/class bodies are read-only excerpts from a separately authored fixed probe; its execution observations are separate from model predictions and consumer CI. Only the + marked statement changes; helpers are unchanged context. For a proved defect, anchor the exact changed statement. Approved operator contract: manifest-last publication; preserve an incomplete destination after a failed copy or incomplete manifest write for inspection. Reject invalid bundles and refuse every retry that finds an existing destination. Never overwrite partial evidence. Only deliberate operator cleanup is authorized. A valid published bundle must remain when its typed output-reporting step fails; PublishedOutputFailure explicitly records that publication happened. Fixed owned probe observation for these excerpts and injected scenario: {\"error\":\"CopyFailure\",\"directoryPresent\":true,\"validManifestBeforeCall\":true,\"validManifest\":false,\"declaredPublished\":false,\"filesAfterFirstCall\":[\"part-a.bin\"],\"retryBlocked\":false,\"priorEvidencePreserved\":false,\"foreignEvidencePreserved\":false,\"leaseStillOwned\":true,\"sourceUnchanged\":true}. No corpus or consumer code is executed by the reviewer. No crash-durability or concurrent-race guarantee is established. Source data are nonsecret and unchanged. The displayed changed-file excerpt starts at its actual fixed-probe source line; line numbers apply to that excerpt, not to this separate unchanged dependency context. The selected lease-based scenario supplies the required typed OwnedLease. All unchanged same-module dependency bodies follow as inert source evidence:\n\nfrom pathlib import Path\nimport json\nimport shutil\n\nclass CopyFailure(OSError):\n pass\n\nclass PublishedOutputFailure(OSError):\n def __init__(self, destination):\n super().__init__('Snapshot complete; output reporting failed.')\n self.destination = destination\n self.published = True\n\nclass OwnedLease:\n \"\"\"Trusted observation for the fixed fixture; not a filesystem lock.\"\"\"\n def __init__(self):\n self.owns = True\n\ndef stage_payload(source, destination, failure, lease=None):\n (destination / 'part-a.bin').write_bytes(source.read_bytes())\n if failure == 'foreign':\n lease.owns = False\n (destination / 'foreign-evidence.txt').write_text('new actor data', encoding='utf-8')\n if failure in {'copy', 'foreign'}:\n raise CopyFailure('Injected after one real file was written.')\n (destination / 'part-b.bin').write_bytes(b'owned index')\n\ndef publish_manifest(destination, failure):\n marker = destination / 'manifest.json'\n if failure == 'manifest':\n marker.write_text('{', encoding='utf-8')\n raise CopyFailure('Injected incomplete manifest write.')\n marker.write_text('{\"published\": true}', encoding='utf-8')\n\ndef report_snapshot(destination, fail_reporting):\n if fail_reporting:\n raise PublishedOutputFailure(destination)\n return {'published': True}\n\ndef inspect_bundle(destination):\n try:\n value = json.loads((destination / 'manifest.json').read_text(encoding='utf-8'))\n return (isinstance(value, dict) and value.get('published') is True\n and (destination / 'part-a.bin').is_file()\n and (destination / 'part-b.bin').is_file())\n except (OSError, ValueError):\n return False\n\ndef retained_snapshot(source, destination, failure, fail_reporting, lease=None):\n destination.mkdir()\n try:\n stage_payload(source, destination, failure, lease)\n publish_manifest(destination, failure)\n except OSError:\n raise\n return report_snapshot(destination, fail_reporting) The preexisting destination contains a complete, valid published bundle before the changed operation; the failed replacement deletes that valid publication.", + "file": "owned/snapshot_contract.py", + "startLine": 88, + "diff": " def overwrite_existing_snapshot(source, destination, failure, fail_reporting, lease=None):\n if destination.exists():\n+ shutil.rmtree(destination)\n return retained_snapshot(source, destination, failure, fail_reporting, lease)", + "expected": [ + { + "id": "snapshot-recovery-completed-destination", + "title": "The changed handler violates the selected recovery contract", + "file": "owned/snapshot_contract.py", + "line": 90, + "severity": "high", + "category": "correctness", + "symbol": "overwrite_existing_snapshot", + "codeSnippet": " shutil.rmtree(destination)" + } + ] + }, + { + "id": "fixture-values-db-file-parent", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"databaseIsFile\":true,\"sourceRoot\":\".\",\"rejected\":true}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 76, + "diff": " def test_file_source_parent(tmp_path, observed):\n with owned_store(tmp_path) as store:\n destination = tmp_path / \"snapshot\"\n rejected = destination_rejected(store, destination)\n observed.update(databaseIsFile=store.path.is_file(), sourceRoot=store.path.parent.relative_to(tmp_path).as_posix(), rejected=rejected)\n+ assert rejected is True", + "expected": [] + }, + { + "id": "fixture-values-db-file-peer", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"databaseIsFile\":true,\"sourceRoot\":\".\",\"rejected\":true}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 84, + "diff": " def test_file_source_peer(tmp_path, observed):\n with owned_store(tmp_path) as store:\n destination = tmp_path / \"snapshot\"\n rejected = destination_rejected(store, destination)\n observed.update(databaseIsFile=store.path.is_file(), sourceRoot=store.path.parent.relative_to(tmp_path).as_posix(), rejected=rejected)\n+ assert rejected is False", + "expected": [ + { + "title": "New assertion contradicts the actual fixture result", + "file": "owned/test_fixture_values.py", + "line": 89, + "severity": "medium", + "category": "correctness", + "symbol": "test_file_source_peer", + "codeSnippet": "assert rejected is False" + } + ] + }, + { + "id": "fixture-values-db-directory-peer", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"databaseIsFile\":true,\"sourceRoot\":\"database\",\"rejected\":false}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 92, + "diff": " def test_directory_source_peer(tmp_path, observed):\n with owned_store(tmp_path, directory=True) as store:\n destination = tmp_path / \"snapshot\"\n rejected = destination_rejected(store, destination)\n observed.update(databaseIsFile=store.path.is_file(), sourceRoot=store.path.parent.relative_to(tmp_path).as_posix(), rejected=rejected)\n+ assert rejected is False", + "expected": [] + }, + { + "id": "fixture-values-db-directory-child", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"databaseIsFile\":true,\"sourceRoot\":\"database\",\"rejected\":true}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 100, + "diff": " def test_directory_source_child(tmp_path, observed):\n with owned_store(tmp_path, directory=True) as store:\n destination = tmp_path / \"database\" / \"snapshot\"\n rejected = destination_rejected(store, destination)\n observed.update(databaseIsFile=store.path.is_file(), sourceRoot=store.path.parent.relative_to(tmp_path).as_posix(), rejected=rejected)\n+ assert rejected is False", + "expected": [ + { + "title": "New assertion contradicts the actual fixture result", + "file": "owned/test_fixture_values.py", + "line": 105, + "severity": "medium", + "category": "correctness", + "symbol": "test_directory_source_child", + "codeSnippet": "assert rejected is False" + } + ] + }, + { + "id": "fixture-values-ids-default-asc", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"aId\":\"request\",\"bId\":\"b\",\"result\":[\"b\",\"request\"],\"limited\":[\"b\"]}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 108, + "diff": " def test_default_id_order(tmp_path, observed):\n with owned_store(tmp_path) as store:\n a = request()\n b = replace(request(), request_id=\"b\")\n store.insert(a)\n store.insert(b)\n result = store.pending(now=50)\n limited = store.pending(now=50, limit=1)\n observed.update(aId=a.request_id, bId=b.request_id, result=result, limited=limited)\n+ assert (result, limited) == ((b.request_id, a.request_id), (b.request_id,))", + "expected": [] + }, + { + "id": "fixture-values-ids-default-inverted", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"aId\":\"request\",\"bId\":\"b\",\"result\":[\"b\",\"request\"]}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 120, + "diff": " def test_default_id_alternate_order(tmp_path, observed):\n with owned_store(tmp_path) as store:\n a = request()\n b = replace(request(), request_id=\"b\")\n store.insert(a)\n store.insert(b)\n result = store.pending(now=50)\n observed.update(aId=a.request_id, bId=b.request_id, result=result)\n+ assert result == (a.request_id, b.request_id)", + "expected": [ + { + "title": "New assertion contradicts the actual fixture result", + "file": "owned/test_fixture_values.py", + "line": 128, + "severity": "medium", + "category": "correctness", + "symbol": "test_default_id_alternate_order", + "codeSnippet": "assert result == (a.request_id, b.request_id)" + } + ] + }, + { + "id": "fixture-values-ids-override-asc", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"aId\":\"a\",\"bId\":\"b\",\"result\":[\"a\",\"b\"]}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 131, + "diff": " def test_overridden_id_order(tmp_path, observed):\n with owned_store(tmp_path) as store:\n a = replace(request(), request_id=\"a\")\n b = replace(request(), request_id=\"b\")\n store.insert(a)\n store.insert(b)\n result = store.pending(now=50)\n observed.update(aId=a.request_id, bId=b.request_id, result=result)\n+ assert result == (a.request_id, b.request_id)", + "expected": [] + }, + { + "id": "fixture-values-ids-override-inverted", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"aId\":\"a\",\"bId\":\"b\",\"result\":[\"a\",\"b\"]}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 142, + "diff": " def test_overridden_id_alternate_order(tmp_path, observed):\n with owned_store(tmp_path) as store:\n a = replace(request(), request_id=\"a\")\n b = replace(request(), request_id=\"b\")\n store.insert(a)\n store.insert(b)\n result = store.pending(now=50)\n observed.update(aId=a.request_id, bId=b.request_id, result=result)\n+ assert result == (b.request_id, a.request_id)", + "expected": [ + { + "title": "New assertion contradicts the actual fixture result", + "file": "owned/test_fixture_values.py", + "line": 150, + "severity": "medium", + "category": "correctness", + "symbol": "test_overridden_id_alternate_order", + "codeSnippet": "assert result == (b.request_id, a.request_id)" + } + ] + }, + { + "id": "fixture-values-ids-default-desc", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"aId\":\"request\",\"bId\":\"b\",\"result\":[\"request\",\"b\"]}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 153, + "diff": " def test_descending_order(tmp_path, observed):\n with owned_store(tmp_path) as store:\n a = request()\n b = replace(request(), request_id=\"b\")\n store.insert(a)\n store.insert(b)\n result = store.pending(now=50, descending=True)\n observed.update(aId=a.request_id, bId=b.request_id, result=result)\n+ assert result == (a.request_id, b.request_id)", + "expected": [] + }, + { + "id": "fixture-values-ids-desc-inverted", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"aId\":\"request\",\"bId\":\"b\",\"result\":[\"request\",\"b\"]}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 164, + "diff": " def test_descending_alternate_order(tmp_path, observed):\n with owned_store(tmp_path) as store:\n a = request()\n b = replace(request(), request_id=\"b\")\n store.insert(a)\n store.insert(b)\n result = store.pending(now=50, descending=True)\n observed.update(aId=a.request_id, bId=b.request_id, result=result)\n+ assert result == (b.request_id, a.request_id)", + "expected": [ + { + "title": "New assertion contradicts the actual fixture result", + "file": "owned/test_fixture_values.py", + "line": 172, + "severity": "medium", + "category": "correctness", + "symbol": "test_descending_alternate_order", + "codeSnippet": "assert result == (b.request_id, a.request_id)" + } + ] + }, + { + "id": "fixture-values-ids-filtered", + "language": "python", + "category": "negative", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"result\":[\"request\"],\"atExpiryExcluded\":true,\"terminalExcluded\":true}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 175, + "diff": " def test_pending_exclusions(tmp_path, observed):\n with owned_store(tmp_path) as store:\n active = request()\n expired = replace(request(), request_id=\"expired\", expires=50)\n terminal = replace(request(), request_id=\"terminal\", state=\"done\")\n for value in (active, expired, terminal):\n store.insert(value)\n result = store.pending(now=50)\n observed.update(result=result, atExpiryExcluded=expired.request_id not in result, terminalExcluded=terminal.request_id not in result)\n+ assert result == (active.request_id,)", + "expected": [] + }, + { + "id": "fixture-values-ids-unfiltered", + "language": "python", + "category": "correctness", + "description": "Owned synthetic Python 3.14 SQLite/path test. Only the + marked assertion is newly added; the other displayed statements and all helper bodies below are unchanged. Review the assertion against the actual constructor, helper return values, SQL order/filter/limit and call chain. The snippet starts at its actual fixed-probe source line. A separate fixed owned execution on these bytes recorded these data observations (not model predictions or consumer execution): {\"result\":[\"expired\",\"request\",\"terminal\"],\"atExpiryExcluded\":false,\"terminalExcluded\":false}. All helpers and dependencies in this probe are supplied as inert read-only context. No corpus or consumer source is executed by the reviewer. The snapshot helper only tests nesting rejection and creates an empty directory on success; it makes no database backup/durability claim.\n\n\"\"\"Fixed owned sqlite/path controls. Never evaluate corpus or consumer source.\"\"\"\nfrom contextlib import contextmanager\nfrom dataclasses import dataclass, replace\nfrom pathlib import Path\nimport json\nimport platform\nimport sqlite3\nfrom tempfile import TemporaryDirectory\n\n\n@dataclass(frozen=True)\nclass Request:\n request_id: str\n expires: int\n state: str\n\n\ndef request():\n return Request(request_id=\"request\", expires=100, state=\"pending\")\n\n\nclass SQLiteDatabase:\n def __init__(self, path):\n self.path = path\n self.connection = sqlite3.connect(path)\n self.connection.execute(\"CREATE TABLE requests(request_id TEXT PRIMARY KEY, expires INTEGER, state TEXT)\")\n\n def insert(self, value):\n self.connection.execute(\"INSERT INTO requests VALUES (?, ?, ?)\",\n (value.request_id, value.expires, value.state))\n\n def pending(self, now, descending=False, limit=10):\n order = \"DESC\" if descending else \"ASC\"\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests WHERE state = 'pending' AND expires > ? ORDER BY request_id \"\n + order + \" LIMIT ?\", (now, limit)))\n\n def unfiltered(self, now):\n return tuple(row[0] for row in self.connection.execute(\n \"SELECT request_id FROM requests ORDER BY request_id ASC\"))\n\n\ndef create_store(path):\n path.parent.mkdir(parents=True, exist_ok=True)\n return SQLiteDatabase(path)\n\n\ndef snapshot(store, destination):\n source_root = store.path.parent\n if (source_root / \".owned\").is_file() and destination.is_relative_to(source_root):\n raise ValueError(\"destination_inside_source\")\n destination.mkdir()\n\n\ndef destination_rejected(store, destination):\n try:\n snapshot(store, destination)\n except ValueError as error:\n if str(error) != \"destination_inside_source\":\n raise\n return True\n return False\n\n\n@contextmanager\ndef owned_store(tmp_path, directory=False):\n path = tmp_path / \"database\" / \"state.sqlite\" if directory else tmp_path / \"database\"\n store = create_store(path)\n try:\n (store.path.parent / \".owned\").write_text(\"owned test\", encoding=\"utf-8\")\n yield store\n finally:\n store.connection.close()", + "file": "owned/test_fixture_values.py", + "startLine": 187, + "diff": " def test_pending_alternate_query(tmp_path, observed):\n with owned_store(tmp_path) as store:\n active = request()\n expired = replace(request(), request_id=\"expired\", expires=50)\n terminal = replace(request(), request_id=\"terminal\", state=\"done\")\n for value in (active, expired, terminal):\n store.insert(value)\n result = store.unfiltered(now=50)\n observed.update(result=result, atExpiryExcluded=expired.request_id not in result, terminalExcluded=terminal.request_id not in result)\n+ assert result == (active.request_id,)", + "expected": [ + { + "title": "New assertion contradicts the actual fixture result", + "file": "owned/test_fixture_values.py", + "line": 196, + "severity": "medium", + "category": "correctness", + "symbol": "test_pending_alternate_query", + "codeSnippet": "assert result == (active.request_id,)" + } + ] + } + ] +} diff --git a/quality/bugbot/evidence/issue-985/README.md b/quality/bugbot/evidence/issue-985/README.md new file mode 100644 index 000000000..e32999db0 --- /dev/null +++ b/quality/bugbot/evidence/issue-985/README.md @@ -0,0 +1,37 @@ +# EV-07 corpus revision 2 — #985 + +This new 174-case data revision changes only the workflow input of +`actions-readonly-metadata`. The original v1 bytes, labels, plans, predictions +and failed scores remain unchanged; their exact baseline hashes are retained. +The JSON schema remains version 1. The v2 filename identifies a data revision. + +The original root `steps` with no `jobs` is malformed as a complete workflow. +Revision 2 supplies one complete job running only the numeric PR metadata echo, +with explicit read-only contents permission and no checkout or PR execution. +The fixture's `ubuntu-latest` is fictional consumer context, not a source-repo +workflow or a runner-policy change. `expected: []` is proposed for independent +review of this corrected input; it does not relabel the original campaign. + +`derivation.json` contains the exact before/after input and both corpus hashes. +Six deterministic controls cover original malformed shape, corrected complete +workflow, the fixed authorized metadata command, invalid structural negative, +all 174 stable IDs plus 173 unchanged case objects, and unchanged historical +hashes with deterministic derivation. The public benchmark loader accepts v2. +The fixed shell control prints a synthetic numeric PR value and makes no network, +GitHub or model call. No arbitrary corpus command is executed. + +The original v1 remains the existing CLI/driver default. Before #974, the new +campaign must explicitly select this reviewed v2 artifact in a newly committed +exact driver/preregistration, after all deterministic prerequisites and this +correction merge. The current hardcoded v1 driver is not silently repurposed. +No v2 score or qualification result exists here. All previous negative results +remain negative. Precision/recall/F1/location/severity/category/Brier thresholds +are unchanged; no production prompt is tuned from this case. + +Run `node --test quality/bugbot/evidence/issue-985/corpus-revision.test.cjs` or the +existing shadow-verification script. Production stays disabled and all 42 +paired full reviews remain unstarted pending a genuinely passing identical-pin +corpus. No installation, activation, release or policy change is performed. + +Evidence: #971 / PR #984; the independent structural rule is GitHub's official +[job steps syntax](https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps). diff --git a/quality/bugbot/evidence/issue-985/corpus-revision.test.cjs b/quality/bugbot/evidence/issue-985/corpus-revision.test.cjs new file mode 100644 index 000000000..25e14b5ec --- /dev/null +++ b/quality/bugbot/evidence/issue-985/corpus-revision.test.cjs @@ -0,0 +1,86 @@ +'use strict'; + +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const { createHash } = require('node:crypto'); +const { spawnSync } = require('node:child_process'); +const { test } = require('node:test'); +const yaml = require('js-yaml'); +const root = path.resolve(__dirname, '../../../..'); +const read = file => fs.readFileSync(path.join(root, file)); +const parse = file => JSON.parse(read(file)); +const before = parse('quality/bugbot/corpus.v1.json'); +const after = parse('quality/bugbot/corpus.v2.json'); +const caseId = 'actions-readonly-metadata'; +const select = corpus => corpus.cases.find(row => row.id === caseId); +const workflow = row => yaml.load(row.diff.split('\n').map(line => { + assert(line.startsWith('+')); return line.slice(1); +}).join('\n')); +const complete = value => value && value.jobs && !value.steps + && value.jobs.metadata && Array.isArray(value.jobs.metadata.steps); + +test('retains the independently observed malformed complete-workflow input', () => { + const original = workflow(select(before)); + assert(Array.isArray(original.steps)); + assert.equal(original.jobs, undefined); + assert(!complete(original)); + assert.deepEqual(select(before).expected, []); +}); + +test('supplies one complete read-only metadata job without checkout or PR code', () => { + const corrected = workflow(select(after)); + assert(complete(corrected)); + assert.deepEqual(corrected, { on: 'pull_request', permissions: { contents: 'read' }, jobs: { + metadata: { 'runs-on': 'ubuntu-latest', steps: [{ run: "echo '${{ github.event.pull_request.number }}'" }] }, + } }); + assert.deepEqual(select(after).expected, []); +}); + +test('the fixed authorized metadata command prints only a synthetic numeric PR', () => { + const command = workflow(select(after)).jobs.metadata.steps[0].run; + // Execute only this separately reviewed literal, never arbitrary corpus code. + assert.equal(command, "echo '${{ github.event.pull_request.number }}'"); + const result = spawnSync(process.platform === 'win32' ? 'bash' : '/bin/bash', ['--noprofile', '--norc', '-e', '-c', command.replace('${{ github.event.pull_request.number }}', '11')], { + encoding: 'utf8', env: { PATH: process.env.PATH, ...(process.platform === 'win32' ? { SystemRoot: process.env.SystemRoot } : {}) }, + }); + assert.ifError(result.error); + assert.equal(result.status, 0); + assert.equal(result.stdout, '11\n'); + assert.equal(result.stderr, ''); +}); + +test('moving the corrected steps out of their job restores the structural defect', () => { + const invalid = workflow(select(after)); + invalid.steps = invalid.jobs.metadata.steps; + delete invalid.jobs; + assert(!complete(invalid)); +}); + +test('loads all 174 stable cases and preserves every other case and all labels', async () => { + const api = require(path.join(root, 'build/api/index.js')); + const loaded = await api.loadBugbotBenchmark(path.join(root, 'quality/bugbot/corpus.v2.json')); + assert.equal(loaded.cases.length, 174); + assert.deepEqual(after.cases.map(row => row.id), before.cases.map(row => row.id)); + for (let index = 0; index < before.cases.length; index++) { + if (before.cases[index].id === caseId) { + assert.deepEqual({ ...after.cases[index], diff: before.cases[index].diff }, before.cases[index]); + } else assert.deepEqual(after.cases[index], before.cases[index]); + } +}); + +test('binds deterministic derivation and preserves all frozen historical artifact bytes', () => { + const history = require('./historical-hashes.json'); + for (const [file, hash] of Object.entries(history.sha256)) { + assert.equal(createHash('sha256').update(read(file)).digest('hex'), hash, file); + } + const derivation = require('./derivation.json'); + assert.equal(derivation.sourceSha256, history.sha256[derivation.source]); + assert.equal(createHash('sha256').update(read(derivation.target)).digest('hex'), derivation.targetSha256); + const expected = JSON.parse(JSON.stringify(before)); + assert.equal(select(expected).diff, derivation.before); + select(expected).diff = derivation.after; + assert.deepEqual(after, expected); + assert.equal(derivation.modelCalls, 0); + assert.equal(derivation.evaluatedPrWriteAttempts, 0); +}); diff --git a/quality/bugbot/evidence/issue-985/derivation.json b/quality/bugbot/evidence/issue-985/derivation.json new file mode 100644 index 000000000..9b4cae535 --- /dev/null +++ b/quality/bugbot/evidence/issue-985/derivation.json @@ -0,0 +1,16 @@ +{ + "schemaVersion": 1, + "source": "quality/bugbot/corpus.v1.json", + "target": "quality/bugbot/corpus.v2.json", + "sourceSha256": "640c3355aeb65c1b15454bd7f9242fa36acc12b8b3f5ef284ee06af8af36c6c6", + "case": "actions-readonly-metadata", + "field": "diff", + "before": "+on: pull_request\n+permissions:\n+ contents: read\n+steps:\n+ - run: echo '${{ github.event.pull_request.number }}'", + "after": "+on: pull_request\n+permissions:\n+ contents: read\n+jobs:\n+ metadata:\n+ runs-on: ubuntu-latest\n+ steps:\n+ - run: echo '${{ github.event.pull_request.number }}'", + "targetSha256": "001223aa255e5af7e10bddab2c8deacd7cacf0b5b3690a5a2034d241274cb9d6", + "reviewState": "proposed-for-independent-PR-review", + "expected": [], + "historicalScoresRecomputed": false, + "modelCalls": 0, + "evaluatedPrWriteAttempts": 0 +} diff --git a/quality/bugbot/evidence/issue-985/historical-hashes.json b/quality/bugbot/evidence/issue-985/historical-hashes.json new file mode 100644 index 000000000..539d8716c --- /dev/null +++ b/quality/bugbot/evidence/issue-985/historical-hashes.json @@ -0,0 +1,18 @@ +{ + "sourceCommit": "ccefb27627cd627ccdb7d5666fd174c2ac1da07b", + "sha256": { + "quality/bugbot/corpus.v1.json": "640c3355aeb65c1b15454bd7f9242fa36acc12b8b3f5ef284ee06af8af36c6c6", + "quality/bugbot/evidence/issue-950/ev07-shadow/campaign-provenance-attempts.jsonl": "68907c3ddcb72b71f76ea650011408e89f9714577eee33c6a66442e4257ebbf5", + "quality/bugbot/evidence/issue-950/ev07-shadow/campaign-provenance-controls.json": "aec49d3822334d34d4e5b767e2d18feecfb3e4d1204654601339dbabc5c81013", + "quality/bugbot/evidence/issue-950/ev07-shadow/campaign-provenance-slots.jsonl": "7859d234217f908416901755a8326a9d55bd70efed3e06b151fb1e6ed25b9568", + "quality/bugbot/evidence/issue-950/ev07-shadow/campaign-provenance.json": "26a66c3d4c40c5a63fc27f619711e969545050d34deef5e85fc617dce47e693e", + "quality/bugbot/evidence/issue-950/ev07-shadow/corpus-score.json": "fbbb9a2f43532afa2ef12d323a05bd67274b9d98e18a73099bffe6092f902fa9", + "quality/bugbot/evidence/issue-950/ev07-shadow/plan.json": "572dfedf3db3975d9478a16222495b228494e5a3e321eaf1e5d108788edf8235", + "quality/bugbot/evidence/issue-950/manifest.json": "c06e3e15c8cef3f926bc9ac6f5d0c2c5700c151383d8092c21d209e7747a1d51", + "quality/bugbot/evidence/issue-950/normal-flow-shadow/subjects.json": "6d934b947c7b1683ec258c9c1c09629b3a6b495c167b33075ec60f19bb8147cf", + "quality/bugbot/evidence/issue-950/shadow-real-prs/official.json": "bcb60bc3d7bb9c487efcbb2578a18231b9ed1c64945d571c2b2e78d0c057c0d5", + "quality/bugbot/evidence/issue-950/shadow-verification/plan.json": "f90f0077b1139ce5fedce064417f1ed8cdedcdd7a32b5b9aa8494f9a7606ea44", + "quality/bugbot/evidence/issue-950/v4/candidates.json": "c79302cb376519f60d69e0a080cd65dc29ff35ab256ce17b0e4b218fe69e239a", + "quality/bugbot/evidence/issue-950/v4/manifest.json": "dab7d62b0419c2da63eae3387be6222e77c114ed32b22dc9a2a9af35fb6afe85" + } +} diff --git a/specs/CATALOG.md b/specs/CATALOG.md index ab1f8e793..6602a18a1 100644 --- a/specs/CATALOG.md +++ b/specs/CATALOG.md @@ -23,7 +23,7 @@ debt or convert unknown historic intent into a design decision. | `issue-start-and-sdd-readiness` | Implemented | Start every admitted issue with one explicit signal and publish a validated SDD before eligible Action-managed branch work; inspect verified SDD status and bounded structural publication comparisons and preserve complete navigable catalog links for accepted repository filenames and safely publish generated catalogs without following destination links; bootstrap truthful proposed SDK capabilities before implementation without changing readiness; reject incomplete specification discovery explicitly without following unregistered symbolic links; report confirmed missing trusted catalogs with immutable source provenance and prerequisite recovery before model or publication; bind pre-branch analysis and drafting to a verified independent read-only view of the selected immutable source without changing the canonical checkout; distinguish visible protocol notation from repository citations, allow only constructive proposed-file directory ancestry and expose bounded private-safe origin diagnostics; distinguish registered-document updates from new companion and independent capability publication, carrying fresh authorized unpublished ownership context across clarification without changing published ownership fences; ground verification guidance in selected project declarations, preserve exact evidence and independent refinements, and render portable catalog instructions without assuming consumer package scripts; preserve admitted explicit case identities and derive declared-target navigation before unchanged native validation; assemble bounded SDD units, validate optional maintainer drafts, and bind companion recovery to immutable ownership and publication evidence | [Uniform issue start and pre-branch SDD readiness](./issue-start-and-branch-readiness.md) + 9 companion | 195 paths · 2026-11-08 | | `managed-issue-lifecycle` | As-built baseline | Convert typed issues into traceable work branches, project state, and lifecycle state | [Managed issue and branch lifecycle](./managed-issue-and-branch-lifecycle.md) + 2 companion | 109 paths · 2026-11-06 | | `comment-automation` | Implemented | Admit only explicit commands or exact mentions, then route them while protecting repository mutations | [Comment automation and authorization](./comment-automation-and-authorization.md) | 88 paths · 2026-10-26 | -| `bugbot-analysis-and-autofix` | Implemented | Select one canonical PR, exhaustively analyze bounded diff partitions with version-grounded dependency, policy-to-request transformation and source-bound assertion and generated-source coordinates with independent candidate verification, configuration-selected initial-session credential ownership, delegated test-path and external Action input-contract, host-aware self-repository references and Kotlin/Wasm lexical-binding and renderer-grounded Markdown path evidence, publish stable findings atomically, and apply authorized verified fixes with regression coverage for cwd/pattern-grounded indirect unittest discovery and source-bound module execution evidence, with active-instance Kotlin Json nullable-input policy grounding; verify complete large diffs through a source-bound closed framed profile with immutable local Git proof, live-base freshness and atomic global publication; ground Python exception syntax in declared interpreter versions and PEP 758 while preserving older-target and independent runtime defects; ground filesystem recovery findings in retention/no-overwrite, ownership and publication contracts while preserving required disposable cleanup and data-loss defects; independently adjudicate candidates for supplied Python source, retaining existing bounded source, identity and history controls; trace concrete helper defaults/overrides, database-file parent containment and stored query values before judging assertions, preserving exact fragment coordinates and genuine assertion failures; co-deliver complete long discussion to every source-bound partition within closed native prompt and invocation traffic limits, preserving provenance and truthful provider partial coverage; verify actual resource content, source binding, human authority and intended entry availability before reporting an authentication defect; ground asynchronous findings in complete statements, actual receiver/cycle/caller and reached lifecycle effects, preserving genuine unfinished updates and omitting disproved claims JSON boundary evidence follows producer/decoder/transform/reader values and Python identity-cast semantics; paired source-bound controls preserve actual serialization failures without consumer-specific suppression. Native completed JSON/schema and host candidate-proof failures retain content-free closed reasons through the original three-attempt partition bound; provider/process and historical unknown failures remain distinct. | [Bugbot analysis, finding publication, and autofix](./bugbot-analysis-publication-and-autofix.md) + 10 companion | 279 paths · 2026-11-19 | +| `bugbot-analysis-and-autofix` | Implemented | Select one canonical PR, exhaustively analyze bounded diff partitions with version-grounded dependency, policy-to-request transformation and source-bound assertion and generated-source coordinates with independent candidate verification, configuration-selected initial-session credential ownership, delegated test-path and external Action input-contract, host-aware self-repository references and Kotlin/Wasm lexical-binding and renderer-grounded Markdown path evidence, publish stable findings atomically, and apply authorized verified fixes with regression coverage for cwd/pattern-grounded indirect unittest discovery and source-bound module execution evidence, with active-instance Kotlin Json nullable-input policy grounding; verify complete large diffs through a source-bound closed framed profile with immutable local Git proof, live-base freshness and atomic global publication; ground Python exception syntax in declared interpreter versions and PEP 758 while preserving older-target and independent runtime defects; ground filesystem recovery findings in retention/no-overwrite, ownership and publication contracts while preserving required disposable cleanup and data-loss defects; independently adjudicate candidates for supplied Python source, retaining existing bounded source, identity and history controls; trace concrete helper defaults/overrides, database-file parent containment and stored query values before judging assertions, preserving exact fragment coordinates and genuine assertion failures; co-deliver complete long discussion to every source-bound partition within closed native prompt and invocation traffic limits, preserving provenance and truthful provider partial coverage; verify actual resource content, source binding, human authority and intended entry availability before reporting an authentication defect; ground asynchronous findings in complete statements, actual receiver/cycle/caller and reached lifecycle effects, preserving genuine unfinished updates and omitting disproved claims JSON boundary evidence follows producer/decoder/transform/reader values and Python identity-cast semantics; paired source-bound controls preserve actual serialization failures without consumer-specific suppression. Native completed JSON/schema and host candidate-proof failures retain content-free closed reasons through the original three-attempt partition bound; provider/process and historical unknown failures remain distinct. | [Bugbot analysis, finding publication, and autofix](./bugbot-analysis-publication-and-autofix.md) + 10 companion | 284 paths · 2026-11-19 | | `branch-synchronization` | Implemented | Observe parent drift with one localized status card and transition-only notifications, then safely merge a parent branch into a linked working branch | [Branch synchronization and conflict recovery](./branch-synchronization-and-conflict-recovery.md) + 3 companion | 163 paths · 2026-11-08 | | `pull-request-lifecycle` | Implemented | Enrich linked and unlinked pull requests with safe issue linkage, metadata, concise descriptions preserving validated closing intent, and distinct workflow evidence | [Pull request lifecycle and enrichment](./pull-request-lifecycle-and-enrichment.md) | 98 paths · 2026-10-30 | | `agent-runtime` | Implemented | Resolve, provision, authenticate, authorize, and execute only the agent roles reachable by a run, with provider-compatible native schemas and exact local acceptance | [Agent runtime, provider, model, and role routing](./agent-runtime-provider-and-model-routing.md) + 1 companion | 116 paths · 2026-11-07 | @@ -185,9 +185,9 @@ debt or convert unknown historic intent into a design decision. - Specifications: [`specs/bugbot-analysis-publication-and-autofix.md`](./bugbot-analysis-publication-and-autofix.md) · [`specs/bugbot-context-selection-and-budgeting.md`](./bugbot-context-selection-and-budgeting.md) · [`specs/bugbot-exhaustive-partitioned-analysis.md`](./bugbot-exhaustive-partitioned-analysis.md) · [`specs/bugbot-lossless-conversation-context.md`](./bugbot-lossless-conversation-context.md) · [`specs/bugbot-source-bound-framed-review.md`](./bugbot-source-bound-framed-review.md) · [`specs/bugbot-recovery-contract-grounding.md`](./bugbot-recovery-contract-grounding.md) · [`specs/bugbot-fixture-value-grounding.md`](./bugbot-fixture-value-grounding.md) · [`specs/bugbot-complete-conversation-review.md`](./bugbot-complete-conversation-review.md) · [`specs/bugbot-resource-authority-evidence.md`](./bugbot-resource-authority-evidence.md) · [`specs/bugbot-async-statement-evidence.md`](./bugbot-async-statement-evidence.md) · [`specs/bugbot-json-value-grounding.md`](./bugbot-json-value-grounding.md) - Workflows: [`.github/workflows/copilot_commit.yml`](../.github/workflows/copilot_commit.yml) · [`.github/workflows/copilot_pull_request.yml`](../.github/workflows/copilot_pull_request.yml) · [`.github/workflows/copilot_pull_request_comment.yml`](../.github/workflows/copilot_pull_request_comment.yml) - Entrypoints: [`src/application/usecases/steps/commit/detect_potential_problems_use_case.ts`](../src/application/usecases/steps/commit/detect_potential_problems_use_case.ts) · [`src/application/ports/bugbot_shadow_verification_ports.ts`](../src/application/ports/bugbot_shadow_verification_ports.ts) · [`src/application/usecases/steps/commit/bugbot/observe_bugbot_shadow_verification.ts`](../src/application/usecases/steps/commit/bugbot/observe_bugbot_shadow_verification.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_autofix_use_case.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_autofix_use_case.ts) -- Core code: [`src/application/policies/bugbot_shadow_configuration_policy.ts`](../src/application/policies/bugbot_shadow_configuration_policy.ts) · [`src/infrastructure/bugbot/installed_bugbot_shadow_adapter.ts`](../src/infrastructure/bugbot/installed_bugbot_shadow_adapter.ts) · [`src/infrastructure/bugbot/native_review_cancellation_adapter.ts`](../src/infrastructure/bugbot/native_review_cancellation_adapter.ts) · [`src/infrastructure/bugbot/shadow/installed_official.cjs`](../src/infrastructure/bugbot/shadow/installed_official.cjs) · [`src/infrastructure/bugbot/verifier_model_catalog.ts`](../src/infrastructure/bugbot/verifier_model_catalog.ts) · [`src/application/policies/bugbot_evidence_reference_policy.cjs`](../src/application/policies/bugbot_evidence_reference_policy.cjs) · [`src/application/policies/bugbot_material_dependency_policy.cjs`](../src/application/policies/bugbot_material_dependency_policy.cjs) · [`src/application/usecases/steps/commit/bugbot/bugbot_candidate_trace.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_candidate_trace.ts) · [`src/application/usecases/steps/commit/bugbot/investigate_bugbot_shadow.cjs`](../src/application/usecases/steps/commit/bugbot/investigate_bugbot_shadow.cjs) · [`src/infrastructure/bugbot/shadow/source_cache.cjs`](../src/infrastructure/bugbot/shadow/source_cache.cjs) · [`src/infrastructure/bugbot/shadow_verification_adapter.ts`](../src/infrastructure/bugbot/shadow_verification_adapter.ts) · [`src/infrastructure/bugbot/shadow/broker.cjs`](../src/infrastructure/bugbot/shadow/broker.cjs) · [`src/infrastructure/bugbot/shadow/run.cjs`](../src/infrastructure/bugbot/shadow/run.cjs) · [`src/infrastructure/bugbot/shadow/prompt.cjs`](../src/infrastructure/bugbot/shadow/prompt.cjs) · [`src/infrastructure/bugbot/shadow/schema.cjs`](../src/infrastructure/bugbot/shadow/schema.cjs) · [`src/infrastructure/bugbot/shadow/session.cjs`](../src/infrastructure/bugbot/shadow/session.cjs) · [`src/infrastructure/composition/bugbot_review_composition.ts`](../src/infrastructure/composition/bugbot_review_composition.ts) · [`src/application/ports/bugbot_context_ports.ts`](../src/application/ports/bugbot_context_ports.ts) · [`src/data/repository/pull_request/pull_request_changes_repository.ts`](../src/data/repository/pull_request/pull_request_changes_repository.ts) · [`src/domain/bugbot/context.ts`](../src/domain/bugbot/context.ts) · [`src/domain/bugbot/finding.ts`](../src/domain/bugbot/finding.ts) · [`src/domain/bugbot/finding_identity.ts`](../src/domain/bugbot/finding_identity.ts) · [`src/domain/bugbot/review_configuration.ts`](../src/domain/bugbot/review_configuration.ts) · [`src/application/policies/bounded_concurrency_policy.ts`](../src/application/policies/bounded_concurrency_policy.ts) · [`src/application/policies/bugbot_resolution_eligibility_policy.ts`](../src/application/policies/bugbot_resolution_eligibility_policy.ts) · [`src/application/policies/bugbot_result_finding_state_projection_policy.ts`](../src/application/policies/bugbot_result_finding_state_projection_policy.ts) · [`src/application/policies/bugbot_telemetry_projection_policy.ts`](../src/application/policies/bugbot_telemetry_projection_policy.ts) · [`src/application/policies/bugbot_diff_partition_policy.ts`](../src/application/policies/bugbot_diff_partition_policy.ts) · [`src/application/policies/bugbot_conversation_packing_policy.ts`](../src/application/policies/bugbot_conversation_packing_policy.ts) · [`src/application/policies/bugbot_partition_completion_policy.ts`](../src/application/policies/bugbot_partition_completion_policy.ts) · [`src/application/policies/action_summary_policy.ts`](../src/application/policies/action_summary_policy.ts) · [`src/application/policies/copilot_evidence_policy.ts`](../src/application/policies/copilot_evidence_policy.ts) · [`src/application/ports/bugbot_git_ports.ts`](../src/application/ports/bugbot_git_ports.ts) · [`src/application/ports/bugbot_reconciliation_ports.ts`](../src/application/ports/bugbot_reconciliation_ports.ts) · [`src/application/ports/bugbot_scm_ports.ts`](../src/application/ports/bugbot_scm_ports.ts) · [`src/application/usecases/steps/commit/bugbot/schema.ts`](../src/application/usecases/steps/commit/bugbot/schema.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_operation_context.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_operation_context.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_context_request.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_context_request.ts) · [`src/application/usecases/steps/commit/bugbot/prepare_bugbot_findings_policy.ts`](../src/application/usecases/steps/commit/bugbot/prepare_bugbot_findings_policy.ts) · [`src/application/usecases/steps/commit/bugbot/analyze_bugbot_revision_use_case.ts`](../src/application/usecases/steps/commit/bugbot/analyze_bugbot_revision_use_case.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_partition_aggregation.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_partition_aggregation.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_context.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_context.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_telemetry.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_telemetry.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_progress.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_progress.ts) · [`src/application/ports/bugbot_review_progress_ports.ts`](../src/application/ports/bugbot_review_progress_ports.ts) · [`src/application/ports/bugbot_review_cancellation_ports.ts`](../src/application/ports/bugbot_review_cancellation_ports.ts) · [`src/application/policies/bugbot_live_progress_presentation_policy.ts`](../src/application/policies/bugbot_live_progress_presentation_policy.ts) · [`src/infrastructure/composition/bugbot_review_progress_composition_root.ts`](../src/infrastructure/composition/bugbot_review_progress_composition_root.ts) · [`src/infrastructure/github/github_bugbot_review_progress_adapter.ts`](../src/infrastructure/github/github_bugbot_review_progress_adapter.ts) · [`src/application/usecases/steps/commit/bugbot/build_bugbot_prompt.ts`](../src/application/usecases/steps/commit/bugbot/build_bugbot_prompt.ts) · [`src/application/usecases/steps/commit/bugbot/load_bugbot_context_use_case.ts`](../src/application/usecases/steps/commit/bugbot/load_bugbot_context_use_case.ts) · [`src/application/usecases/steps/commit/bugbot/query_bugbot_findings.ts`](../src/application/usecases/steps/commit/bugbot/query_bugbot_findings.ts) · [`src/prompts/bugbot.ts`](../src/prompts/bugbot.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_previous_findings_context.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_previous_findings_context.ts) · [`src/application/usecases/steps/commit/bugbot/publish_findings_use_case.ts`](../src/application/usecases/steps/commit/bugbot/publish_findings_use_case.ts) · [`src/application/usecases/steps/commit/workspace_mutation_guard.ts`](../src/application/usecases/steps/commit/workspace_mutation_guard.ts) · [`src/data/repository/issue/bugbot_issue_comment_query_repository.ts`](../src/data/repository/issue/bugbot_issue_comment_query_repository.ts) · [`src/infrastructure/bound_bugbot_git_mutation_adapter.ts`](../src/infrastructure/bound_bugbot_git_mutation_adapter.ts) · [`src/infrastructure/composition/bugbot_scm_port_factory.ts`](../src/infrastructure/composition/bugbot_scm_port_factory.ts) · [`src/infrastructure/composition/bugbot_composition_root.ts`](../src/infrastructure/composition/bugbot_composition_root.ts) · [`scripts/coverage-budgets.json`](../scripts/coverage-budgets.json) · [`scripts/validate-coverage-budgets.cjs`](../scripts/validate-coverage-budgets.cjs) · [`src/application/usecases/comment_automation_action_workflow.ts`](../src/application/usecases/comment_automation_action_workflow.ts) · [`src/data/repository/pull_request/pull_request_lifecycle_repository.ts`](../src/data/repository/pull_request/pull_request_lifecycle_repository.ts) · [`src/application/usecases/comment_automation_command_workflow.ts`](../src/application/usecases/comment_automation_command_workflow.ts) · [`src/domain/copilot_command.ts`](../src/domain/copilot_command.ts) · [`src/application/usecases/comment_automation_contracts.ts`](../src/application/usecases/comment_automation_contracts.ts) · [`src/application/usecases/issue_comment_use_case.ts`](../src/application/usecases/issue_comment_use_case.ts) · [`src/application/usecases/pull_request_review_comment_use_case.ts`](../src/application/usecases/pull_request_review_comment_use_case.ts) · [`src/infrastructure/composition/main_run_route_composition_root.ts`](../src/infrastructure/composition/main_run_route_composition_root.ts) · [`src/infrastructure/github/ports/github_pull_request_provider_ports.ts`](../src/infrastructure/github/ports/github_pull_request_provider_ports.ts) · [`src/application/usecases/steps/commit/bugbot/dismiss_bugbot_findings_use_case.ts`](../src/application/usecases/steps/commit/bugbot/dismiss_bugbot_findings_use_case.ts) · [`src/application/policies/semantic_result_publication_policy.ts`](../src/application/policies/semantic_result_publication_policy.ts) · [`src/application/policies/publication_message_catalog.ts`](../src/application/policies/publication_message_catalog.ts) · [`src/application/usecases/steps/commit/bugbot/detect_bugbot_fix_intent_workflow.ts`](../src/application/usecases/steps/commit/bugbot/detect_bugbot_fix_intent_workflow.ts) · [`src/application/usecases/comment_automation_use_case.ts`](../src/application/usecases/comment_automation_use_case.ts) · [`src/infrastructure/filesystem/workspace_bugbot_rules_repository.ts`](../src/infrastructure/filesystem/workspace_bugbot_rules_repository.ts) · [`src/application/usecases/steps/commit/git_branch_checkout.ts`](../src/application/usecases/steps/commit/git_branch_checkout.ts) · [`src/application/usecases/steps/commit/bugbot/commit_and_push_preflight.ts`](../src/application/usecases/steps/commit/bugbot/commit_and_push_preflight.ts) · [`src/application/usecases/steps/commit/bugbot/commit_and_push_workflow.ts`](../src/application/usecases/steps/commit/bugbot/commit_and_push_workflow.ts) · [`quality/bugbot/corpus.v1.json`](../quality/bugbot/corpus.v1.json) · [`quality/bugbot/reference-predictions.v1.json`](../quality/bugbot/reference-predictions.v1.json) · [`src/tooling/bugbot_benchmark_runner.ts`](../src/tooling/bugbot_benchmark_runner.ts) · [`quality/bugbot/compose-720-observations.v1.json`](../quality/bugbot/compose-720-observations.v1.json) · [`quality/bugbot/evidence/issue-722.json`](../quality/bugbot/evidence/issue-722.json) · [`quality/bugbot/evidence/issue-736.json`](../quality/bugbot/evidence/issue-736.json) · [`quality/bugbot/evidence/issue-738.json`](../quality/bugbot/evidence/issue-738.json) · [`quality/bugbot/evidence/issue-739.json`](../quality/bugbot/evidence/issue-739.json) · [`quality/bugbot/evidence/issue-749.json`](../quality/bugbot/evidence/issue-749.json) · [`quality/bugbot/evidence/issue-770.json`](../quality/bugbot/evidence/issue-770.json) · [`src/application/policies/bugbot_python_literal_witness_policy.ts`](../src/application/policies/bugbot_python_literal_witness_policy.ts) · [`src/application/policies/bugbot_literal_verification_policy.ts`](../src/application/policies/bugbot_literal_verification_policy.ts) · [`src/application/usecases/steps/commit/bugbot/verify_generated_literal_findings.ts`](../src/application/usecases/steps/commit/bugbot/verify_generated_literal_findings.ts) · [`src/application/policies/agent_output_locale_policy.ts`](../src/application/policies/agent_output_locale_policy.ts) · [`src/domain/bugbot/framed_review.ts`](../src/domain/bugbot/framed_review.ts) · [`src/application/policies/bugbot_framed_identity_policy.ts`](../src/application/policies/bugbot_framed_identity_policy.ts) · [`src/application/policies/bugbot_framed_receipt_policy.ts`](../src/application/policies/bugbot_framed_receipt_policy.ts) · [`src/application/policies/bugbot_framed_snapshot_policy.ts`](../src/application/policies/bugbot_framed_snapshot_policy.ts) · [`src/application/policies/bugbot_framed_review_policy.ts`](../src/application/policies/bugbot_framed_review_policy.ts) · [`src/application/policies/bugbot_patch_binding_policy.ts`](../src/application/policies/bugbot_patch_binding_policy.ts) · [`src/application/policies/bugbot_review_diagnostic_labels.ts`](../src/application/policies/bugbot_review_diagnostic_labels.ts) · [`src/application/ports/bugbot_review_source_ports.ts`](../src/application/ports/bugbot_review_source_ports.ts) · [`src/application/ports/bugbot_telemetry_ports.ts`](../src/application/ports/bugbot_telemetry_ports.ts) · [`src/infrastructure/filesystem/bugbot_git_review_source_adapter.ts`](../src/infrastructure/filesystem/bugbot_git_review_source_adapter.ts) · [`src/application/usecases/steps/commit/bugbot/analyze_bugbot_frames.ts`](../src/application/usecases/steps/commit/bugbot/analyze_bugbot_frames.ts) · [`src/application/policies/bugbot_framed_prompt_policy.ts`](../src/application/policies/bugbot_framed_prompt_policy.ts) · [`quality/bugbot/evidence/issue-831.json`](../quality/bugbot/evidence/issue-831.json) · [`quality/bugbot/evidence/issue-832.json`](../quality/bugbot/evidence/issue-832.json) · [`quality/bugbot/evidence/issue-834.json`](../quality/bugbot/evidence/issue-834.json) · [`src/application/policies/bugbot_complete_conversation_policy.ts`](../src/application/policies/bugbot_complete_conversation_policy.ts) · [`src/prompts/fill.ts`](../src/prompts/fill.ts) · [`quality/bugbot/evidence/issue-843.json`](../quality/bugbot/evidence/issue-843.json) · [`src/prompts/bugbot_resource_authority.ts`](../src/prompts/bugbot_resource_authority.ts) · [`quality/bugbot/resource-authority-corpus.v1.json`](../quality/bugbot/resource-authority-corpus.v1.json) · [`quality/bugbot/evidence/issue-847.json`](../quality/bugbot/evidence/issue-847.json) · [`.gitattributes`](../.gitattributes) · [`src/prompts/bugbot_async_statement_evidence.ts`](../src/prompts/bugbot_async_statement_evidence.ts) · [`quality/bugbot/async-statement-corpus.v1.json`](../quality/bugbot/async-statement-corpus.v1.json) · [`quality/bugbot/evidence/issue-848.json`](../quality/bugbot/evidence/issue-848.json) · [`eslint.config.mjs`](../eslint.config.mjs) · [`src/prompts/bugbot_json_value_evidence.ts`](../src/prompts/bugbot_json_value_evidence.ts) · [`quality/bugbot/json-value-corpus.v1.json`](../quality/bugbot/json-value-corpus.v1.json) · [`quality/bugbot/evidence/issue-855.json`](../quality/bugbot/evidence/issue-855.json) · [`src/domain/bugbot/response_failure.ts`](../src/domain/bugbot/response_failure.ts) · [`src/data/repository/agent_findings_response_policy.ts`](../src/data/repository/agent_findings_response_policy.ts) · [`src/data/model/application_error.ts`](../src/data/model/application_error.ts) · [`src/application/policies/application_error_message_catalog.ts`](../src/application/policies/application_error_message_catalog.ts) · [`src/application/errors/bugbot_verification_response_failure.ts`](../src/application/errors/bugbot_verification_response_failure.ts) · [`src/domain/bugbot/review_freshness_failure.ts`](../src/domain/bugbot/review_freshness_failure.ts) · [`src/application/errors/bugbot_freshness_error.ts`](../src/application/errors/bugbot_freshness_error.ts) · [`src/application/policies/pull_request_review_provider_code_policy.ts`](../src/application/policies/pull_request_review_provider_code_policy.ts) · [`src/application/ports/pull_request_review_errors.ts`](../src/application/ports/pull_request_review_errors.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_freshness.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_freshness.ts) · [`src/application/usecases/steps/commit/bugbot/verify_bugbot_publication_policy.ts`](../src/application/usecases/steps/commit/bugbot/verify_bugbot_publication_policy.ts) · [`src/application/policies/bugbot_mutation_cancellation_policy.ts`](../src/application/policies/bugbot_mutation_cancellation_policy.ts) -- Tests: [`src/application/policies/__tests__/bugbot_shadow_configuration_policy.test.ts`](../src/application/policies/__tests__/bugbot_shadow_configuration_policy.test.ts) · [`src/data/repository/__tests__/pull_request_changes_repository.test.ts`](../src/data/repository/__tests__/pull_request_changes_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/bugbot_review_lifecycle.e2e.test.ts`](../src/application/usecases/steps/commit/__tests__/bugbot_review_lifecycle.e2e.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_operation_context.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_operation_context.test.ts) · [`src/application/policies/__tests__/bugbot_partition_completion_policy.test.ts`](../src/application/policies/__tests__/bugbot_partition_completion_policy.test.ts) · [`src/application/policies/__tests__/bugbot_conversation_packing_policy.test.ts`](../src/application/policies/__tests__/bugbot_conversation_packing_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_revision_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_revision_use_case.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_aggregation.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_aggregation.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_context_request.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_context_request.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/load_bugbot_context_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/load_bugbot_context_use_case.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/schema.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/schema.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/prepare_bugbot_findings.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/prepare_bugbot_findings.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_context.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_context.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/query_bugbot_findings.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/query_bugbot_findings.test.ts) · [`src/domain/bugbot/__tests__/context.test.ts`](../src/domain/bugbot/__tests__/context.test.ts) · [`src/data/repository/issue/__tests__/bugbot_issue_comment_query_repository.test.ts`](../src/data/repository/issue/__tests__/bugbot_issue_comment_query_repository.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/publish_findings_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/publish_findings_use_case.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_autofix_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_autofix_use_case.test.ts) · [`src/application/ports/__tests__/bugbot_port_boundaries.test.ts`](../src/application/ports/__tests__/bugbot_port_boundaries.test.ts) · [`src/infrastructure/composition/__tests__/bugbot_scm_port_factory.test.ts`](../src/infrastructure/composition/__tests__/bugbot_scm_port_factory.test.ts) · [`src/__tests__/api.test.ts`](../src/__tests__/api.test.ts) · [`src/domain/bugbot/__tests__/finding_identity.test.ts`](../src/domain/bugbot/__tests__/finding_identity.test.ts) · [`src/application/policies/__tests__/bugbot_result_finding_state_projection_policy.test.ts`](../src/application/policies/__tests__/bugbot_result_finding_state_projection_policy.test.ts) · [`src/application/policies/__tests__/bugbot_telemetry_projection_policy.test.ts`](../src/application/policies/__tests__/bugbot_telemetry_projection_policy.test.ts) · [`src/application/policies/__tests__/action_summary_policy.test.ts`](../src/application/policies/__tests__/action_summary_policy.test.ts) · [`src/application/policies/__tests__/copilot_evidence_policy.test.ts`](../src/application/policies/__tests__/copilot_evidence_policy.test.ts) · [`src/actions/__tests__/github_action_completion.test.ts`](../src/actions/__tests__/github_action_completion.test.ts) · [`src/tooling/__tests__/validate_workflow_contract.test.ts`](../src/tooling/__tests__/validate_workflow_contract.test.ts) · [`src/application/usecases/__tests__/comment_automation_action_workflow.test.ts`](../src/application/usecases/__tests__/comment_automation_action_workflow.test.ts) · [`src/data/repository/__tests__/pull_request_lifecycle_repository.test.ts`](../src/data/repository/__tests__/pull_request_lifecycle_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/detect_potential_problems_use_case.test.ts`](../src/application/usecases/steps/commit/__tests__/detect_potential_problems_use_case.test.ts) · [`src/application/usecases/__tests__/comment_automation_use_case.test.ts`](../src/application/usecases/__tests__/comment_automation_use_case.test.ts) · [`src/domain/__tests__/copilot_command.test.ts`](../src/domain/__tests__/copilot_command.test.ts) · [`src/infrastructure/composition/__tests__/main_run_route_composition_root.test.ts`](../src/infrastructure/composition/__tests__/main_run_route_composition_root.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/dismiss_bugbot_findings_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/dismiss_bugbot_findings_use_case.test.ts) · [`src/application/policies/__tests__/semantic_result_publication_policy.test.ts`](../src/application/policies/__tests__/semantic_result_publication_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/detect_bugbot_fix_intent_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/detect_bugbot_fix_intent_use_case.test.ts) · [`src/infrastructure/filesystem/__tests__/workspace_bugbot_rules_repository.test.ts`](../src/infrastructure/filesystem/__tests__/workspace_bugbot_rules_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/git_branch_checkout.integration.test.ts`](../src/application/usecases/steps/commit/__tests__/git_branch_checkout.integration.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/workspace_changes.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/workspace_changes.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/commit_verification_workspace.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/commit_verification_workspace.test.ts) · [`src/application/usecases/__tests__/autofix_conversation_branch_authority.test.ts`](../src/application/usecases/__tests__/autofix_conversation_branch_authority.test.ts) · [`src/tooling/__tests__/bugbot_benchmark.test.ts`](../src/tooling/__tests__/bugbot_benchmark.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_call_path_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_call_path_oracles.ts) · [`src/tooling/__tests__/bugbot_benchmark_runner.test.ts`](../src/tooling/__tests__/bugbot_benchmark_runner.test.ts) · [`src/prompts/__tests__/bugbot.test.ts`](../src/prompts/__tests__/bugbot.test.ts) · [`src/prompts/__tests__/bugbot_framework_semantics.test.ts`](../src/prompts/__tests__/bugbot_framework_semantics.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_validation_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_validation_oracles.ts) · [`src/tooling/__tests__/fixtures/bugbot_validation_functions.ts`](../src/tooling/__tests__/fixtures/bugbot_validation_functions.ts) · [`src/tooling/__tests__/fixtures/bugbot_markdown_link_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_markdown_link_oracles.ts) · [`quality/bugbot/evidence/issue-772.json`](../quality/bugbot/evidence/issue-772.json) · [`src/tooling/__tests__/bugbot_request_transform_evidence.test.ts`](../src/tooling/__tests__/bugbot_request_transform_evidence.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_request_transform_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_request_transform_oracles.ts) · [`quality/bugbot/evidence/issue-784.json`](../quality/bugbot/evidence/issue-784.json) · [`src/tooling/__tests__/fixtures/bugbot_generated_coordinate_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_generated_coordinate_oracles.ts) · [`src/tooling/__tests__/bugbot_generated_coordinate_evidence.test.ts`](../src/tooling/__tests__/bugbot_generated_coordinate_evidence.test.ts) · [`src/application/policies/__tests__/bugbot_python_literal_witness_policy.test.ts`](../src/application/policies/__tests__/bugbot_python_literal_witness_policy.test.ts) · [`src/application/policies/__tests__/bugbot_literal_verification_policy.test.ts`](../src/application/policies/__tests__/bugbot_literal_verification_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/verify_generated_literal_findings.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/verify_generated_literal_findings.test.ts) · [`quality/bugbot/evidence/issue-796.json`](../quality/bugbot/evidence/issue-796.json) · [`src/tooling/__tests__/fixtures/bugbot_initial_session_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_initial_session_oracles.ts) · [`src/tooling/__tests__/bugbot_initial_session_evidence.test.ts`](../src/tooling/__tests__/bugbot_initial_session_evidence.test.ts) · [`quality/bugbot/evidence/issue-798.json`](../quality/bugbot/evidence/issue-798.json) · [`src/tooling/__tests__/bugbot_unittest_discovery.test.ts`](../src/tooling/__tests__/bugbot_unittest_discovery.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_unittest_discovery_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_unittest_discovery_oracles.ts) · [`quality/bugbot/evidence/issue-806.json`](../quality/bugbot/evidence/issue-806.json) · [`src/tooling/__tests__/fixtures/bugbot_unittest_discovery_probe.py`](../src/tooling/__tests__/fixtures/bugbot_unittest_discovery_probe.py) · [`src/tooling/__tests__/bugbot_kotlin_json.test.ts`](../src/tooling/__tests__/bugbot_kotlin_json.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_kotlin_json_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_kotlin_json_oracles.ts) · [`src/tooling/__tests__/fixtures/bugbot_kotlin_json_probe.kt`](../src/tooling/__tests__/fixtures/bugbot_kotlin_json_probe.kt) · [`quality/bugbot/evidence/issue-807.json`](../quality/bugbot/evidence/issue-807.json) · [`src/tooling/__tests__/bugbot_ktor_routing.test.ts`](../src/tooling/__tests__/bugbot_ktor_routing.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_ktor_routing_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_ktor_routing_oracles.ts) · [`quality/bugbot/evidence/issue-809.json`](../quality/bugbot/evidence/issue-809.json) · [`src/domain/bugbot/__tests__/framed_review.test.ts`](../src/domain/bugbot/__tests__/framed_review.test.ts) · [`src/application/policies/__tests__/bugbot_framed_review_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_review_policy.test.ts) · [`src/application/policies/__tests__/bugbot_framed_identity_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_identity_policy.test.ts) · [`src/application/policies/__tests__/bugbot_patch_binding_policy.test.ts`](../src/application/policies/__tests__/bugbot_patch_binding_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_frames.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_frames.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_progress.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_progress.test.ts) · [`src/infrastructure/github/__tests__/github_bugbot_review_progress_adapter.test.ts`](../src/infrastructure/github/__tests__/github_bugbot_review_progress_adapter.test.ts) · [`src/infrastructure/filesystem/__tests__/bugbot_git_review_source_adapter.test.ts`](../src/infrastructure/filesystem/__tests__/bugbot_git_review_source_adapter.test.ts) · [`src/data/repository/__tests__/bugbot_source_bound_identity_repository.test.ts`](../src/data/repository/__tests__/bugbot_source_bound_identity_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/bugbot_framed_complete_review.integration.test.ts`](../src/application/usecases/steps/commit/__tests__/bugbot_framed_complete_review.integration.test.ts) · [`src/application/policies/__tests__/bugbot_framed_snapshot_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_snapshot_policy.test.ts) · [`src/application/policies/__tests__/bugbot_framed_prompt_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_prompt_policy.test.ts) · [`src/tooling/__tests__/bugbot_python_exception_syntax.test.ts`](../src/tooling/__tests__/bugbot_python_exception_syntax.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_python_exception_parse_probe.py`](../src/tooling/__tests__/fixtures/bugbot_python_exception_parse_probe.py) · [`src/tooling/__tests__/fixtures/bugbot_python_314_catch_probe.py`](../src/tooling/__tests__/fixtures/bugbot_python_314_catch_probe.py) · [`src/tooling/__tests__/bugbot_recovery_contract.test.ts`](../src/tooling/__tests__/bugbot_recovery_contract.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_recovery_contract_probe.py`](../src/tooling/__tests__/fixtures/bugbot_recovery_contract_probe.py) · [`src/tooling/__tests__/bugbot_fixture_values.test.ts`](../src/tooling/__tests__/bugbot_fixture_values.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_fixture_values_probe.py`](../src/tooling/__tests__/fixtures/bugbot_fixture_values_probe.py) · [`src/tooling/__tests__/bugbot_fixture_identity.test.ts`](../src/tooling/__tests__/bugbot_fixture_identity.test.ts) · [`src/application/policies/__tests__/bugbot_complete_conversation_policy.test.ts`](../src/application/policies/__tests__/bugbot_complete_conversation_policy.test.ts) · [`src/prompts/__tests__/bugbot_complete_conversation.test.ts`](../src/prompts/__tests__/bugbot_complete_conversation.test.ts) · [`src/application/usecases/steps/commit/__tests__/bugbot_complete_conversation.integration.test.ts`](../src/application/usecases/steps/commit/__tests__/bugbot_complete_conversation.integration.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_long_conversation_fixture.ts`](../src/tooling/__tests__/fixtures/bugbot_long_conversation_fixture.ts) · [`src/tooling/__tests__/bugbot_resource_authority.test.ts`](../src/tooling/__tests__/bugbot_resource_authority.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_resource_boundary_probe.py`](../src/tooling/__tests__/fixtures/bugbot_resource_boundary_probe.py) · [`src/tooling/__tests__/bugbot_async_statements.test.ts`](../src/tooling/__tests__/bugbot_async_statements.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_async_statement_probe.mjs`](../src/tooling/__tests__/fixtures/bugbot_async_statement_probe.mjs) · [`src/tooling/__tests__/fixtures/bugbot_async_statement_runner.mjs`](../src/tooling/__tests__/fixtures/bugbot_async_statement_runner.mjs) · [`src/tooling/__tests__/bugbot_json_values.test.ts`](../src/tooling/__tests__/bugbot_json_values.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_json_value_probe.py`](../src/tooling/__tests__/fixtures/bugbot_json_value_probe.py) · [`src/tooling/__tests__/fixtures/bugbot_json_value_runner.py`](../src/tooling/__tests__/fixtures/bugbot_json_value_runner.py) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_query_diagnostics.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_query_diagnostics.test.ts) · [`src/application/policies/__tests__/bugbot_freshness_diagnostics.test.ts`](../src/application/policies/__tests__/bugbot_freshness_diagnostics.test.ts) · [`quality/bugbot/evidence/issue-950/ev07-shadow/launch-full-review.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/launch-full-review.test.cjs) · [`quality/bugbot/evidence/issue-950/ev07-shadow/review-runtime.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/review-runtime.test.cjs) · [`quality/bugbot/evidence/issue-950/ev07-shadow/score-review.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/score-review.test.cjs) · [`quality/bugbot/evidence/issue-950/normal-flow-shadow/paths.test.cjs`](../quality/bugbot/evidence/issue-950/normal-flow-shadow/paths.test.cjs) · [`quality/bugbot/evidence/issue-950/shadow-verification/verification.test.cjs`](../quality/bugbot/evidence/issue-950/shadow-verification/verification.test.cjs) · [`src/infrastructure/bugbot/__tests__/shadow_verification_adapter.test.ts`](../src/infrastructure/bugbot/__tests__/shadow_verification_adapter.test.ts) · [`src/infrastructure/bugbot/__tests__/native_review_cancellation_adapter.test.ts`](../src/infrastructure/bugbot/__tests__/native_review_cancellation_adapter.test.ts) · [`src/infrastructure/bugbot/__tests__/installed_bugbot_official.test.ts`](../src/infrastructure/bugbot/__tests__/installed_bugbot_official.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/verify_bugbot_publication_paths.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/verify_bugbot_publication_paths.test.ts) · [`quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs) · [`src/application/policies/__tests__/bugbot_mutation_cancellation_policy.test.ts`](../src/application/policies/__tests__/bugbot_mutation_cancellation_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/observe_bugbot_base.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/observe_bugbot_base.test.ts) -- User documentation: [`docs/bugbot/how-it-works.mdx`](../docs/bugbot/how-it-works.mdx) · [`docs/bugbot/detection.mdx`](../docs/bugbot/detection.mdx) · [`docs/bugbot/finding-publication.mdx`](../docs/bugbot/finding-publication.mdx) · [`docs/bugbot/autofix.mdx`](../docs/bugbot/autofix.mdx) · [`docs/bugbot/failure-scenarios.mdx`](../docs/bugbot/failure-scenarios.mdx) · [`docs/bugbot/quality-observability.mdx`](../docs/bugbot/quality-observability.mdx) · [`docs/bugbot/permissions.mdx`](../docs/bugbot/permissions.mdx) · [`docs/bugbot/programmatic-api.mdx`](../docs/bugbot/programmatic-api.mdx) · [`docs/bugbot/configuration.mdx`](../docs/bugbot/configuration.mdx) · [`docs/pull-requests/workflow-setup.mdx`](../docs/pull-requests/workflow-setup.mdx) · [`docs/issues/comment-commands.mdx`](../docs/issues/comment-commands.mdx) · [`docs/security-operations/operations/error-reference.mdx`](../docs/security-operations/operations/error-reference.mdx) · [`quality/bugbot/evidence/issue-950/README.md`](../quality/bugbot/evidence/issue-950/README.md) · [`quality/bugbot/evidence/issue-950/traceability.md`](../quality/bugbot/evidence/issue-950/traceability.md) · [`quality/bugbot/evidence/issue-950/ev07-shadow/preregistration.md`](../quality/bugbot/evidence/issue-950/ev07-shadow/preregistration.md) · [`quality/bugbot/evidence/issue-950/shadow-verification/README.md`](../quality/bugbot/evidence/issue-950/shadow-verification/README.md) · [`quality/bugbot/evidence/issue-950/review-progress-follow-up.md`](../quality/bugbot/evidence/issue-950/review-progress-follow-up.md) +- Core code: [`src/application/policies/bugbot_shadow_configuration_policy.ts`](../src/application/policies/bugbot_shadow_configuration_policy.ts) · [`src/infrastructure/bugbot/installed_bugbot_shadow_adapter.ts`](../src/infrastructure/bugbot/installed_bugbot_shadow_adapter.ts) · [`src/infrastructure/bugbot/native_review_cancellation_adapter.ts`](../src/infrastructure/bugbot/native_review_cancellation_adapter.ts) · [`src/infrastructure/bugbot/shadow/installed_official.cjs`](../src/infrastructure/bugbot/shadow/installed_official.cjs) · [`src/infrastructure/bugbot/verifier_model_catalog.ts`](../src/infrastructure/bugbot/verifier_model_catalog.ts) · [`src/application/policies/bugbot_evidence_reference_policy.cjs`](../src/application/policies/bugbot_evidence_reference_policy.cjs) · [`src/application/policies/bugbot_material_dependency_policy.cjs`](../src/application/policies/bugbot_material_dependency_policy.cjs) · [`src/application/usecases/steps/commit/bugbot/bugbot_candidate_trace.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_candidate_trace.ts) · [`src/application/usecases/steps/commit/bugbot/investigate_bugbot_shadow.cjs`](../src/application/usecases/steps/commit/bugbot/investigate_bugbot_shadow.cjs) · [`src/infrastructure/bugbot/shadow/source_cache.cjs`](../src/infrastructure/bugbot/shadow/source_cache.cjs) · [`src/infrastructure/bugbot/shadow_verification_adapter.ts`](../src/infrastructure/bugbot/shadow_verification_adapter.ts) · [`src/infrastructure/bugbot/shadow/broker.cjs`](../src/infrastructure/bugbot/shadow/broker.cjs) · [`src/infrastructure/bugbot/shadow/run.cjs`](../src/infrastructure/bugbot/shadow/run.cjs) · [`src/infrastructure/bugbot/shadow/prompt.cjs`](../src/infrastructure/bugbot/shadow/prompt.cjs) · [`src/infrastructure/bugbot/shadow/schema.cjs`](../src/infrastructure/bugbot/shadow/schema.cjs) · [`src/infrastructure/bugbot/shadow/session.cjs`](../src/infrastructure/bugbot/shadow/session.cjs) · [`src/infrastructure/composition/bugbot_review_composition.ts`](../src/infrastructure/composition/bugbot_review_composition.ts) · [`src/application/ports/bugbot_context_ports.ts`](../src/application/ports/bugbot_context_ports.ts) · [`src/data/repository/pull_request/pull_request_changes_repository.ts`](../src/data/repository/pull_request/pull_request_changes_repository.ts) · [`src/domain/bugbot/context.ts`](../src/domain/bugbot/context.ts) · [`src/domain/bugbot/finding.ts`](../src/domain/bugbot/finding.ts) · [`src/domain/bugbot/finding_identity.ts`](../src/domain/bugbot/finding_identity.ts) · [`src/domain/bugbot/review_configuration.ts`](../src/domain/bugbot/review_configuration.ts) · [`src/application/policies/bounded_concurrency_policy.ts`](../src/application/policies/bounded_concurrency_policy.ts) · [`src/application/policies/bugbot_resolution_eligibility_policy.ts`](../src/application/policies/bugbot_resolution_eligibility_policy.ts) · [`src/application/policies/bugbot_result_finding_state_projection_policy.ts`](../src/application/policies/bugbot_result_finding_state_projection_policy.ts) · [`src/application/policies/bugbot_telemetry_projection_policy.ts`](../src/application/policies/bugbot_telemetry_projection_policy.ts) · [`src/application/policies/bugbot_diff_partition_policy.ts`](../src/application/policies/bugbot_diff_partition_policy.ts) · [`src/application/policies/bugbot_conversation_packing_policy.ts`](../src/application/policies/bugbot_conversation_packing_policy.ts) · [`src/application/policies/bugbot_partition_completion_policy.ts`](../src/application/policies/bugbot_partition_completion_policy.ts) · [`src/application/policies/action_summary_policy.ts`](../src/application/policies/action_summary_policy.ts) · [`src/application/policies/copilot_evidence_policy.ts`](../src/application/policies/copilot_evidence_policy.ts) · [`src/application/ports/bugbot_git_ports.ts`](../src/application/ports/bugbot_git_ports.ts) · [`src/application/ports/bugbot_reconciliation_ports.ts`](../src/application/ports/bugbot_reconciliation_ports.ts) · [`src/application/ports/bugbot_scm_ports.ts`](../src/application/ports/bugbot_scm_ports.ts) · [`src/application/usecases/steps/commit/bugbot/schema.ts`](../src/application/usecases/steps/commit/bugbot/schema.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_operation_context.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_operation_context.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_context_request.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_context_request.ts) · [`src/application/usecases/steps/commit/bugbot/prepare_bugbot_findings_policy.ts`](../src/application/usecases/steps/commit/bugbot/prepare_bugbot_findings_policy.ts) · [`src/application/usecases/steps/commit/bugbot/analyze_bugbot_revision_use_case.ts`](../src/application/usecases/steps/commit/bugbot/analyze_bugbot_revision_use_case.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_partition_aggregation.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_partition_aggregation.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_context.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_context.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_telemetry.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_telemetry.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_progress.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_progress.ts) · [`src/application/ports/bugbot_review_progress_ports.ts`](../src/application/ports/bugbot_review_progress_ports.ts) · [`src/application/ports/bugbot_review_cancellation_ports.ts`](../src/application/ports/bugbot_review_cancellation_ports.ts) · [`src/application/policies/bugbot_live_progress_presentation_policy.ts`](../src/application/policies/bugbot_live_progress_presentation_policy.ts) · [`src/infrastructure/composition/bugbot_review_progress_composition_root.ts`](../src/infrastructure/composition/bugbot_review_progress_composition_root.ts) · [`src/infrastructure/github/github_bugbot_review_progress_adapter.ts`](../src/infrastructure/github/github_bugbot_review_progress_adapter.ts) · [`src/application/usecases/steps/commit/bugbot/build_bugbot_prompt.ts`](../src/application/usecases/steps/commit/bugbot/build_bugbot_prompt.ts) · [`src/application/usecases/steps/commit/bugbot/load_bugbot_context_use_case.ts`](../src/application/usecases/steps/commit/bugbot/load_bugbot_context_use_case.ts) · [`src/application/usecases/steps/commit/bugbot/query_bugbot_findings.ts`](../src/application/usecases/steps/commit/bugbot/query_bugbot_findings.ts) · [`src/prompts/bugbot.ts`](../src/prompts/bugbot.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_previous_findings_context.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_previous_findings_context.ts) · [`src/application/usecases/steps/commit/bugbot/publish_findings_use_case.ts`](../src/application/usecases/steps/commit/bugbot/publish_findings_use_case.ts) · [`src/application/usecases/steps/commit/workspace_mutation_guard.ts`](../src/application/usecases/steps/commit/workspace_mutation_guard.ts) · [`src/data/repository/issue/bugbot_issue_comment_query_repository.ts`](../src/data/repository/issue/bugbot_issue_comment_query_repository.ts) · [`src/infrastructure/bound_bugbot_git_mutation_adapter.ts`](../src/infrastructure/bound_bugbot_git_mutation_adapter.ts) · [`src/infrastructure/composition/bugbot_scm_port_factory.ts`](../src/infrastructure/composition/bugbot_scm_port_factory.ts) · [`src/infrastructure/composition/bugbot_composition_root.ts`](../src/infrastructure/composition/bugbot_composition_root.ts) · [`scripts/coverage-budgets.json`](../scripts/coverage-budgets.json) · [`scripts/validate-coverage-budgets.cjs`](../scripts/validate-coverage-budgets.cjs) · [`src/application/usecases/comment_automation_action_workflow.ts`](../src/application/usecases/comment_automation_action_workflow.ts) · [`src/data/repository/pull_request/pull_request_lifecycle_repository.ts`](../src/data/repository/pull_request/pull_request_lifecycle_repository.ts) · [`src/application/usecases/comment_automation_command_workflow.ts`](../src/application/usecases/comment_automation_command_workflow.ts) · [`src/domain/copilot_command.ts`](../src/domain/copilot_command.ts) · [`src/application/usecases/comment_automation_contracts.ts`](../src/application/usecases/comment_automation_contracts.ts) · [`src/application/usecases/issue_comment_use_case.ts`](../src/application/usecases/issue_comment_use_case.ts) · [`src/application/usecases/pull_request_review_comment_use_case.ts`](../src/application/usecases/pull_request_review_comment_use_case.ts) · [`src/infrastructure/composition/main_run_route_composition_root.ts`](../src/infrastructure/composition/main_run_route_composition_root.ts) · [`src/infrastructure/github/ports/github_pull_request_provider_ports.ts`](../src/infrastructure/github/ports/github_pull_request_provider_ports.ts) · [`src/application/usecases/steps/commit/bugbot/dismiss_bugbot_findings_use_case.ts`](../src/application/usecases/steps/commit/bugbot/dismiss_bugbot_findings_use_case.ts) · [`src/application/policies/semantic_result_publication_policy.ts`](../src/application/policies/semantic_result_publication_policy.ts) · [`src/application/policies/publication_message_catalog.ts`](../src/application/policies/publication_message_catalog.ts) · [`src/application/usecases/steps/commit/bugbot/detect_bugbot_fix_intent_workflow.ts`](../src/application/usecases/steps/commit/bugbot/detect_bugbot_fix_intent_workflow.ts) · [`src/application/usecases/comment_automation_use_case.ts`](../src/application/usecases/comment_automation_use_case.ts) · [`src/infrastructure/filesystem/workspace_bugbot_rules_repository.ts`](../src/infrastructure/filesystem/workspace_bugbot_rules_repository.ts) · [`src/application/usecases/steps/commit/git_branch_checkout.ts`](../src/application/usecases/steps/commit/git_branch_checkout.ts) · [`src/application/usecases/steps/commit/bugbot/commit_and_push_preflight.ts`](../src/application/usecases/steps/commit/bugbot/commit_and_push_preflight.ts) · [`src/application/usecases/steps/commit/bugbot/commit_and_push_workflow.ts`](../src/application/usecases/steps/commit/bugbot/commit_and_push_workflow.ts) · [`quality/bugbot/corpus.v1.json`](../quality/bugbot/corpus.v1.json) · [`quality/bugbot/reference-predictions.v1.json`](../quality/bugbot/reference-predictions.v1.json) · [`src/tooling/bugbot_benchmark_runner.ts`](../src/tooling/bugbot_benchmark_runner.ts) · [`quality/bugbot/compose-720-observations.v1.json`](../quality/bugbot/compose-720-observations.v1.json) · [`quality/bugbot/evidence/issue-722.json`](../quality/bugbot/evidence/issue-722.json) · [`quality/bugbot/evidence/issue-736.json`](../quality/bugbot/evidence/issue-736.json) · [`quality/bugbot/evidence/issue-738.json`](../quality/bugbot/evidence/issue-738.json) · [`quality/bugbot/evidence/issue-739.json`](../quality/bugbot/evidence/issue-739.json) · [`quality/bugbot/evidence/issue-749.json`](../quality/bugbot/evidence/issue-749.json) · [`quality/bugbot/evidence/issue-770.json`](../quality/bugbot/evidence/issue-770.json) · [`src/application/policies/bugbot_python_literal_witness_policy.ts`](../src/application/policies/bugbot_python_literal_witness_policy.ts) · [`src/application/policies/bugbot_literal_verification_policy.ts`](../src/application/policies/bugbot_literal_verification_policy.ts) · [`src/application/usecases/steps/commit/bugbot/verify_generated_literal_findings.ts`](../src/application/usecases/steps/commit/bugbot/verify_generated_literal_findings.ts) · [`src/application/policies/agent_output_locale_policy.ts`](../src/application/policies/agent_output_locale_policy.ts) · [`src/domain/bugbot/framed_review.ts`](../src/domain/bugbot/framed_review.ts) · [`src/application/policies/bugbot_framed_identity_policy.ts`](../src/application/policies/bugbot_framed_identity_policy.ts) · [`src/application/policies/bugbot_framed_receipt_policy.ts`](../src/application/policies/bugbot_framed_receipt_policy.ts) · [`src/application/policies/bugbot_framed_snapshot_policy.ts`](../src/application/policies/bugbot_framed_snapshot_policy.ts) · [`src/application/policies/bugbot_framed_review_policy.ts`](../src/application/policies/bugbot_framed_review_policy.ts) · [`src/application/policies/bugbot_patch_binding_policy.ts`](../src/application/policies/bugbot_patch_binding_policy.ts) · [`src/application/policies/bugbot_review_diagnostic_labels.ts`](../src/application/policies/bugbot_review_diagnostic_labels.ts) · [`src/application/ports/bugbot_review_source_ports.ts`](../src/application/ports/bugbot_review_source_ports.ts) · [`src/application/ports/bugbot_telemetry_ports.ts`](../src/application/ports/bugbot_telemetry_ports.ts) · [`src/infrastructure/filesystem/bugbot_git_review_source_adapter.ts`](../src/infrastructure/filesystem/bugbot_git_review_source_adapter.ts) · [`src/application/usecases/steps/commit/bugbot/analyze_bugbot_frames.ts`](../src/application/usecases/steps/commit/bugbot/analyze_bugbot_frames.ts) · [`src/application/policies/bugbot_framed_prompt_policy.ts`](../src/application/policies/bugbot_framed_prompt_policy.ts) · [`quality/bugbot/evidence/issue-831.json`](../quality/bugbot/evidence/issue-831.json) · [`quality/bugbot/evidence/issue-832.json`](../quality/bugbot/evidence/issue-832.json) · [`quality/bugbot/evidence/issue-834.json`](../quality/bugbot/evidence/issue-834.json) · [`src/application/policies/bugbot_complete_conversation_policy.ts`](../src/application/policies/bugbot_complete_conversation_policy.ts) · [`src/prompts/fill.ts`](../src/prompts/fill.ts) · [`quality/bugbot/evidence/issue-843.json`](../quality/bugbot/evidence/issue-843.json) · [`src/prompts/bugbot_resource_authority.ts`](../src/prompts/bugbot_resource_authority.ts) · [`quality/bugbot/resource-authority-corpus.v1.json`](../quality/bugbot/resource-authority-corpus.v1.json) · [`quality/bugbot/evidence/issue-847.json`](../quality/bugbot/evidence/issue-847.json) · [`.gitattributes`](../.gitattributes) · [`src/prompts/bugbot_async_statement_evidence.ts`](../src/prompts/bugbot_async_statement_evidence.ts) · [`quality/bugbot/async-statement-corpus.v1.json`](../quality/bugbot/async-statement-corpus.v1.json) · [`quality/bugbot/evidence/issue-848.json`](../quality/bugbot/evidence/issue-848.json) · [`eslint.config.mjs`](../eslint.config.mjs) · [`src/prompts/bugbot_json_value_evidence.ts`](../src/prompts/bugbot_json_value_evidence.ts) · [`quality/bugbot/json-value-corpus.v1.json`](../quality/bugbot/json-value-corpus.v1.json) · [`quality/bugbot/evidence/issue-855.json`](../quality/bugbot/evidence/issue-855.json) · [`src/domain/bugbot/response_failure.ts`](../src/domain/bugbot/response_failure.ts) · [`src/data/repository/agent_findings_response_policy.ts`](../src/data/repository/agent_findings_response_policy.ts) · [`src/data/model/application_error.ts`](../src/data/model/application_error.ts) · [`src/application/policies/application_error_message_catalog.ts`](../src/application/policies/application_error_message_catalog.ts) · [`src/application/errors/bugbot_verification_response_failure.ts`](../src/application/errors/bugbot_verification_response_failure.ts) · [`src/domain/bugbot/review_freshness_failure.ts`](../src/domain/bugbot/review_freshness_failure.ts) · [`src/application/errors/bugbot_freshness_error.ts`](../src/application/errors/bugbot_freshness_error.ts) · [`src/application/policies/pull_request_review_provider_code_policy.ts`](../src/application/policies/pull_request_review_provider_code_policy.ts) · [`src/application/ports/pull_request_review_errors.ts`](../src/application/ports/pull_request_review_errors.ts) · [`src/application/usecases/steps/commit/bugbot/bugbot_review_freshness.ts`](../src/application/usecases/steps/commit/bugbot/bugbot_review_freshness.ts) · [`src/application/usecases/steps/commit/bugbot/verify_bugbot_publication_policy.ts`](../src/application/usecases/steps/commit/bugbot/verify_bugbot_publication_policy.ts) · [`src/application/policies/bugbot_mutation_cancellation_policy.ts`](../src/application/policies/bugbot_mutation_cancellation_policy.ts) · [`quality/bugbot/corpus.v2.json`](../quality/bugbot/corpus.v2.json) · [`quality/bugbot/evidence/issue-985/derivation.json`](../quality/bugbot/evidence/issue-985/derivation.json) · [`quality/bugbot/evidence/issue-985/historical-hashes.json`](../quality/bugbot/evidence/issue-985/historical-hashes.json) +- Tests: [`src/application/policies/__tests__/bugbot_shadow_configuration_policy.test.ts`](../src/application/policies/__tests__/bugbot_shadow_configuration_policy.test.ts) · [`src/data/repository/__tests__/pull_request_changes_repository.test.ts`](../src/data/repository/__tests__/pull_request_changes_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/bugbot_review_lifecycle.e2e.test.ts`](../src/application/usecases/steps/commit/__tests__/bugbot_review_lifecycle.e2e.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_operation_context.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_operation_context.test.ts) · [`src/application/policies/__tests__/bugbot_partition_completion_policy.test.ts`](../src/application/policies/__tests__/bugbot_partition_completion_policy.test.ts) · [`src/application/policies/__tests__/bugbot_conversation_packing_policy.test.ts`](../src/application/policies/__tests__/bugbot_conversation_packing_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_revision_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_revision_use_case.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_aggregation.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_aggregation.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_context_request.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_context_request.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/load_bugbot_context_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/load_bugbot_context_use_case.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/schema.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/schema.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/prepare_bugbot_findings.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/prepare_bugbot_findings.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_context.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_context.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/query_bugbot_findings.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/query_bugbot_findings.test.ts) · [`src/domain/bugbot/__tests__/context.test.ts`](../src/domain/bugbot/__tests__/context.test.ts) · [`src/data/repository/issue/__tests__/bugbot_issue_comment_query_repository.test.ts`](../src/data/repository/issue/__tests__/bugbot_issue_comment_query_repository.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/publish_findings_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/publish_findings_use_case.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_autofix_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_autofix_use_case.test.ts) · [`src/application/ports/__tests__/bugbot_port_boundaries.test.ts`](../src/application/ports/__tests__/bugbot_port_boundaries.test.ts) · [`src/infrastructure/composition/__tests__/bugbot_scm_port_factory.test.ts`](../src/infrastructure/composition/__tests__/bugbot_scm_port_factory.test.ts) · [`src/__tests__/api.test.ts`](../src/__tests__/api.test.ts) · [`src/domain/bugbot/__tests__/finding_identity.test.ts`](../src/domain/bugbot/__tests__/finding_identity.test.ts) · [`src/application/policies/__tests__/bugbot_result_finding_state_projection_policy.test.ts`](../src/application/policies/__tests__/bugbot_result_finding_state_projection_policy.test.ts) · [`src/application/policies/__tests__/bugbot_telemetry_projection_policy.test.ts`](../src/application/policies/__tests__/bugbot_telemetry_projection_policy.test.ts) · [`src/application/policies/__tests__/action_summary_policy.test.ts`](../src/application/policies/__tests__/action_summary_policy.test.ts) · [`src/application/policies/__tests__/copilot_evidence_policy.test.ts`](../src/application/policies/__tests__/copilot_evidence_policy.test.ts) · [`src/actions/__tests__/github_action_completion.test.ts`](../src/actions/__tests__/github_action_completion.test.ts) · [`src/tooling/__tests__/validate_workflow_contract.test.ts`](../src/tooling/__tests__/validate_workflow_contract.test.ts) · [`src/application/usecases/__tests__/comment_automation_action_workflow.test.ts`](../src/application/usecases/__tests__/comment_automation_action_workflow.test.ts) · [`src/data/repository/__tests__/pull_request_lifecycle_repository.test.ts`](../src/data/repository/__tests__/pull_request_lifecycle_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/detect_potential_problems_use_case.test.ts`](../src/application/usecases/steps/commit/__tests__/detect_potential_problems_use_case.test.ts) · [`src/application/usecases/__tests__/comment_automation_use_case.test.ts`](../src/application/usecases/__tests__/comment_automation_use_case.test.ts) · [`src/domain/__tests__/copilot_command.test.ts`](../src/domain/__tests__/copilot_command.test.ts) · [`src/infrastructure/composition/__tests__/main_run_route_composition_root.test.ts`](../src/infrastructure/composition/__tests__/main_run_route_composition_root.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/dismiss_bugbot_findings_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/dismiss_bugbot_findings_use_case.test.ts) · [`src/application/policies/__tests__/semantic_result_publication_policy.test.ts`](../src/application/policies/__tests__/semantic_result_publication_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/detect_bugbot_fix_intent_use_case.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/detect_bugbot_fix_intent_use_case.test.ts) · [`src/infrastructure/filesystem/__tests__/workspace_bugbot_rules_repository.test.ts`](../src/infrastructure/filesystem/__tests__/workspace_bugbot_rules_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/git_branch_checkout.integration.test.ts`](../src/application/usecases/steps/commit/__tests__/git_branch_checkout.integration.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/workspace_changes.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/workspace_changes.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/commit_verification_workspace.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/commit_verification_workspace.test.ts) · [`src/application/usecases/__tests__/autofix_conversation_branch_authority.test.ts`](../src/application/usecases/__tests__/autofix_conversation_branch_authority.test.ts) · [`src/tooling/__tests__/bugbot_benchmark.test.ts`](../src/tooling/__tests__/bugbot_benchmark.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_call_path_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_call_path_oracles.ts) · [`src/tooling/__tests__/bugbot_benchmark_runner.test.ts`](../src/tooling/__tests__/bugbot_benchmark_runner.test.ts) · [`src/prompts/__tests__/bugbot.test.ts`](../src/prompts/__tests__/bugbot.test.ts) · [`src/prompts/__tests__/bugbot_framework_semantics.test.ts`](../src/prompts/__tests__/bugbot_framework_semantics.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_validation_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_validation_oracles.ts) · [`src/tooling/__tests__/fixtures/bugbot_validation_functions.ts`](../src/tooling/__tests__/fixtures/bugbot_validation_functions.ts) · [`src/tooling/__tests__/fixtures/bugbot_markdown_link_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_markdown_link_oracles.ts) · [`quality/bugbot/evidence/issue-772.json`](../quality/bugbot/evidence/issue-772.json) · [`src/tooling/__tests__/bugbot_request_transform_evidence.test.ts`](../src/tooling/__tests__/bugbot_request_transform_evidence.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_request_transform_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_request_transform_oracles.ts) · [`quality/bugbot/evidence/issue-784.json`](../quality/bugbot/evidence/issue-784.json) · [`src/tooling/__tests__/fixtures/bugbot_generated_coordinate_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_generated_coordinate_oracles.ts) · [`src/tooling/__tests__/bugbot_generated_coordinate_evidence.test.ts`](../src/tooling/__tests__/bugbot_generated_coordinate_evidence.test.ts) · [`src/application/policies/__tests__/bugbot_python_literal_witness_policy.test.ts`](../src/application/policies/__tests__/bugbot_python_literal_witness_policy.test.ts) · [`src/application/policies/__tests__/bugbot_literal_verification_policy.test.ts`](../src/application/policies/__tests__/bugbot_literal_verification_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/verify_generated_literal_findings.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/verify_generated_literal_findings.test.ts) · [`quality/bugbot/evidence/issue-796.json`](../quality/bugbot/evidence/issue-796.json) · [`src/tooling/__tests__/fixtures/bugbot_initial_session_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_initial_session_oracles.ts) · [`src/tooling/__tests__/bugbot_initial_session_evidence.test.ts`](../src/tooling/__tests__/bugbot_initial_session_evidence.test.ts) · [`quality/bugbot/evidence/issue-798.json`](../quality/bugbot/evidence/issue-798.json) · [`src/tooling/__tests__/bugbot_unittest_discovery.test.ts`](../src/tooling/__tests__/bugbot_unittest_discovery.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_unittest_discovery_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_unittest_discovery_oracles.ts) · [`quality/bugbot/evidence/issue-806.json`](../quality/bugbot/evidence/issue-806.json) · [`src/tooling/__tests__/fixtures/bugbot_unittest_discovery_probe.py`](../src/tooling/__tests__/fixtures/bugbot_unittest_discovery_probe.py) · [`src/tooling/__tests__/bugbot_kotlin_json.test.ts`](../src/tooling/__tests__/bugbot_kotlin_json.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_kotlin_json_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_kotlin_json_oracles.ts) · [`src/tooling/__tests__/fixtures/bugbot_kotlin_json_probe.kt`](../src/tooling/__tests__/fixtures/bugbot_kotlin_json_probe.kt) · [`quality/bugbot/evidence/issue-807.json`](../quality/bugbot/evidence/issue-807.json) · [`src/tooling/__tests__/bugbot_ktor_routing.test.ts`](../src/tooling/__tests__/bugbot_ktor_routing.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_ktor_routing_oracles.ts`](../src/tooling/__tests__/fixtures/bugbot_ktor_routing_oracles.ts) · [`quality/bugbot/evidence/issue-809.json`](../quality/bugbot/evidence/issue-809.json) · [`src/domain/bugbot/__tests__/framed_review.test.ts`](../src/domain/bugbot/__tests__/framed_review.test.ts) · [`src/application/policies/__tests__/bugbot_framed_review_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_review_policy.test.ts) · [`src/application/policies/__tests__/bugbot_framed_identity_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_identity_policy.test.ts) · [`src/application/policies/__tests__/bugbot_patch_binding_policy.test.ts`](../src/application/policies/__tests__/bugbot_patch_binding_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_frames.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/analyze_bugbot_frames.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_progress.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_review_progress.test.ts) · [`src/infrastructure/github/__tests__/github_bugbot_review_progress_adapter.test.ts`](../src/infrastructure/github/__tests__/github_bugbot_review_progress_adapter.test.ts) · [`src/infrastructure/filesystem/__tests__/bugbot_git_review_source_adapter.test.ts`](../src/infrastructure/filesystem/__tests__/bugbot_git_review_source_adapter.test.ts) · [`src/data/repository/__tests__/bugbot_source_bound_identity_repository.test.ts`](../src/data/repository/__tests__/bugbot_source_bound_identity_repository.test.ts) · [`src/application/usecases/steps/commit/__tests__/bugbot_framed_complete_review.integration.test.ts`](../src/application/usecases/steps/commit/__tests__/bugbot_framed_complete_review.integration.test.ts) · [`src/application/policies/__tests__/bugbot_framed_snapshot_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_snapshot_policy.test.ts) · [`src/application/policies/__tests__/bugbot_framed_prompt_policy.test.ts`](../src/application/policies/__tests__/bugbot_framed_prompt_policy.test.ts) · [`src/tooling/__tests__/bugbot_python_exception_syntax.test.ts`](../src/tooling/__tests__/bugbot_python_exception_syntax.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_python_exception_parse_probe.py`](../src/tooling/__tests__/fixtures/bugbot_python_exception_parse_probe.py) · [`src/tooling/__tests__/fixtures/bugbot_python_314_catch_probe.py`](../src/tooling/__tests__/fixtures/bugbot_python_314_catch_probe.py) · [`src/tooling/__tests__/bugbot_recovery_contract.test.ts`](../src/tooling/__tests__/bugbot_recovery_contract.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_recovery_contract_probe.py`](../src/tooling/__tests__/fixtures/bugbot_recovery_contract_probe.py) · [`src/tooling/__tests__/bugbot_fixture_values.test.ts`](../src/tooling/__tests__/bugbot_fixture_values.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_fixture_values_probe.py`](../src/tooling/__tests__/fixtures/bugbot_fixture_values_probe.py) · [`src/tooling/__tests__/bugbot_fixture_identity.test.ts`](../src/tooling/__tests__/bugbot_fixture_identity.test.ts) · [`src/application/policies/__tests__/bugbot_complete_conversation_policy.test.ts`](../src/application/policies/__tests__/bugbot_complete_conversation_policy.test.ts) · [`src/prompts/__tests__/bugbot_complete_conversation.test.ts`](../src/prompts/__tests__/bugbot_complete_conversation.test.ts) · [`src/application/usecases/steps/commit/__tests__/bugbot_complete_conversation.integration.test.ts`](../src/application/usecases/steps/commit/__tests__/bugbot_complete_conversation.integration.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_long_conversation_fixture.ts`](../src/tooling/__tests__/fixtures/bugbot_long_conversation_fixture.ts) · [`src/tooling/__tests__/bugbot_resource_authority.test.ts`](../src/tooling/__tests__/bugbot_resource_authority.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_resource_boundary_probe.py`](../src/tooling/__tests__/fixtures/bugbot_resource_boundary_probe.py) · [`src/tooling/__tests__/bugbot_async_statements.test.ts`](../src/tooling/__tests__/bugbot_async_statements.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_async_statement_probe.mjs`](../src/tooling/__tests__/fixtures/bugbot_async_statement_probe.mjs) · [`src/tooling/__tests__/fixtures/bugbot_async_statement_runner.mjs`](../src/tooling/__tests__/fixtures/bugbot_async_statement_runner.mjs) · [`src/tooling/__tests__/bugbot_json_values.test.ts`](../src/tooling/__tests__/bugbot_json_values.test.ts) · [`src/tooling/__tests__/fixtures/bugbot_json_value_probe.py`](../src/tooling/__tests__/fixtures/bugbot_json_value_probe.py) · [`src/tooling/__tests__/fixtures/bugbot_json_value_runner.py`](../src/tooling/__tests__/fixtures/bugbot_json_value_runner.py) · [`src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_query_diagnostics.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/bugbot_partition_query_diagnostics.test.ts) · [`src/application/policies/__tests__/bugbot_freshness_diagnostics.test.ts`](../src/application/policies/__tests__/bugbot_freshness_diagnostics.test.ts) · [`quality/bugbot/evidence/issue-950/ev07-shadow/launch-full-review.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/launch-full-review.test.cjs) · [`quality/bugbot/evidence/issue-950/ev07-shadow/review-runtime.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/review-runtime.test.cjs) · [`quality/bugbot/evidence/issue-950/ev07-shadow/score-review.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/score-review.test.cjs) · [`quality/bugbot/evidence/issue-950/normal-flow-shadow/paths.test.cjs`](../quality/bugbot/evidence/issue-950/normal-flow-shadow/paths.test.cjs) · [`quality/bugbot/evidence/issue-950/shadow-verification/verification.test.cjs`](../quality/bugbot/evidence/issue-950/shadow-verification/verification.test.cjs) · [`src/infrastructure/bugbot/__tests__/shadow_verification_adapter.test.ts`](../src/infrastructure/bugbot/__tests__/shadow_verification_adapter.test.ts) · [`src/infrastructure/bugbot/__tests__/native_review_cancellation_adapter.test.ts`](../src/infrastructure/bugbot/__tests__/native_review_cancellation_adapter.test.ts) · [`src/infrastructure/bugbot/__tests__/installed_bugbot_official.test.ts`](../src/infrastructure/bugbot/__tests__/installed_bugbot_official.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/verify_bugbot_publication_paths.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/verify_bugbot_publication_paths.test.ts) · [`quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs`](../quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs) · [`src/application/policies/__tests__/bugbot_mutation_cancellation_policy.test.ts`](../src/application/policies/__tests__/bugbot_mutation_cancellation_policy.test.ts) · [`src/application/usecases/steps/commit/bugbot/__tests__/observe_bugbot_base.test.ts`](../src/application/usecases/steps/commit/bugbot/__tests__/observe_bugbot_base.test.ts) · [`quality/bugbot/evidence/issue-985/corpus-revision.test.cjs`](../quality/bugbot/evidence/issue-985/corpus-revision.test.cjs) +- User documentation: [`docs/bugbot/how-it-works.mdx`](../docs/bugbot/how-it-works.mdx) · [`docs/bugbot/detection.mdx`](../docs/bugbot/detection.mdx) · [`docs/bugbot/finding-publication.mdx`](../docs/bugbot/finding-publication.mdx) · [`docs/bugbot/autofix.mdx`](../docs/bugbot/autofix.mdx) · [`docs/bugbot/failure-scenarios.mdx`](../docs/bugbot/failure-scenarios.mdx) · [`docs/bugbot/quality-observability.mdx`](../docs/bugbot/quality-observability.mdx) · [`docs/bugbot/permissions.mdx`](../docs/bugbot/permissions.mdx) · [`docs/bugbot/programmatic-api.mdx`](../docs/bugbot/programmatic-api.mdx) · [`docs/bugbot/configuration.mdx`](../docs/bugbot/configuration.mdx) · [`docs/pull-requests/workflow-setup.mdx`](../docs/pull-requests/workflow-setup.mdx) · [`docs/issues/comment-commands.mdx`](../docs/issues/comment-commands.mdx) · [`docs/security-operations/operations/error-reference.mdx`](../docs/security-operations/operations/error-reference.mdx) · [`quality/bugbot/evidence/issue-950/README.md`](../quality/bugbot/evidence/issue-950/README.md) · [`quality/bugbot/evidence/issue-950/traceability.md`](../quality/bugbot/evidence/issue-950/traceability.md) · [`quality/bugbot/evidence/issue-950/ev07-shadow/preregistration.md`](../quality/bugbot/evidence/issue-950/ev07-shadow/preregistration.md) · [`quality/bugbot/evidence/issue-950/shadow-verification/README.md`](../quality/bugbot/evidence/issue-950/shadow-verification/README.md) · [`quality/bugbot/evidence/issue-950/review-progress-follow-up.md`](../quality/bugbot/evidence/issue-950/review-progress-follow-up.md) · [`quality/bugbot/evidence/issue-985/README.md`](../quality/bugbot/evidence/issue-985/README.md) ### `branch-synchronization` — Branch synchronization and conflict recovery diff --git a/specs/bugbot-analysis-publication-and-autofix.md b/specs/bugbot-analysis-publication-and-autofix.md index 7949c4716..069a5734f 100644 --- a/specs/bugbot-analysis-publication-and-autofix.md +++ b/specs/bugbot-analysis-publication-and-autofix.md @@ -4400,3 +4400,38 @@ corpus. Evidence for readiness and authorization for production are distinct. The existing Bugbot SDD and its evidence reports document the qualification thresholds, supported profiles, approval policy and rollback protocol. This revision neither enables production verification nor qualifies a profile. + +## Versioned corpus input correction (#985) + +The #971 audit separates original scorer FP/FN from independent causal evidence. +Its malformed `actions-readonly-metadata` fixture is corrected only in the new +repository qualification artifact `quality/bugbot/corpus.v2.json`. The original +v1, labels, plans, model outputs, scores and failure decisions remain immutable. +The new artifact keeps all 174 IDs/order and all labels; only one case's workflow +input changes, supplying a complete read-only metadata job without checkout or +PR-code execution. Its proposed empty expected list requires independent review +of the corrected input; it cannot retrospectively remove a recorded FP. + +The existing JSON schema stays version 1; the filename identifies a corpus data +revision. `issue-985/derivation.json` records the exact before/after input and +source/target hashes. Its history manifest binds the original corpus and all +frozen #950 JSON/JSONL records. This is test evidence, not a new user setting, +production prompt, runtime policy or model qualification result. The synthetic +consumer runner in the input does not alter source-repository self-hosted policy. + +The numeric test budget is exactly **six focused controls**: original malformed +shape; corrected complete workflow; fixed read-only numeric metadata command; +invalid structural negative; public-loader acceptance plus 174 stable IDs and +173 unchanged cases; deterministic derivation plus frozen historical hashes. +Only the separately reviewed literal metadata echo runs in the shell. No live +GitHub dispatch, credentials, arbitrary corpus command or model call is needed. +Run these controls through the shadow-verification script and preserve all +failed attempts. Update benchmark guidance/catalog and validate specifications. + +For #974, first merge the deterministic prerequisites and this justified +correction. A new exact committed driver/preregistration MUST select and pin v2 +before measurement. The current v1 driver/default is unchanged; this revision +does not silently redirect it. Preserve prompt/schema/order/retry/runtime/source +identity, all existing thresholds and zero evaluated-PR writes. A v1 score cannot +qualify v2, and a failed new campaign still leaves all 42 full reviews unstarted. +Production verification remains disabled regardless of the eventual score. diff --git a/specs/catalog.json b/specs/catalog.json index 328a4386d..f3ec04f26 100644 --- a/specs/catalog.json +++ b/specs/catalog.json @@ -2446,7 +2446,10 @@ "src/application/ports/pull_request_review_errors.ts", "src/application/usecases/steps/commit/bugbot/bugbot_review_freshness.ts", "src/application/usecases/steps/commit/bugbot/verify_bugbot_publication_policy.ts", - "src/application/policies/bugbot_mutation_cancellation_policy.ts" + "src/application/policies/bugbot_mutation_cancellation_policy.ts", + "quality/bugbot/corpus.v2.json", + "quality/bugbot/evidence/issue-985/derivation.json", + "quality/bugbot/evidence/issue-985/historical-hashes.json" ], "tests": [ "src/application/policies/__tests__/bugbot_shadow_configuration_policy.test.ts", @@ -2568,7 +2571,8 @@ "src/application/usecases/steps/commit/bugbot/__tests__/verify_bugbot_publication_paths.test.ts", "quality/bugbot/evidence/issue-950/ev07-shadow/plan.test.cjs", "src/application/policies/__tests__/bugbot_mutation_cancellation_policy.test.ts", - "src/application/usecases/steps/commit/bugbot/__tests__/observe_bugbot_base.test.ts" + "src/application/usecases/steps/commit/bugbot/__tests__/observe_bugbot_base.test.ts", + "quality/bugbot/evidence/issue-985/corpus-revision.test.cjs" ], "documentation": [ "docs/bugbot/how-it-works.mdx", @@ -2587,7 +2591,8 @@ "quality/bugbot/evidence/issue-950/traceability.md", "quality/bugbot/evidence/issue-950/ev07-shadow/preregistration.md", "quality/bugbot/evidence/issue-950/shadow-verification/README.md", - "quality/bugbot/evidence/issue-950/review-progress-follow-up.md" + "quality/bugbot/evidence/issue-950/review-progress-follow-up.md", + "quality/bugbot/evidence/issue-985/README.md" ] }, {