OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
fix: complete Deep scans with missing optional writeups (#1624)
Michael D'Angelo6f1412a6ad6c
diff --git a/plugins/codex-security/scripts/finalize_scan_contract.py b/plugins/codex-security/scripts/finalize_scan_contract.pyindex df8a11095..acafc41a7 100644--- a/plugins/codex-security/scripts/finalize_scan_contract.py+++ b/plugins/codex-security/scripts/finalize_scan_contract.py@@ -19,7 +19,7 @@ import structimport sysfrom datetime import datetime, timezonefrom pathlib import Path, PurePosixPath-from typing import Any, TextIO+from typing import Any, NamedTuple, TextIOfrom urllib.parse import quote, urlsplit# Keep sibling helpers importable when Python starts in isolated mode.@@ -95,6 +95,10 @@ class ContractError(ValueError):"""Raised when a completed scan does not satisfy the additive contract."""+class MissingScanLocalFileError(ContractError):+ """Raised when a scan-local file or its containing directory is absent."""++class RecoverableContractError(ContractError):"""Raised when scan completion can safely be retried before publication."""@@ -587,6 +591,9 @@ def _open_scan_local_file_with_path(return backend.open_read_fd_with_path(scan_dir, relative_path, context)return backend.open_read_fd(scan_dir, relative_path, context), relative_pathexcept OSError as exc:+ # The Windows backend retains native ERROR_FILE/PATH_NOT_FOUND codes.+ if exc.errno in {2, 3}:+ raise MissingScanLocalFileError(str(exc)) from excraise ContractError(str(exc)) from excroot_fd: int | None = Noneparent_fd: int | None = None@@ -602,6 +609,10 @@ def _open_scan_local_file_with_path(dir_fd=parent_fd,)except OSError as exc:+ if exc.errno == errno.ENOENT:+ raise MissingScanLocalFileError(+ f"{context}: expected a file inside the scan directory"+ ) from excif exc.errno == errno.ELOOP:try:link_target = Path(os.readlink(parts[-1], dir_fd=parent_fd))@@ -647,7 +658,13 @@ def _require_scan_local_file(scan_dir: Path, relative_path: str, context: str) -os.close(descriptor)-def _require_derived_writeup_files(scan_dir: Path, findings: dict[str, Any]) -> None:+def _prepare_derived_writeups(+ scan_dir: Path,+ findings: dict[str, Any],+ *,+ allow_missing: bool = False,+) -> list[str]:+ warnings: list[str] = []for index, finding in enumerate(findings.get("findings", [])):if not isinstance(finding, dict):continue@@ -656,11 +673,18 @@ def _require_derived_writeup_files(scan_dir: Path, findings: dict[str, Any]) ->continuereport_path = writeup.get("reportPath")if isinstance(report_path, str):- _require_scan_local_file(- scan_dir,- report_path,- f"findings[{index}].writeup.reportPath",- )+ try:+ _require_scan_local_file(+ scan_dir,+ report_path,+ f"findings[{index}].writeup.reportPath",+ )+ except MissingScanLocalFileError as exc:+ if not allow_missing:+ raise+ finding.pop("writeup")+ warnings.append(f"Skipped missing writeup for finding {index + 1}: {exc}.")+ return warningsdef _require_hardening_portfolio_file(scan_dir: Path, scan: dict[str, Any]) -> None:@@ -2911,15 +2935,15 @@ def _write_sarif_projection_if_possible()-PreparedScanFinalization = tuple[- Path,- Path,- dict[str, Any],- dict[str, Any],- dict[str, Any],- bool,- bytes,-]+class PreparedScanFinalization(NamedTuple):+ scan_dir: Path+ schema_dir: Path+ manifest: dict[str, Any]+ findings: dict[str, Any]+ coverage: dict[str, Any]+ was_sealed: bool+ report_markdown_bytes: bytes+ warnings: list[str]def _prepare_scan_finalization(@@ -2928,12 +2952,14 @@ def _prepare_scan_finalization(*,expected_coverage_mode: str | None = None,completion_binding: dict[str, Any] | None = None,- completion_warnings: list[str] | None = None,+ recover_unsealed: bool = False,+ allow_missing_writeups: bool = False,draft_documents: tuple[dict[str, Any], dict[str, Any], dict[str, Any]] | None = None,finding_scope: list[tuple[str, bool]] | None = None,) -> PreparedScanFinalization:- """Read, populate, and validate a scan without writing any output files."""+ """Prepare validated documents and warnings without writing any output files."""+ warnings: list[str] = []scan_dir = _require_scan_directory(scan_dir)schema_dir = schema_dir or Path(__file__).resolve().parent.parent / "schemas"manifest = (@@ -2993,14 +3019,12 @@ def _prepare_scan_finalization(findings_for_validation = (_legacy_sealed_findings_for_validation(findings) if was_sealed else findings)- if not was_sealed and completion_warnings is not None:+ if not was_sealed and recover_unsealed:discarded_findings = _recover_unsealed_findings(- manifest, findings, schema_dir, scan_dir, completion_warnings- )- _recover_unsealed_coverage(- coverage, schema_dir, scan_dir, completion_warnings, discarded_findings+ manifest, findings, schema_dir, scan_dir, warnings)- _recover_unsealed_hardening(manifest, scan_dir, completion_warnings)+ _recover_unsealed_coverage(coverage, schema_dir, scan_dir, warnings, discarded_findings)+ _recover_unsealed_hardening(manifest, scan_dir, warnings)elif not was_sealed:_populate_unsealed_finding_identities(manifest, findings)_validate_findings(manifest, findings_for_validation)@@ -3010,29 +3034,42 @@ def _prepare_scan_finalization(_validate_canonical_schemas_before_projection(manifest, findings_for_validation, coverage, schema_dir)- _require_derived_writeup_files(scan_dir, findings)_require_hardening_portfolio_file(scan_dir, scan)if finding_scope is not None:# Accepted worker/reducer files remain immutable; only the new parent# projection is scoped, after the existing validation of every finding.- scoped_findings = [- finding- for finding in findings["findings"]- if any(+ scoped_findings = []+ excluded_findings = []+ for finding in findings["findings"]:+ in_scope = any(PurePosixPath(location["path"]) == PurePosixPath(path)if is_fileelse path_within_scope(location["path"], path)for location in finding["locations"]for path, is_file in finding_scope)- ]+ (scoped_findings if in_scope else excluded_findings).append(finding)if was_sealed and len(scoped_findings) != len(findings["findings"]):raise ContractError("The sealed Deep scan contains findings outside its requested paths; ""start a new scan to produce scoped results.")if not was_sealed:+ # Excluded findings still require safe writeups, but missing optional+ # links should only produce warnings for findings in the final report.+ _prepare_derived_writeups(+ scan_dir,+ {"findings": excluded_findings},+ allow_missing=allow_missing_writeups,+ )findings["findings"] = scoped_findings+ warnings.extend(+ _prepare_derived_writeups(+ scan_dir,+ findings,+ allow_missing=allow_missing_writeups and not was_sealed,+ )+ )if was_sealed:_validate_sealed_coverage_receipts(scan, coverage)_validate_manifest(manifest)@@ -3055,14 +3092,15 @@ def _prepare_scan_finalization(_validate_manifest(manifest)validate_against_schema(manifest, schema_dir / "scan-manifest.schema.json")_contract_json_bytes("scan-manifest.json", manifest)- return (- scan_dir,- schema_dir,- manifest,- findings,- coverage,- was_sealed,- report_markdown_bytes,+ return PreparedScanFinalization(+ scan_dir=scan_dir,+ schema_dir=schema_dir,+ manifest=manifest,+ findings=findings,+ coverage=coverage,+ was_sealed=was_sealed,+ report_markdown_bytes=report_markdown_bytes,+ warnings=warnings,)@@ -3074,33 +3112,25 @@ def _write_prepared_scan_finalization() -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]:"""Write a previously validated scan finalization result."""- (- scan_dir,- schema_dir,- manifest,- findings,- coverage,- was_sealed,- report_markdown_bytes,- ) = prepared- scan = _require_dict(manifest, "scan", "manifest")- if not was_sealed:- _write_scan_local_json(scan_dir, "findings.json", findings)- _write_scan_local_json(scan_dir, "coverage.json", coverage)- write_scan_local_bytes(scan_dir, "report.md", report_markdown_bytes)+ scan_dir = prepared.scan_dir+ scan = _require_dict(prepared.manifest, "scan", "manifest")+ if not prepared.was_sealed:+ _write_scan_local_json(scan_dir, "findings.json", prepared.findings)+ _write_scan_local_json(scan_dir, "coverage.json", prepared.coverage)+ write_scan_local_bytes(scan_dir, "report.md", prepared.report_markdown_bytes)_remove_scan_local_file_if_exists(scan_dir, "report.html")- if not was_sealed:- _write_scan_local_json(scan_dir, "scan-manifest.json", manifest)+ if not prepared.was_sealed:+ _write_scan_local_json(scan_dir, "scan-manifest.json", prepared.manifest)_validate_existing_seal(scan_dir, scan)- _write_sarif_projection_if_possible(scan_dir, source_root, schema_dir)- warning = write_threat_model_projection_if_possible(scan_dir, manifest)+ _write_sarif_projection_if_possible(scan_dir, source_root, prepared.schema_dir)+ warning = write_threat_model_projection_if_possible(scan_dir, prepared.manifest)if (warning is not Noneand projection_warnings is not Noneand warning not in projection_warnings):projection_warnings.append(warning)- return manifest, findings, coverage+ return prepared.manifest, prepared.findings, prepared.coveragedef finalize_scan(diff --git a/plugins/codex-security/scripts/workbench_db.py b/plugins/codex-security/scripts/workbench_db.pyindex 6fff8bc67..d2f93a80a 100644--- a/plugins/codex-security/scripts/workbench_db.py+++ b/plugins/codex-security/scripts/workbench_db.py@@ -1552,11 +1552,23 @@ def complete_scan_locked(scan_dir,expected_coverage_mode=expected_coverage_mode(scan),completion_binding=completion_binding,- completion_warnings=warnings if scan["mode"] != "deep" else None,+ recover_unsealed=scan["mode"] != "deep",+ allow_missing_writeups=scan["mode"] == "deep",draft_documents=draft_documents,finding_scope=requested_finding_scope(scan) if scan["mode"] == "deep" else None,)+ if scan["mode"] != "deep":+ warnings.extend(prepared.warnings)add_warning()+ if scan["mode"] == "deep" and prepared.warnings:+ warnings.extend(warning for warning in prepared.warnings if warning not in warnings)+ # Save the explanation before publication removes the broken reference,+ # so a retry after an output-write failure retains it.+ with connection:+ connection.execute(+ "UPDATE scans SET completion_warnings_json = ? WHERE id = ? AND status = 'running'",+ (json.dumps(warnings), scan_id),+ )wrote = Truemanifest, findings, _ = _write_prepared_scan_finalization(prepared, projection_warnings=warningsdiff --git a/plugins/codex-security/scripts/workbench_saved_results.py b/plugins/codex-security/scripts/workbench_saved_results.pyindex 97091bd6c..7206e2c79 100644--- a/plugins/codex-security/scripts/workbench_saved_results.py+++ b/plugins/codex-security/scripts/workbench_saved_results.py@@ -2039,12 +2039,12 @@ def coverage_for_comparison(db: Any, scan: Any) -> dict[str, Any]:scan_dir = db.require_canonical_scan_directory(Path(scan["scan_dir"]))db.require_recorded_manifest_digest(scan, scan_dir)try:- _, _, manifest, _, coverage, was_sealed, _ = _prepare_scan_finalization(scan_dir)+ prepared = _prepare_scan_finalization(scan_dir)except ContractError as exc:raise SystemExit(str(exc)) from exc- if not was_sealed or manifest["scan"]["id"] != scan["id"]:+ if not prepared.was_sealed or prepared.manifest["scan"]["id"] != scan["id"]:raise SystemExit("Only sealed scans can be compared.")- return coverage+ return prepared.coveragedef _snapshot_published_outputs(scan_dir: Path) -> dict[str, bytes | None]:@@ -2272,10 +2272,11 @@ def preserve_scan_results_locked(scan_dir,expected_coverage_mode=db.expected_coverage_mode(scan),completion_binding=binding,- completion_warnings=warnings,+ recover_unsealed=True,draft_documents=documents,finding_scope=db.requested_finding_scope(scan) if scan["mode"] == "deep" else None,)+ warnings.extend(prepared.warnings)snapshots = _snapshot_published_outputs(scan_dir)try:manifest, findings, _ = _write_prepared_scan_finalization(diff --git a/plugins/codex-security/tests/test_deep_scan_successful_publication.py b/plugins/codex-security/tests/test_deep_scan_successful_publication.pyindex 57e5d4d28..af8bb75b7 100644--- a/plugins/codex-security/tests/test_deep_scan_successful_publication.py+++ b/plugins/codex-security/tests/test_deep_scan_successful_publication.py@@ -371,6 +371,118 @@ def test_deep_prepare_and_complete_preserve_the_same_aggregate(assert_published_aggregate(scan)[email protected]_platform[email protected]("scope", [".", "subdir"])[email protected]("missing_parent", [False, True])+def test_deep_completion_preserves_findings_with_missing_optional_writeups(+ workbench_api, workbench_db, publication_scan, scope, missing_parent+):+ scan = publication_scan(scope=scope)+ valid_path = "findings/valid/valid.md"+ valid_file = scan.scan_dir / valid_path+ valid_file.parent.mkdir(parents=True)+ valid_file.write_text("# Retained writeup\n")+ scan.findings[0]["writeup"] = {"reportPath": valid_path}+ missing = copy.deepcopy(scan.findings[0])+ missing["identity"]["anchor"] = "missing-writeup"+ missing["summary"] = "A separate finding whose optional writeup was not transferred."+ missing_path = "findings/missing/missing.md"+ if not missing_parent:+ (scan.scan_dir / missing_path).parent.mkdir()+ missing["writeup"] = {"reportPath": missing_path}+ scan.findings.append(missing)+ if scope != ".":+ excluded = copy.deepcopy(missing)+ excluded["identity"]["anchor"] = "excluded-writeup"+ excluded["locations"] = [{"path": "unrelated/extract.py", "startLine": 1}]+ excluded["writeup"] = {"reportPath": "findings/excluded/excluded.md"}+ scan.findings.insert(0, excluded)+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))+ original_files = {valid_file: valid_file.read_bytes()}+ for kind in ("discovery", "dedup"):+ result = add_worker(workbench_db, scan)+ result.write_text(+ json.dumps(saved_draft(scan.scan_id, findings=scan.findings, complete=True))+ )+ checkpoint = write_checkpoint(result.parent / "checkpoints", json.loads(result.read_text()))+ original_files.update({path: path.read_bytes() for path in (result, checkpoint)})+ with workbench_db:+ workbench_db.execute(+ "UPDATE deep_scan_workers SET kind = ?, merge_state = 'none' "+ "WHERE result_manifest_path = ?",+ (kind, str(result)),+ )++ # Preparing and then completing also exercises replay of the sealed parent.+ prepared = complete(workbench_api, workbench_db, scan, prepare_only=True)+ completed = complete(workbench_api, workbench_db, scan)++ assert completed["progress"]["status"] == "complete"+ assert completed["findingCount"] == 2+ assert len(completed["warnings"]) == 1+ assert completed["warnings"] == prepared["warnings"]+ assert completed["warnings"][0].startswith("Skipped missing writeup for finding 2:")+ assert "findings[1].writeup.reportPath" in completed["warnings"][0]+ if scope != ".":+ scan.findings.pop(0)+ missing.pop("writeup")+ assert_published_aggregate(scan)+ assert {path: path.read_bytes() for path in original_files} == original_files+ report = (scan.scan_dir / "report.md").read_text()+ assert valid_path in report+ assert missing_path not in report+ assert missing["summary"] in report+ manifest = json.loads((scan.scan_dir / "scan-manifest.json").read_text())+ assert manifest["scan"]["status"] == "completed"+ assert manifest["scan"]["sealedAt"]++[email protected]_platform[email protected]("invalid", ["unsafe-path", "directory"])+def test_deep_scope_filter_does_not_hide_invalid_writeups(+ workbench_api, workbench_db, publication_scan, invalid+):+ scan = publication_scan(scope="subdir")+ finding = scan.findings[0]+ finding["locations"] = [{"path": "unrelated/extract.py", "startLine": 1}]+ report_path = "findings/invalid/invalid.md"+ if invalid == "unsafe-path":+ report_path = "../invalid.md"+ else:+ (scan.scan_dir / report_path).mkdir(parents=True)+ finding["writeup"] = {"reportPath": report_path}+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))++ with pytest.raises(SystemExit, match="reportPath|regular non-symlink file"):+ complete(workbench_api, workbench_db, scan)+ assert (+ workbench_db.execute("SELECT status FROM scans WHERE id = ?", (scan.scan_id,)).fetchone()[0]+ != "complete"+ )++[email protected]_platform[email protected]("invalid", ["finding", "coverage"])+def test_missing_deep_writeup_does_not_enable_general_recovery(+ workbench_api, workbench_db, publication_scan, invalid+):+ scan = publication_scan()+ scan.findings[0]["writeup"] = {"reportPath": "findings/missing/missing.md"}+ if invalid == "finding":+ scan.findings[0]["severity"]["level"] = "invalid"+ else:+ scan.coverage["completeness"] = "invalid"+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))+ (scan.scan_dir / "coverage.json").write_text(json.dumps(scan.coverage))++ with pytest.raises(SystemExit, match="severity|completeness"):+ complete(workbench_api, workbench_db, scan)+ assert (+ workbench_db.execute("SELECT status FROM scans WHERE id = ?", (scan.scan_id,)).fetchone()[0]+ != "complete"+ )++@pytest.mark.parametrize(("source", "scope", "has_parent"),[@@ -543,22 +655,35 @@ def test_standard_publication_preserves_deliberately_partial_coverage(assert_published_aggregate(scan)[email protected]_platform[email protected]("missing_writeup", [False, True])[email protected]("interrupted_file", ["findings.json", "report.md"])def test_deep_publication_write_failure_keeps_original_terminal_cause(- workbench_api, workbench_db, publication_scan, monkeypatch+ workbench_api, workbench_db, publication_scan, monkeypatch, missing_writeup, interrupted_file):scan = publication_scan()+ if missing_writeup:+ scan.findings[0]["writeup"] = {"reportPath": "findings/missing/missing.md"}+ (scan.scan_dir / "findings.json").write_text(json.dumps({"findings": scan.findings}))finalizer_globals = workbench_api["_write_prepared_scan_finalization"].__globals__write_bytes = finalizer_globals["write_scan_local_bytes"]def fail_report(scan_dir, relative_path, payload, **kwargs):- if relative_path == "report.md":+ if relative_path == interrupted_file:raise finalizer_globals["ContractError"]("Synthetic report write interruption")return write_bytes(scan_dir, relative_path, payload, **kwargs)with monkeypatch.context() as patch:patch.setitem(finalizer_globals, "write_scan_local_bytes", fail_report)- with pytest.raises(SystemExit, match="Synthetic report write interruption"):- complete(workbench_api, workbench_db, scan)+ for _ in range(2):+ with pytest.raises(SystemExit, match="Synthetic report write interruption"):+ complete(workbench_api, workbench_db, scan)+ warnings = json.loads(+ workbench_db.execute(+ "SELECT completion_warnings_json FROM scans WHERE id = ?", (scan.scan_id,)+ ).fetchone()[0]+ )+ assert len(warnings) == int(missing_writeup)assert (workbench_db.execute("SELECT status FROM scans WHERE id = ?", (scan.scan_id,)).fetchone()[0]@@ -568,7 +693,11 @@ def test_deep_publication_write_failure_keeps_original_terminal_cause("SELECT status, terminal_reason FROM deep_scan_runs WHERE scan_id = ?", (scan.scan_id,)).fetchone()assert tuple(run) == ("succeeded", "saturated")- assert complete(workbench_api, workbench_db, scan)["progress"]["status"] == "complete"+ completed = complete(workbench_api, workbench_db, scan)+ assert completed["progress"]["status"] == "complete"+ assert completed["warnings"] == warnings+ if missing_writeup:+ scan.findings[0].pop("writeup")assert_published_aggregate(scan)diff --git a/plugins/codex-security/tests/test_finalize_scan_contract.py b/plugins/codex-security/tests/test_finalize_scan_contract.pyindex 1919dc4e9..b478941b7 100644--- a/plugins/codex-security/tests/test_finalize_scan_contract.py+++ b/plugins/codex-security/tests/test_finalize_scan_contract.py@@ -672,6 +672,11 @@ The extraction root is not enforced.with self.assertRaisesRegex(FINALIZER.ContractError, "expected a file inside"):FINALIZER.finalize_scan(self.scan_dir)+ with self.assertRaisesRegex(FINALIZER.ContractError, "expected a file inside"):+ FINALIZER._prepare_scan_finalization(+ self.scan_dir, finding_scope=[("unrelated", False)]+ )+writeup_path = self.scan_dir / report_pathwriteup_path.parent.mkdir(parents=True)writeup_path.mkdir()@@ -684,6 +689,12 @@ The extraction root is not enforced.writeup_path.unlink()with self.assertRaisesRegex(FINALIZER.ContractError, "expected a file inside"):FINALIZER.finalize_scan(self.scan_dir)+ sealed_files = {name: (self.scan_dir / name).read_bytes() for name in CANONICAL_FILES}+ with self.assertRaises(FINALIZER.ContractError):+ FINALIZER._prepare_scan_finalization(self.scan_dir, allow_missing_writeups=True)+ self.assertEqual(+ {name: (self.scan_dir / name).read_bytes() for name in CANONICAL_FILES}, sealed_files+ )def test_finalize_requires_hardening_portfolio_to_be_regular_scan_local_file(self) -> None:portfolio_path = "hardening/hardening.md"@@ -2062,10 +2073,8 @@ The extraction root is not enforced.with self.assertRaisesRegex(FINALIZER.ContractError, "missing from sealed artifacts"):FINALIZER.finalize_scan(self.scan_dir)- warnings: list[str] = []with self.assertRaisesRegex(FINALIZER.ContractError, "missing from sealed artifacts"):- FINALIZER._prepare_scan_finalization(self.scan_dir, completion_warnings=warnings)- self.assertEqual(warnings, [])+ FINALIZER._prepare_scan_finalization(self.scan_dir, recover_unsealed=True)def test_fingerprint_survives_line_movement_and_file_rename(self) -> None:renamed = copy.deepcopy(self.finding)@@ -2160,18 +2169,19 @@ The extraction root is not enforced."Lower if the input is constrained before parsing.",]self.write_scan()- warnings: list[str] = []- prepared = FINALIZER._prepare_scan_finalization(self.scan_dir, completion_warnings=warnings)+ prepared = FINALIZER._prepare_scan_finalization(self.scan_dir, recover_unsealed=True)- finding = prepared[3]["findings"][0]+ finding = prepared.findings["findings"][0]self.assertEqual(finding["severity"]["changeConditions"],"Raise if the vulnerable path becomes internet-reachable. ""Lower if the input is constrained before parsing.",)- self.assertEqual(warnings, ["Recovered finding 1: normalized severity change conditions."])- self.assertEqual(prepared[4]["completeness"], "complete")+ self.assertEqual(+ prepared.warnings, ["Recovered finding 1: normalized severity change conditions."]+ )+ self.assertEqual(prepared.coverage["completeness"], "complete")@pytest.mark.cross_platformdef test_recovery_ranks_legacy_and_canonical_code_evidence_equally(self) -> None:@@ -2197,17 +2207,16 @@ The extraction root is not enforced.second["root_cause"] = Noneself.findings["findings"] = [first, second]self.write_scan()- warnings: list[str] = []prepared = FINALIZER._prepare_scan_finalization(- self.scan_dir, completion_warnings=warnings+ self.scan_dir, recover_unsealed=True)- self.assertEqual(prepared[3]["findings"][0]["summary"], "SECOND")- self.assertIsNone(prepared[3]["findings"][0]["root_cause"])- self.assertEqual(prepared[3]["findings"][0][evidence_field], [evidence])+ self.assertEqual(prepared.findings["findings"][0]["summary"], "SECOND")+ self.assertIsNone(prepared.findings["findings"][0]["root_cause"])+ self.assertEqual(prepared.findings["findings"][0][evidence_field], [evidence])self.assertEqual(- warnings,+ prepared.warnings,["Recovered finding 2: retained stronger duplicate logical finding."],)@@ -2235,15 +2244,14 @@ The extraction root is not enforced.second["rootCause"] = root_causeself.findings["findings"] = [first, second]self.write_scan()- warnings: list[str] = []prepared = FINALIZER._prepare_scan_finalization(- self.scan_dir, completion_warnings=warnings+ self.scan_dir, recover_unsealed=True)- self.assertEqual(prepared[3]["findings"][0]["summary"], "SECOND")+ self.assertEqual(prepared.findings["findings"][0]["summary"], "SECOND")self.assertEqual(- warnings,+ prepared.warnings,["Recovered finding 2: retained stronger duplicate logical finding."],)@@ -2252,16 +2260,15 @@ The extraction root is not enforced.with self.subTest(change_conditions=repr(change_conditions)):self.findings["findings"][0]["severity"]["changeConditions"] = change_conditionsself.write_scan()- warnings: list[str] = []prepared = FINALIZER._prepare_scan_finalization(- self.scan_dir, completion_warnings=warnings+ self.scan_dir, recover_unsealed=True)- self.assertEqual(prepared[3]["findings"], [])- self.assertEqual(prepared[4]["completeness"], "partial")- self.assertEqual(len(warnings), 1)- self.assertIn("severity.changeConditions", warnings[0])+ self.assertEqual(prepared.findings["findings"], [])+ self.assertEqual(prepared.coverage["completeness"], "partial")+ self.assertEqual(len(prepared.warnings), 1)+ self.assertIn("severity.changeConditions", prepared.warnings[0])def test_unsealed_invalid_anchor_stays_strict_without_recovery(self) -> None:self.findings["findings"][0]["identity"]["anchor"] = "Invalid Anchor"@@ -2279,18 +2286,20 @@ The extraction root is not enforced.with self.subTest(field=field, value=value):self.findings["findings"][0][field] = valueself.write_scan()- warnings: list[str] = []- _, _, _, findings, coverage, _, _ = FINALIZER._prepare_scan_finalization(+ prepared = FINALIZER._prepare_scan_finalization(self.scan_dir,- completion_warnings=warnings,+ recover_unsealed=True,)- self.assertEqual(len(findings["findings"]), 1)- self.assertNotIn(field, findings["findings"][0])- self.assertEqual(coverage["completeness"], "complete")+ self.assertEqual(len(prepared.findings["findings"]), 1)+ self.assertNotIn(field, prepared.findings["findings"][0])+ self.assertEqual(prepared.coverage["completeness"], "complete")self.assertTrue(- any(warning.startswith(f"Skipped malformed {field}") for warning in warnings)+ any(+ warning.startswith(f"Skipped malformed {field}")+ for warning in prepared.warnings+ ))self.findings["findings"][0].pop(field)@@ -2299,18 +2308,19 @@ The extraction root is not enforced.finding["remediationTests"] = ["Reject unsafe archive paths."]finding["preventiveControls"] = ["Validate every archive path."]self.write_scan()- warnings: list[str] = []- _, _, _, findings, _, _, _ = FINALIZER._prepare_scan_finalization(+ prepared = FINALIZER._prepare_scan_finalization(self.scan_dir,- completion_warnings=warnings,+ recover_unsealed=True,)- self.assertEqual(findings["findings"][0]["remediationTests"], finding["remediationTests"])self.assertEqual(- findings["findings"][0]["preventiveControls"], finding["preventiveControls"]+ prepared.findings["findings"][0]["remediationTests"], finding["remediationTests"])- self.assertFalse(warnings)+ self.assertEqual(+ prepared.findings["findings"][0]["preventiveControls"], finding["preventiveControls"]+ )+ self.assertFalse(prepared.warnings)def test_recovery_publishes_findings_without_unsafe_deferred_paths(self) -> None:valid = {"id": "review", "reason": "Repository review is incomplete.", "paths": ["."]}@@ -2322,9 +2332,8 @@ The extraction root is not enforced.with self.subTest(status=status):self.write_scan()binding = {**self.completion_binding(), "status": status}- warnings: list[str] = []prepared = FINALIZER._prepare_scan_finalization(- self.scan_dir, completion_binding=binding, completion_warnings=warnings+ self.scan_dir, completion_binding=binding, recover_unsealed=True)manifest, findings, coverage = FINALIZER._write_prepared_scan_finalization(prepared)@@ -2336,7 +2345,7 @@ The extraction root is not enforced.self.assertTrue(any("Skipped malformed deferred coverage item 1" in warning- for warning in warnings+ for warning in prepared.warnings))self.assertEqual(self.read_json("findings.json"), findings)@@ -3143,6 +3152,61 @@ def test_schema_numeric_types_do_not_accept_booleans(expected, value) -> None:FINALIZER._validate_schema_node(True, schema, "value")[email protected](os.name == "nt", reason="POSIX symlinks and file permissions")+ "kind", ["unsafe", "symlink", "dangling-symlink", "parent-symlink", "directory", "unreadable"]+)+def test_missing_writeup_recovery_rejects_other_file_errors(tmp_path, kind):+ scan_dir = tmp_path / "scan"+ scan_dir.mkdir()+ report = scan_dir / "findings" / "report.md"+ report.parent.mkdir()+ outside = tmp_path / "outside.md"+ outside.write_text("# Outside the scan\n")+ report_path = "findings/report.md"+ if kind == "unsafe":+ report_path = "../outside.md"+ elif kind == "symlink":+ report.symlink_to(outside)+ elif kind == "dangling-symlink":+ report.symlink_to(report.parent / "missing.md")+ elif kind == "parent-symlink":+ report.parent.rmdir()+ report.parent.symlink_to(tmp_path, target_is_directory=True)+ elif kind == "directory":+ report.mkdir()+ else:+ if os.geteuid() == 0:+ pytest.skip("root can read files without permission bits")+ report.write_text("# Unreadable writeup\n")+ report.chmod(0)+ findings = {"findings": [{"writeup": {"reportPath": report_path}}]}+ original = copy.deepcopy(findings)+ with pytest.raises(FINALIZER.ContractError):+ FINALIZER._prepare_derived_writeups(scan_dir, findings, allow_missing=True)+ assert findings == original++[email protected]_platform[email protected]("error_code", [2, 3, 5, 22, 32, 33])+def test_windows_writeup_recovery_only_omits_missing_files(tmp_path, monkeypatch, error_code):+ backend = windows_file_backend()+ windows_error = load_script("windows_scan_local_files").WindowsScanLocalFileError+ backend.open_read_fd.side_effect = windows_error(error_code, "Synthetic Windows file error")+ monkeypatch.setattr(FINALIZER.os, "supports_dir_fd", set())+ monkeypatch.setattr(FINALIZER, "_is_windows", lambda: True)+ monkeypatch.setattr(FINALIZER, "_windows_scan_local_files", lambda: backend)+ findings = {"findings": [{"writeup": {"reportPath": "findings/report.md"}}]}+ if error_code in {2, 3}:+ warnings = FINALIZER._prepare_derived_writeups(tmp_path, findings, allow_missing=True)+ assert findings == {"findings": [{}]}+ assert len(warnings) == 1+ else:+ with pytest.raises(FINALIZER.ContractError):+ FINALIZER._prepare_derived_writeups(tmp_path, findings, allow_missing=True)+ assert "writeup" in findings["findings"][0]++def test_schema_references_preserve_constraints_siblings_and_cycle_errors() -> None:root = {"$defs": {"text": {"type": "string", "minLength": 1}}}reference = {"$ref": "#/$defs/text"}diff --git a/plugins/codex-security/tests/test_saved_deferred_identity.py b/plugins/codex-security/tests/test_saved_deferred_identity.pyindex 31bfacf8e..031a09431 100644--- a/plugins/codex-security/tests/test_saved_deferred_identity.py+++ b/plugins/codex-security/tests/test_saved_deferred_identity.py@@ -137,7 +137,7 @@ def cancel_and_preserve(monkeypatch, saved_results, state, codex_home, scan_dir,prepared_coverage = []def fail_publication(prepared, *, projection_warnings=None):- prepared_coverage.append(prepared[4])+ prepared_coverage.append(prepared.coverage)raise OSError("injected publication failure")with monkeypatch.context() as patch:diff --git a/plugins/codex-security/tests/test_workbench_checkpoint_heads.py b/plugins/codex-security/tests/test_workbench_checkpoint_heads.pyindex 633a8b237..5e6a8d006 100644--- a/plugins/codex-security/tests/test_workbench_checkpoint_heads.py+++ b/plugins/codex-security/tests/test_workbench_checkpoint_heads.py@@ -913,7 +913,7 @@ def test_parent_head_selection_matches_frozen_publication_retry(first = []def fail_publication(prepared, *, projection_warnings=None):- first.append(copy.deepcopy((prepared[3], prepared[4])))+ first.append(copy.deepcopy((prepared.findings, prepared.coverage)))raise OSError("injected stopped publication failure")with monkeypatch.context() as patch:diff --git a/plugins/codex-security/tests/test_workbench_standard_deep_results.py b/plugins/codex-security/tests/test_workbench_standard_deep_results.pyindex d49a1fc91..0da4f6278 100644--- a/plugins/codex-security/tests/test_workbench_standard_deep_results.py+++ b/plugins/codex-security/tests/test_workbench_standard_deep_results.py@@ -774,6 +774,7 @@ def test_canceled_scan_retries_failed_publication_from_frozen_sources(state_dir, codex_home, target, scan_dir, scan_id = deep_scan_fixture(tmp_path)worker_id, result_path = accepted_standard_worker(state_dir, codex_home, scan_dir, scan_id)finding = standard_finding(tmp_path, scan_id, target)+ finding["severity"]["changeConditions"] = ["Raise if the service becomes internet-reachable."]checkpoint = saved_draft(scan_id, findings=[finding], completeness="partial")write_checkpoint(result_path.parent / "checkpoints", checkpoint)result_path.write_text("{incomplete")@@ -816,6 +817,9 @@ def test_canceled_scan_retries_failed_publication_from_frozen_sources()["scan"]assert preserved["findingCount"] == 1assert preserved["findings"][0]["locations"][0]["startLine"] != 91+ assert preserved["findings"][0]["severity"]["changeConditions"] == (+ "Raise if the service becomes internet-reachable."+ )assert json.loads((scan_dir / "scan-manifest.json").read_text())["scan"]["status"] == "canceled"with sqlite3.connect(state_dir / "workbench.sqlite3") as connection:warnings = json.loads(@@ -824,6 +828,8 @@ def test_canceled_scan_retries_failed_publication_from_frozen_sources().fetchone()[0])assert not any("result publication needs follow-up" in warning for warning in warnings)+ assert "Recovered finding 1: normalized severity change conditions." in warnings+ assert preserved["warnings"] == warnings@pytest.mark.parametrize("deep_status", ["failed", "interrupted"])@@ -2466,7 +2472,7 @@ def test_recovery_rejects_closures_that_would_discard_saved_evidence()assert documents is not Noneprepared = workbench_saved_results._prepare_scan_finalization(- scan_dir, completion_binding=binding, completion_warnings=[], draft_documents=documents+ scan_dir, completion_binding=binding, recover_unsealed=True, draft_documents=documents)workbench_saved_results._write_prepared_scan_finalization(prepared)recovered = json.loads((scan_dir / "coverage.json").read_text())