← Codex SecurityCONTENT HISTORY

Update to Codex Security

Snapshot Nov 18, 2026 · 06:12 UTC · version 0.1.33

WHAT CHANGED

Package or technical metadata updated

Package or technical metadata updated

Observed in package metadata. These changes alone do not establish a new customer-facing feature.

Save Codex Security and check future changes in Following.

Up to 3 plugins free · no card required.

All fields and original values.

These are saved file metadata. Open a changed file to read its text edits.

Package file

Before

Oct 7, 2026 · 06:02 UTC

527d1a0db286884729572d400b0ad9b0ff852d4a12b36228ff5fbef180f7de9d

After

Nov 18, 2026 · 06:12 UTC

3766646eafb09a5e691657999f4f423c9652bbac286c0e0f55e179169aa97e99

Package file

Before

Oct 7, 2026 · 06:02 UTC

1582

After

Nov 18, 2026 · 06:12 UTC

1846

Package file

Before

Oct 7, 2026 · 06:02 UTC

7c5968060f6e848859ce02450d6e02e67029d8d39011bbda1059b19de6309ebf

After

Nov 18, 2026 · 06:12 UTC

69bbc0f86c92397eb7540ff09c17d69d429b0dc45dc1de3e02b16d101adfe7c0

Package file

Before

Oct 7, 2026 · 06:02 UTC

1679

After

Nov 18, 2026 · 06:12 UTC

2078

Compare saved observations

Download comparison JSON

Changed files

Choose a file to see its text changes. Binary or large files show metadata only.

.codex-plugin/plugin.json →

.mcp.json →

examples/completed-scan/coverage.json →

examples/completed-scan/findings.json →

examples/completed-scan/report.md →

examples/completed-scan/scan-manifest.json →

examples/legacy-completed-scan/coverage.json →

examples/legacy-completed-scan/findings.json →

examples/legacy-completed-scan/report.md →

examples/legacy-completed-scan/scan-manifest.json →

integrity.json →

mcp/fzstd-LICENSE.txt →

mcp/helpers.mjs →

mcp/helpers.mjs.br →

mcp/helpers.mjs.br.part-000 →

mcp/native/THIRD_PARTY_NOTICES.txt →

mcp/native/darwin-arm64/unix.node →

mcp/native/darwin-x64/unix.node →

mcp/native/linux-arm64-gnu/unix.node →

mcp/native/linux-arm64-musl/unix.node →

mcp/native/linux-x64-gnu/unix.node →

mcp/native/linux-x64-musl/unix.node →

mcp/native/win32-arm64/windows.node →

mcp/native/win32-x64/windows.node →

mcp/package.json →

mcp/permission-profile-preflight.mjs →

mcp/server.mjs →

mcp/server.mjs.br →

mcp/server.mjs.br.part-000 →

mcp/server.mjs.br.part-001 →

mcp/session-decompression.mjs →

preflight/capability-profiles.toml →

references/access-advisory.md →

references/artifact-storage.md →

references/baseline-auditor.md →

references/config-preflight.md →

references/core-scan.md →

references/default-severity-rubric.md →

references/desktop-config-preflight.md →

references/final-report.md →

references/finding-detail-fields.md →

references/focused-investigator.md →

references/investigation-time-budget.md →

references/sarif-adapter.md →

references/scan-artifacts.md →

references/scan-contract.md →

references/scan-prologue.md →

references/scan-runtime.md →

references/security-guidance.md →

references/standalone-validation.md →

references/threat-model.md →

references/validate-scan-findings.md →

schemas/coverage.schema.json →

schemas/definitions/artifact-common.schema.json →

schemas/definitions/discovery-candidate.schema.json →

schemas/findings.schema.json →

schemas/patch-risk-assessment.schema.json →

schemas/scan-manifest.schema.json →

schemas/tools/candidate-attack-paths.schema.json →

schemas/tools/candidate-validations.schema.json →

schemas/tools/deep-reducer.schema.json →

schemas/tools/discovery-candidates.schema.json →

schemas/tools/review-items.schema.json →

schemas/tools/scan-draft.schema.json →

schemas/tools/worker-threat-model.schema.json →

scripts/check_deep_scan_target.py →

scripts/codex_profile.mjs →

scripts/codex_session.mjs →

scripts/config_preflight.py →

scripts/deep_scan_config.py →

scripts/deep_scan_workbench.py →

scripts/dispatch_inventory_tool →

scripts/filesystem_identity.py →

scripts/finalize_scan_contract.py →

scripts/finding_preview.py →

scripts/generate_in_scope_files.py →

scripts/generate_rank_input.py →

scripts/launch_codex_security_mcp →

scripts/launch_codex_security_mcp.cmd →

scripts/legacy_findings.py →

scripts/posix_scan_local_files.py →

scripts/rank_preview.py →

scripts/read_codex_session.mjs →

scripts/report_projection.py →

scripts/review_state.py →

scripts/servicenow_avit.py →

scripts/snapshot_sqlite.py →

scripts/threat_model_projection.py →

scripts/validate_scan_contract.py →

scripts/validate_tracking_source.py →

scripts/windows_scan_local_files.py →

scripts/workbench/__init__.py →

scripts/workbench/handoff.py →

scripts/workbench/retained_coverage.py →

scripts/workbench/retained_records.py →

scripts/workbench/runtime_toml.py →

scripts/workbench/saved_coverage.py →

scripts/workbench/saved_outputs.py →

scripts/workbench/saved_sources.py →

scripts/workbench/storage.py →

scripts/workbench_cli.py →

scripts/workbench_constants.py →

scripts/workbench_coverage_receipts.py →

scripts/workbench_dashboard.py →

scripts/workbench_db.py →

scripts/workbench_feedback.py →

scripts/workbench_finding_index.py →

scripts/workbench_finding_workflows.py →

scripts/workbench_findings.py →

scripts/workbench_native_indexes.py →

scripts/workbench_progress.py →

scripts/workbench_publication.py →

scripts/workbench_remediation.py →

scripts/workbench_saved_results.py →

scripts/workbench_scan_history.py →

scripts/workbench_scan_start.py →

scripts/workbench_scan_usage.py →

scripts/workbench_schema.py →

scripts/workbench_setup.py →

scripts/workbench_severity.py →

scripts/workbench_source_excerpt.py →

scripts/workbench_source_scopes.py →

scripts/workbench_target.py →

scripts/workbench_target_state.py →

scripts/workbench_validation.py →

shared/workbench-history-repairs.json →

shared/workbench-migrations.json →

skills/assess-patch-risk/SKILL.md →

skills/assess-patch-risk/references/windows-validation.md →

skills/attack-path-analysis/SKILL.md →

skills/attack-path-analysis/references/attack-path-facts.md →

skills/attack-path-analysis/references/severity-policy.md →

skills/check-skills/SKILL.md →

skills/check-skills/agents/openai.yaml →

skills/cloud-findings/SKILL.md →

skills/cloud-findings/agents/openai.yaml →

skills/deep-security-scan/SKILL.md →

skills/define-security-policy/SKILL.md →

skills/finding-discovery/SKILL.md →

skills/fix-finding/SKILL.md →

skills/propose-security-hardening/SKILL.md →

skills/propose-security-hardening/references/proposal-format.md →

skills/publish-findings/SKILL.md →

skills/publish-findings/agents/openai.yaml →

skills/publish-findings/references/checkmarx-import.md →

skills/publish-findings/references/wiz-import.md →

skills/publish-findings/scripts/collect_checkmarx.py →

skills/publish-findings/scripts/collector_paths.py →

skills/resolve-dependency-alert/SKILL.md →

skills/resolve-dependency-alert/agents/openai.yaml →

skills/security-diff-scan/SKILL.md →

skills/security-scan/SKILL.md →

skills/security-scan/agents/openai.yaml →

skills/security-scan/references/desktop-scan.md →

skills/security-scan/references/managed-scan.md →

skills/security-scan/references/scan-artifacts-and-ledger.md →

skills/security-scan/references/scan-results.md →

skills/security-scan/references/scoped-paths.md →

skills/security-scan/references/sdk-files.md →

skills/threat-model-visualize/SKILL.md →

skills/threat-model-visualize/agents/openai.yaml →

skills/threat-model-visualize/assets/context-reference-overview.svg →

skills/threat-model-visualize/assets/context-reference-path.svg →

skills/threat-model-visualize/assets/control-effects.js →

skills/threat-model-visualize/assets/explorer.css →

skills/threat-model-visualize/assets/explorer.html →

skills/threat-model-visualize/assets/explorer.js →

skills/threat-model-visualize/assets/route-paths.js →

skills/threat-model-visualize/assets/source-roles.js →

skills/threat-model-visualize/assets/svg-layout.js →

skills/threat-model-visualize/references/context-explorer.md →

skills/threat-model-visualize/references/view-model.md →

skills/threat-model-visualize/scripts/build_explorer.py →

skills/threat-model/SKILL.md →

skills/track-findings/SKILL.md →

skills/track-findings/references/github-security-advisories.md →

skills/triage-finding/SKILL.md →

skills/triage-finding/references/github-rest-intake.md →

skills/triage-finding/references/ticket-intake.md →

skills/validation/SKILL.md →

skills/validation/references/validation-guidance.md →

skills/verify-fix/SKILL.md →

skills/vulnerability-writeup/SKILL.md →

skills/vulnerability-writeup/references/report-format.md →

scripts/workbench/retained_coverage.py

− removed · + added

--- before
+++ after
@@ -0,0 +1,3193 @@
+"""Retain semantic scan drafts without rerunning analysis or changing run state."""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import os
+from collections import Counter, deque
+from functools import partial
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from finalize_scan_contract import (
+    ContractError,
+    _finding_strength,
+    _read_json,
+    _recover_unsealed_findings,
+    _require_safe_json_value,
+    _validate_schema_node,
+    finding_candidate_id,
+    write_scan_local_bytes,
+)
+from review_state import uses_legacy_review
+from workbench.retained_records import (
+    _append_previous_finding,
+    _competing_rejection_receipts,
+    _conflicting_outcome_receipts,
+    _ensure_finding_identities,
+    _ensure_finding_identity,
+    _finding_content,
+    _finding_identity,
+    _finding_key,
+    _identity_candidate,
+    _recover_preserved_worker_coverage,
+    _recover_preserved_worker_source,
+    _retained_findings,
+    _saved_candidate_outcomes,
+    _semantic_identity_key,
+    _worker_candidate_key,
+    contains_raw_value,
+    distinct_reports,
+    identifiers,
+    raw_owner,
+    raw_scope,
+    same_raw_content,
+    same_raw_finding,
+    same_raw_value,
+)
+from workbench.saved_coverage import (
+    SavedCoverageProjection,
+    _coverage_rows,
+    _has_candidate_metadata,
+    _inherit_coverage_sources,
+    _merge_tied_parent_observations,
+    _parent_observation_content,
+    _project_worker_closure,
+    _projected_worker_closure_sources,
+    _resolved_deferred_rows,
+    prepare_saved_coverage_projection,
+)
+from workbench.saved_sources import (
+    _capture_parent_observation,
+    _capture_saved_source,
+    _checkpoint_head_directory,
+    _checkpoint_paths,
+    _CheckpointSnapshotError,
+    _digest,
+    _encoded,
+    _freeze_source_times,
+    _frozen_checkpoint_heads,
+    _frozen_source_times,
+    _is_source_order_snapshot,
+    _iteration_order,
+    _latest_iteration,
+    _model_capture,
+    _parent_publication_ancestors,
+    _read_saved_parent_result,
+    _read_saved_result,
+    _unselected_root_order,
+    _worker_outputs,
+)
+from workbench_coverage_receipts import (
+    _deferred_candidate_id,
+    _generic_surface_updates,
+    receipt_checkpoints,
+    resolve_coverage_receipts,
+    retain_recorded_receipt_ownership,
+)
+from workbench_target import committed_diff_snapshot_digest
+from workbench_validation import javascript_utf8, path_within_scope
+
+
+def merge_saved_results(
+    scan_dir: Path,
+    scan_id: str,
+    binding: dict[str, Any],
+    workers: list[Any],
+    warnings: list[str],
+    *,
+    stopped: bool,
+    reason: str,
+    scan_mode: str | None = None,
+    frozen_source_digests: dict[str, str] | None = None,
+    checkpoint_heads: dict[str, str | None] | None = None,
+    allow_frozen_legacy_parent: bool = False,
+    parent_already_captured: bool = False,
+    frozen_model_source: str | None = None,
+    selected_model_source: list[str] | None = None,
+    canonical_model: dict[str, Any] | None = None,
+    canonical_model_source: str | None = None,
+    canonical_sources: dict[str, str] | None = None,
+    finding_scope: list[tuple[str, bool]] | None = None,
+    preserve_canonical_parent: bool = False,
+    project_worker_coverage: bool = False,
+    created_paths: set[str] | None = None,
+    current_contract: bool = False,
+    recovery_snapshot_error: _CheckpointSnapshotError | None = None,
+) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]] | None:
+    """Reconcile the bound parent and worker checkpoints into an unsealed scan draft.
+
+    Return the manifest, findings document, and coverage document, or None when there
+    is no saved input or the sealed parent already reflects the selected checkpoints.
+    Frozen digests and heads identify the inputs selected when the scan stopped.
+    Recovery appends diagnostics to the caller's warnings list.
+    """
+    initial_warnings = set(warnings)
+    if frozen_source_digests is None:
+        checkpoint_heads = {}
+    snapshot_error = recovery_snapshot_error
+    captured_records = dict(snapshot_error.records) if snapshot_error is not None else {}
+
+    def capture_head(relative: str, canonical: Path | None = None) -> dict[str, tuple[str, int]]:
+        nonlocal snapshot_error
+        try:
+            if canonical is not None:
+                return _capture_parent_observation(
+                    scan_dir,
+                    scan_id,
+                    canonical.name,
+                    max(parent_modified, canonical.lstat().st_mtime_ns),
+                    allow_frozen_legacy_parent,
+                    created_paths=created_paths,
+                )
+            return _capture_saved_source(
+                scan_dir,
+                relative,
+                scan_id,
+                checkpoint_heads=checkpoint_heads,
+                created_paths=created_paths,
+            )
+        except _CheckpointSnapshotError as exc:
+            if "status" not in binding:
+                # A running coordinator can continue from its remaining evidence.
+                if checkpoint_heads is not None:
+                    checkpoint_heads.pop(Path(relative).parent.as_posix(), None)
+                raise
+            # Finish selection from captured bytes before freezing an I/O failure.
+            snapshot_error = snapshot_error or exc
+            captured_records.update(exc.records)
+            return exc.captured
+
+    parent_context = dict(recovery_snapshot_error.parent_context) if recovery_snapshot_error else {}
+    try:
+        source_times = _frozen_source_times(
+            scan_dir, scan_id, frozen_source_digests or {}, parent_context
+        )
+        if snapshot_error is not None:
+            source_times.update({path: item[1] for path, item in snapshot_error.captured.items()})
+    except (ContractError, OSError, ValueError) as exc:
+        raise ContractError("Frozen stopped-scan checkpoint set is incomplete.") from exc
+    parent: dict[str, Any] | None = None
+    frozen_parent_path: str | None = None
+    parent_manifest: dict[str, Any] | None = None
+    parent_is_canonical = False
+    parent_modified = 0
+    parent_model_source: str | None = None
+    canonical_model_order: tuple[int, int] | None = None
+    canonical_model_digest: str | None = None
+    if frozen_source_digests is None or (
+        allow_frozen_legacy_parent and not parent_already_captured
+    ):
+        try:
+            parent_manifest, parent = _read_saved_parent_result(scan_dir, scan_id)
+            # Without an accepted head, a file-authored draft is a full replacement.
+            parent_file = (
+                "coverage.json"
+                if uses_legacy_review(parent_manifest["scan"])
+                else "scan-manifest.json"
+            )
+            parent_modified = (scan_dir / parent_file).lstat().st_mtime_ns
+            parent_is_canonical = True
+        except (ContractError, OSError, ValueError) as exc:
+            if not stopped:
+                raise
+            if (scan_dir / "scan-manifest.json").exists():
+                warnings.append(f"Could not read the saved parent draft: {exc}")
+            parent_manifest = None
+            parent = None
+        if parent_manifest is not None and parent is not None and not preserve_canonical_parent:
+            parent_scan = parent_manifest["scan"]
+            try:
+                _, _, head_modified = _read_saved_result(scan_dir, "checkpoint-head.json", scan_id)
+            except (ContractError, OSError, ValueError):
+                head_modified = None
+            if head_modified is not None:
+                # A partial tool publication must not outrank its accepted head.
+                parent_modified = min(
+                    (scan_dir / name).lstat().st_mtime_ns
+                    for name in (
+                        "findings.json",
+                        "scan-manifest.json",
+                        *(["coverage.json"] if uses_legacy_review(parent_scan) else []),
+                    )
+                )
+            if not parent_scan.get("sealedAt") or allow_frozen_legacy_parent:
+                payload = _encoded(parent)
+                parent_digest = hashlib.sha256(payload).hexdigest()
+                parent_checkpoint = f"checkpoints/{parent_digest}.json"
+                if isinstance(parent.get("threatModel"), dict):
+                    canonical_model_source = parent_checkpoint
+                    parent_model_source = parent_checkpoint
+                    canonical_model_order = (0, parent_modified)
+                    canonical_model_digest = parent_digest
+                parent_context["canonical"] = parent_checkpoint
+                parent_context["canonicalObservedAtNs"] = str(parent_modified)
+                checkpoint_path = scan_dir / parent_checkpoint
+                if not checkpoint_path.exists():
+                    if created_paths is not None and not os.path.lexists(checkpoint_path):
+                        created_paths.add(parent_checkpoint)
+                    write_scan_local_bytes(scan_dir, parent_checkpoint, payload)
+                    # A recovery copy must not appear newer than the review it copies.
+                    os.utime(checkpoint_path, ns=(parent_modified, parent_modified))
+                captured = capture_head(
+                    "checkpoint-head.json", checkpoint_path if head_modified is None else None
+                )
+                if captured and (head_modified is not None or allow_frozen_legacy_parent):
+                    if checkpoint_heads is not None:
+                        checkpoint_heads["."] = next(iter(captured))
+                    parent_context["head"] = next(iter(captured))
+                if frozen_source_digests is not None:
+                    frozen_source_digests = {
+                        **frozen_source_digests,
+                        parent_checkpoint: parent_digest,
+                        **{path: value[0] for path, value in captured.items()},
+                    }
+
+    sources: list[tuple[str, dict[str, Any], str | None]] = []
+    parent_preserved_sources: dict[str, str] = {}
+    source_digests: dict[str, str] = {}
+    source_order: dict[str, tuple[int, int]] = {}
+    worker_attempts: dict[str, tuple[str, int]] = {}
+    saved_heads: dict[str, str] = {}
+    saved_inputs: dict[str, str] = {}
+    if parent_manifest:
+        recorded = parent_manifest["scan"].get("preservedSources", {})
+        if isinstance(recorded, dict):
+            parent_preserved_sources = recorded
+            source_digests.update(parent_preserved_sources)
+            if frozen_source_digests is None:
+                source_times.update(_frozen_source_times(scan_dir, scan_id, recorded))
+    paths: dict[str, str | None] = {}
+    reducer_paths: set[str] = set()
+    current_results: set[str] = set()
+    reducer_outputs: list[tuple[Any, str, list[str], int]] = []
+    reducer = _latest_iteration(workers)
+    latest_reducer: str | None = None
+    if reducer is not None:
+        try:
+            latest_reducer = Path(reducer["result_manifest_path"]).relative_to(scan_dir).as_posix()
+            paths[latest_reducer] = None
+            reducer_paths.add(latest_reducer)
+        except ValueError:
+            warnings.append("Skipped a reducer result outside the scan directory.")
+
+    def checkpoints(directory: str, worker_id: str | None, attempt: int = 0) -> None:
+        if worker_id is not None:
+            root = Path(directory).parent.as_posix()
+            worker_attempts[root] = (worker_id, attempt)
+            paths[f"{root}/checkpoint-head.json"] = worker_id
+        head_snapshots = (Path(directory).parent / "checkpoint-heads").as_posix()
+        for saved_directory in (directory, head_snapshots):
+            paths.update(dict.fromkeys(_checkpoint_paths(scan_dir, saved_directory), worker_id))
+
+    if not preserve_canonical_parent:
+        paths["checkpoint-head.json"] = None
+        checkpoints("checkpoints", None)
+    for worker in workers:
+        try:
+            outputs = _worker_outputs(scan_dir, worker)
+        except (TypeError, ValueError):
+            warnings.append("Skipped a worker checkpoint outside the scan directory.")
+            continue
+        if worker["kind"] == "dedup":
+            for directory, attempt in outputs:
+                checkpoint_paths = _checkpoint_paths(scan_dir, f"{directory}/checkpoints")
+                if not checkpoint_paths:
+                    continue
+                result_path = f"{directory}/result.json"
+                retained_paths = [result_path, *checkpoint_paths]
+                paths.update(dict.fromkeys(retained_paths))
+                reducer_paths.update(retained_paths)
+                reducer_outputs.append((worker, result_path, checkpoint_paths, attempt))
+            continue
+        if worker["kind"] != "discovery":
+            continue
+        output, attempt = outputs[0]
+        paths[f"{output}/result.json"] = worker["id"]
+        current_results.add(f"{output}/result.json")
+        for archived, archived_attempt in outputs[1:]:
+            paths[f"{archived}/result.json"] = worker["id"]
+            checkpoints(f"{archived}/checkpoints", worker["id"], archived_attempt)
+        checkpoints(f"{output}/checkpoints", worker["id"], attempt)
+        if worker["result_manifest_path"]:
+            try:
+                current_path = Path(worker["result_manifest_path"]).relative_to(scan_dir).as_posix()
+                paths[current_path] = worker["id"]
+                current_results.add(current_path)
+            except ValueError:
+                warnings.append("Skipped a worker result outside the scan directory.")
+
+    if frozen_source_digests is None:
+        for relative, worker_id in list(paths.items()):
+            if Path(relative).name != "checkpoint-head.json":
+                continue
+            del paths[relative]
+            try:
+                captured = capture_head(relative)
+                if relative == "checkpoint-head.json" and frozen_source_digests is None:
+                    parent_context["head"] = next(iter(captured))
+                paths.update({path: worker_id for path in captured})
+            except (ContractError, OSError, ValueError) as exc:
+                if (scan_dir / relative).exists() and not (
+                    relative == "checkpoint-head.json" and parent is not None
+                ):
+                    warnings.append(f"Preserved unreadable checkpoint {relative}: {exc}")
+
+    if frozen_source_digests is not None:
+        source_digests.update(
+            {
+                path: digest
+                for path, digest in frozen_source_digests.items()
+                if _is_source_order_snapshot(path)
+            }
+        )
+        paths = {
+            relative: worker_id
+            for relative, worker_id in paths.items()
+            if relative in frozen_source_digests
+        }
+        current_results.intersection_update(frozen_source_digests)
+        if latest_reducer not in frozen_source_digests:
+            latest_reducer = None
+
+    discarded_by_source: dict[str, list[str]] = {}
+    pending = deque(paths.items())
+    while pending:
+        relative, worker_id = pending.popleft()
+        try:
+            draft, digest, observed = captured_records.get(relative) or _read_saved_result(
+                scan_dir, relative, scan_id, kind="dedup" if relative in reducer_paths else None
+            )
+            if frozen_source_digests is not None and frozen_source_digests[relative] != digest:
+                raise ContractError("checkpoint changed after the scan stopped")
+            source_digests[relative] = digest
+            source_times.setdefault(relative, observed)
+            source_order[relative] = (0, source_times[relative])
+            directory = Path(relative).parent
+            if directory.name in {"checkpoints", "checkpoint-heads"}:
+                directory = directory.parent
+            if _checkpoint_head_directory(relative) is not None:
+                saved_heads[relative] = draft["checkpoint"]
+                if isinstance(draft.get("inputCheckpoint"), str):
+                    saved_inputs[relative] = draft["inputCheckpoint"]
+                continue
+            if (
+                checkpoint_heads is not None
+                and checkpoint_heads.get(directory.as_posix(), relative) is None
+            ):
+                continue
+            if preserve_canonical_parent and worker_id is not None:
+                discarded = _recover_preserved_worker_source(
+                    scan_dir,
+                    relative,
+                    scan_id,
+                    binding,
+                    worker_id,
+                    next(worker for worker in workers if worker["id"] == worker_id),
+                    draft,
+                    warnings,
+                )
+                if discarded:
+                    discarded_by_source[relative] = discarded
+            # Recovery expects coverage, but reducer results only contain findings
+            # and context. Add an empty value after hashing the original result.
+            sources.append((relative, {"reviewState": {}, **draft}, worker_id))
+            if frozen_source_digests is None:
+                pending.extend(
+                    receipt_checkpoints(
+                        relative, worker_id, paths, partial(_checkpoint_paths, scan_dir)
+                    ).items()
+                )
+        except (ContractError, OSError, ValueError) as exc:
+            if (scan_dir / relative).exists():
+                warnings.append(f"Preserved unreadable checkpoint {relative}: {exc}")
+    if frozen_source_digests is not None:
+        if frozen_source_digests.keys() - source_digests.keys():
+            raise ContractError("Frozen stopped-scan checkpoint set is incomplete.")
+
+    if checkpoint_heads is None:
+        checkpoint_heads = _frozen_checkpoint_heads(scan_dir, scan_id, source_digests)
+    heads_snapshotted = False
+    if frozen_source_digests is not None and snapshot_error is None:
+        # Raw heads are a temporary fallback, not permanent publication sources.
+        for relative in list(saved_heads):
+            if Path(relative).name != "checkpoint-head.json":
+                continue
+            captured = _capture_saved_source(
+                scan_dir,
+                relative,
+                scan_id,
+                expected_digest=source_digests[relative],
+                created_paths=created_paths,
+            )
+            for path, (digest, observed) in captured.items():
+                if path in source_digests and source_digests[path] != digest:
+                    raise ContractError("checkpoint changed after the scan stopped")
+                source_digests[path] = digest
+                source_times.setdefault(path, observed)
+                if _checkpoint_head_directory(path) is not None:
+                    saved_heads[path] = saved_heads[relative]
+                    if relative in saved_inputs:
+                        saved_inputs[path] = saved_inputs[relative]
+                    if parent_context.get("head") == relative:
+                        parent_context["head"] = path
+                    source_order[path] = (0, observed)
+                    key = Path(relative).parent.as_posix()
+                    if checkpoint_heads.get(key) == relative:
+                        checkpoint_heads[key] = path
+            saved_inputs.pop(relative, None)
+            del saved_heads[relative], source_digests[relative]
+            heads_snapshotted = True
+        if heads_snapshotted:
+            source_digests = {
+                path: digest
+                for path, digest in source_digests.items()
+                if not _is_source_order_snapshot(path)
+            }
+    headed_workers = {
+        worker_attempts[_checkpoint_head_directory(head).as_posix()][0]
+        for head in saved_heads
+        if _checkpoint_head_directory(head) != Path(".")
+    }
+    for relative, _, worker_id in sources:
+        if worker_id not in headed_workers:
+            continue
+        directory = Path(relative).parent
+        if directory.name == "checkpoints":
+            directory = directory.parent
+        _, attempt = worker_attempts.get(directory.as_posix(), (worker_id, 0))
+        source_order[relative] = (attempt, source_order[relative][1])
+    selected_observations: dict[str, tuple[int, int]] = {}
+    authoritative_heads: set[str] = set()
+    authoritative_observations: dict[str, tuple[int, int]] = {}
+    parent_heads: list[tuple[int, str]] = []
+    for head, checkpoint in saved_heads.items():
+        directory = _checkpoint_head_directory(head)
+        selected = (directory / "checkpoints" / checkpoint).as_posix()
+        if selected not in source_order:
+            raise ContractError("Checkpoint head is outside the saved source set.")
+        key = directory.as_posix()
+        if key in checkpoint_heads and checkpoint_heads[key] is None:
+            continue
+        observed = source_order[head][1]
+        attempt = 0 if directory == Path(".") else worker_attempts[key][1]
+        order = (attempt, observed)
+        if key not in checkpoint_heads or checkpoint_heads[key] in (head, selected):
+            authoritative_heads.add(selected)
+            if checkpoint_heads.get(key) == head:
+                authoritative_observations[selected] = order
+            if directory == Path("."):
+                parent_heads.append((observed, selected))
+        selected_observations[selected] = max(selected_observations.get(selected, order), order)
+    # A registered result independently retains its latest accepted observation.
+    # Restoring the head does not withdraw that result's publication authority.
+    registered_result_orders = {
+        path: order for path, order in selected_observations.items() if path in current_results
+    }
+    # A restored head selects one observation, not the newest time for its payload.
+    selected_observations.update(authoritative_observations)
+    source_order.update(selected_observations)
+    source_order.update(registered_result_orders)
+
+    # Keep frozen source digests over the original data, before discarding markers
+    # that never passed through the worker draft writer.
+    retain_recorded_receipt_ownership(
+        sources, _digest, binding["scope"]["includePaths"], finding_scope
+    )
+    drafts_by_path = {relative: draft for relative, draft, _ in sources}
+    # A frozen model capture supplies context without replacing earlier findings.
+    model_path = frozen_model_source or canonical_model_source
+    model_draft = drafts_by_path.get(model_path)
+    if (
+        model_draft is not None
+        and model_path not in selected_observations
+        and model_path != parent_context.get("canonical")
+        and isinstance(model := model_draft.get("threatModel"), dict)
+        and model_draft == _model_capture(scan_id, model)
+    ):
+        model_draft["complete"] = False
+    if frozen_source_digests is not None and "canonical" in parent_context:
+        canonical = parent_context["canonical"]
+        parent = drafts_by_path[canonical]
+        parent_model_source = canonical
+        parent_modified = int(
+            parent_context.get("canonicalObservedAtNs", source_order[canonical][1])
+        )
+        parent_is_canonical = True
+    if "head" in parent_context:
+        head = parent_context["head"]
+        parent_heads = [(source_order[head][1], f"checkpoints/{saved_heads[head]}")]
+
+    if parent is None and frozen_source_digests is not None and "canonical" not in parent_context:
+        # Older host snapshots remain evidence; only the newest is the current parent.
+        saved_parents = {
+            relative: draft
+            for relative, draft, _ in sources
+            if relative.startswith("checkpoints/")
+            and isinstance(draft.get("previousParentCheckpoints"), list)
+        }
+        previous_parents = {
+            relative
+            for draft in saved_parents.values()
+            for relative in draft["previousParentCheckpoints"]
+            if isinstance(relative, str)
+        }
+        for relative, draft in saved_parents.items():
+            if relative not in previous_parents:
+                frozen_parent_path, parent = relative, draft
+                parent_model_source = relative
+                parent_is_canonical = draft.get("canonicalParent") is True
+                break
+    projected_coverage = parent["reviewState"] if parent else {}
+    # V1 persists the review projection in the parent, without reducer sourceCoverage.
+
+    coverage_receipts = partial(resolve_coverage_receipts, scan_dir)
+
+    def canonical_coverage_record(field: str, item: dict[str, Any]) -> dict[str, Any]:
+        refs = item.get("receiptRefs", [])
+        if field != "surfaces" or not isinstance(refs, list):
+            return item
+        origin = projection_origins.get(id(item))
+        if origin is not None and (worker := workers_by_id.get(origin[0])) is not None:
+            refs = coverage_receipts(item, worker, origin[1])
+        result = {
+            **item,
+            "receiptRefs": [Path(ref).as_posix() if isinstance(ref, str) else ref for ref in refs],
+        }
+        if isinstance(provenance := result.get("provenance"), dict):
+            result["provenance"] = {
+                key: value for key, value in provenance.items() if key != "scanReceiptRefs"
+            }
+        return result
+
+    def retained_coverage_record(field: str, item: dict[str, Any]) -> dict[str, Any] | None:
+        return projection.retained_record(coverage, field, item, canonical_coverage_record)
+
+    reconciled_surface_ids: dict[tuple[str | None, str], str] = {}
+
+    def project_missing_record(
+        field: str,
+        item: dict[str, Any],
+        index: int,
+        worker: Any,
+        source: dict[str, Any],
+        *,
+        receipts_resolved: bool = False,
+    ) -> dict[str, Any]:
+        # Retain projectDiscoveryCoverage worker ownership.
+        prefix = f"{worker['id']}-attempt-{worker['attempt']}"
+
+        def accepted_positions(surface: dict[str, Any]) -> list[int]:
+            return [
+                position
+                for position, accepted in accepted_surfaces.get((worker["id"], surface["id"]), [])
+                if canonical_coverage_record("surfaces", accepted)
+                == canonical_coverage_record("surfaces", surface)
+            ]
+
+        def surface_id(surface: dict[str, Any], offset: int) -> str:
+            source_id = surface.get("id")
+            if id(source) not in accepted_coverage_sources and isinstance(source_id, str):
+                positions = accepted_positions(surface)
+                if len(positions) == 1:
+                    offset = positions[0]
+                elif not positions:
+                    return f"{prefix}-surface-{offset}-{_digest(surface)[:16]}"
+            return f"{prefix}-surface-{offset}"
+
+        result = copy.deepcopy(item)
+        provenance = result.get("provenance")
+        if not isinstance(provenance, dict):
+            provenance = {}
+        for key in ("workerId", "attempt", "sourceId", "candidateId"):
+            provenance.pop(key, None)
+        provenance.update(workerId=worker["id"], attempt=worker["attempt"])
+        result["provenance"] = provenance
+        source_rows = source.get(field, [])
+        inferred_id = (
+            isinstance(source_rows, list)
+            and index <= len(source_rows)
+            and id(source_rows[index - 1]) in inferred_coverage_ids
+        )
+        for key, name in (("id", "sourceId"), ("candidateId", "candidateId")):
+            if key == "id" and inferred_id:
+                continue
+            if key in item:
+                result["provenance"][name] = item[key]
+        if isinstance(item.get("candidateId"), str):
+            candidate_digest = hashlib.sha256(javascript_utf8(item["candidateId"])).hexdigest()
+            result["candidateId"] = f"{prefix}-candidate-{candidate_digest}"
+        if field == "surfaces":
+            original = source_rows[index - 1] if isinstance(source_rows, list) else item
+            result["id"] = surface_id(original, index)
+            if not receipts_resolved and (origin := projection_origins.get(id(original))):
+                result["receiptRefs"] = coverage_receipts(result, worker, origin[1])
+            previous = retained_coverage_record("surfaces", result)
+            if previous is not None and isinstance(previous.get("id"), str):
+                result["id"] = previous["id"]
+            else:
+                if any(
+                    isinstance(row, dict) and row.get("id") == result["id"]
+                    for row in _coverage_rows(coverage, "surfaces")
+                ):
+                    result["id"] = f"{result['id']}-{_digest(result)[:16]}"
+        elif field == "deferred":
+            result["id"] = f"{prefix}-deferred-{index}"
+            if isinstance(item.get("surfaceIds"), list):
+                surface_ids: dict[str, str] = {}
+                for surface in _coverage_rows(projected_coverage, "surfaces"):
+                    if not isinstance(surface, dict) or not isinstance(surface.get("id"), str):
+                        continue
+                    provenance = surface.get("provenance", {})
+                    if (
+                        isinstance(provenance, dict)
+                        and provenance.get("workerId") == worker["id"]
+                        and provenance.get("attempt") == worker["attempt"]
+                        and isinstance(provenance.get("sourceId"), str)
+                    ):
+                        surface_ids.setdefault(provenance["sourceId"], surface["id"])
+                source_surface_ids: dict[str, tuple[int, dict[str, Any]]] = {}
+                for offset, surface in enumerate(_coverage_rows(source, "surfaces"), 1):
+                    if isinstance(surface, dict) and isinstance(surface.get("id"), str):
+                        source_surface_ids.setdefault(surface["id"], (offset, surface))
+                for (owner, source_id), accepted in accepted_surfaces.items():
+                    if owner == worker["id"] and accepted:
+                        source_surface_ids.setdefault(source_id, accepted[0])
+                for source_id, (offset, surface) in source_surface_ids.items():
+                    if source_id not in item["surfaceIds"]:
+                        continue
+                    if (worker["id"], source_id) in reconciled_surface_ids:
+                        surface_ids[source_id] = reconciled_surface_ids[(worker["id"], source_id)]
+                        continue
+                    projected_id = surface_id(surface, offset)
+                    if id(source) in accepted_coverage_sources or accepted_positions(surface):
+                        origin = projection_origins.get(id(surface))
+                        projected = project_missing_record(
+                            "surfaces", surface, offset, worker, origin[4] if origin else source
+                        )
+                        if origin := projection_origins.get(id(surface)):
+                            projected["receiptRefs"] = coverage_receipts(
+                                projected, worker, origin[1]
+                            )
+                        projected_id = projected["id"]
+                        previous = retained_coverage_record("surfaces", projected)
+                        if previous is not None and isinstance(previous.get("id"), str):
+                            projected_id = previous["id"]
+                    surface_ids[source_id] = projected_id
+                result["surfaceIds"] = [
+                    surface_ids.get(value, value) if isinstance(value, str) else value
+                    for value in item["surfaceIds"]
+                ]
+        return result
+
+    workers_by_id = {worker["id"]: worker for worker in workers}
+    latest_reducer_key = (
+        (_iteration_order(reducer), int(reducer["attempt"] or 0))
+        if reducer is not None and latest_reducer in drafts_by_path
+        else None
+    )
+    if latest_reducer_key is None:
+        latest_reducer = None
+    for worker, result_path, checkpoint_paths, attempt in reducer_outputs:
+        result = drafts_by_path.get(result_path)
+        if result is None or not any(
+            drafts_by_path.get(checkpoint_path) == result for checkpoint_path in checkpoint_paths
+        ):
+            continue
+        current_results.add(result_path)
+        candidate_key = (_iteration_order(worker), attempt)
+        if latest_reducer_key is None or candidate_key > latest_reducer_key:
+            latest_reducer_key = candidate_key
+            latest_reducer = result_path
+
+    if parent_heads:
+        latest_observation = max(observed for observed, _ in parent_heads)
+        for observed, parent_path in parent_heads:
+            if observed != latest_observation:
+                continue
+            draft = drafts_by_path[parent_path]
+            modified = source_order[parent_path][1]
+            if parent is None or modified > parent_modified:
+                # Only a replacement head can replay without the canonical draft.
+                if parent_context.get("canonical") not in source_digests:
+                    parent_context.pop("canonical", None)
+                    parent_context.pop("canonicalObservedAtNs", None)
+                parent = draft
+                parent_model_source = parent_path
+                frozen_parent_path = (
+                    parent_path
+                    if isinstance(draft.get("previousParentCheckpoints"), list)
+                    else None
+                )
+                parent_modified = modified
+                parent_is_canonical = draft.get("canonicalParent") is True
+            elif modified == parent_modified and _parent_observation_content(
+                draft
+            ) != _parent_observation_content(parent):
+                parent = _merge_tied_parent_observations(parent, draft)
+                parent_is_canonical = False
+    # A reducer supplies findings but cannot supersede saved parent coverage.
+    saved_parent = parent
+    parent_is_root = parent is not None
+    if parent is None and latest_reducer is not None:
+        parent = drafts_by_path[latest_reducer]
+        parent_model_source = latest_reducer
+
+    projected_coverage = saved_parent["reviewState"] if saved_parent else {}
+    # Reconcile raw source IDs and timestamps before projecting accepted outputs.
+    accepted_sources = {
+        (worker_id, relative): draft
+        for relative, draft, worker_id in sources
+        if (worker := workers_by_id.get(worker_id)) is not None
+        and worker["status"] == "succeeded"
+        and worker["result_manifest_path"] == str(scan_dir / relative)
+        and draft.get("complete") is not False
+    }
+    project_worker_coverage, legacy_surface_links = prepare_saved_coverage_projection(
+        sources,
+        parent,
+        source_order,
+        project_worker_coverage=project_worker_coverage,
+        preserve_canonical_parent=preserve_canonical_parent,
+        receipt_resolver=lambda relative, row, owner: resolve_coverage_receipts(
+            scan_dir, row, workers_by_id[owner], relative
+        ),
+    )
+
+    def retain_coverage_row(output, item, owner, field, original=None, qualified=False):
+        retained = projection.retain_coverage_row(output, item, owner, field, original, qualified)
+        source = item if original is None else original
+        _inherit_coverage_sources(retained, [item, source], coverage_sources)
+        if preserve_canonical_parent and (
+            id(item) in canonical_rows or id(source) in canonical_rows
+        ):
+            canonical_rows.add(id(retained))
+        if field == "surfaces":
+            retained_surface_rows.add(id(source))
+        return retained
+
+    accepted_coverage_sources = {id(draft["reviewState"]) for draft in accepted_sources.values()}
+    accepted_by_worker = {}
+    accepted_surfaces: dict[tuple[str, str], list[tuple[int, dict[str, Any]]]] = {}
+    for (worker_id, relative), draft in accepted_sources.items():
+        accepted_by_worker.setdefault(worker_id, (relative, draft["reviewState"]))
+        for index, surface in enumerate(_coverage_rows(draft["reviewState"], "surfaces"), 1):
+            if isinstance(surface, dict) and isinstance(surface.get("id"), str):
+                accepted_surfaces.setdefault((worker_id, surface["id"]), []).append(
+                    (index, surface)
+                )
+
+    for _, draft, _ in sources:
+        questions = draft["reviewState"].get("openQuestions")
+        if isinstance(questions, list):
+            draft["reviewState"]["openQuestions"] = [
+                {"question": item.strip()} if isinstance(item, str) else item for item in questions
+            ]
+    projection_origins = {
+        id(item): (worker_id, relative, field, index, draft["reviewState"])
+        for relative, draft, worker_id in sources
+        for field in ("surfaces", "explicitExclusions", "deferred", "openQuestions")
+        for index, item in enumerate(_coverage_rows(draft["reviewState"], field), 1)
+        if isinstance(item, dict)
+    }
+
+    projection = SavedCoverageProjection(
+        project_worker_coverage, legacy_surface_links, projection_origins
+    )
+
+    def project_record(
+        field: str,
+        item: dict[str, Any],
+        source_item: dict[str, Any] | None = None,
+        *,
+        receipts_resolved: bool = False,
+    ) -> dict[str, Any]:
+        original = item if source_item is None else source_item
+        origin = projection_origins.get(id(original))
+        if origin is None:
+            return item
+        worker_id, relative, _, index, source = origin
+        if (worker_id, relative) not in accepted_sources:
+            directory = Path(relative).parent
+            if directory.name == "checkpoints":
+                directory = directory.parent
+            worker = workers_by_id.get(worker_id)
+            if worker is None or worker_attempts.get(directory.as_posix(), (None, None)) != (
+                worker_id,
+                worker["attempt"],
+            ):
+                return item
+            # Reproduced outputs and links from omitted checkpoints use the
+            # accepted worker's surface namespace.
+            accepted = accepted_by_worker.get(worker_id)
+            if accepted is not None and source == accepted[1]:
+                relative, source = accepted
+            elif relative not in selected_observations or accepted is None:
+                if field == "deferred" and accepted is not None and "surfaceIds" in item:
+                    return {
+                        **item,
+                        "surfaceIds": project_missing_record(
+                            field, item, index, worker, accepted[1]
+                        )["surfaceIds"],
+                    }
+                return item
+        worker = workers_by_id[worker_id]
+        result = project_missing_record(
+            field, item, index, worker, source, receipts_resolved=receipts_resolved
+        )
+        if field == "surfaces" and not receipts_resolved:
+            result["receiptRefs"] = coverage_receipts(result, worker, relative)
+        return result
+
+    all_sources = ([("parent", parent, None)] if parent else []) + sources
+    inferred_coverage_ids: set[int] = set()
+    # Older checkpoints can omit IDs already assigned in their published output.
+    for field in ("deferred", "surfaces"):
+        named_rows: dict[str | None, list[dict[str, Any]]] = {}
+        for _, draft, owner in all_sources:
+            named_rows.setdefault(owner, []).extend(
+                row
+                for row in _coverage_rows(draft["reviewState"], field)
+                if isinstance(row, dict) and isinstance(row.get("id"), str)
+            )
+        for _, draft, owner in all_sources:
+            rows = _coverage_rows(draft["reviewState"], field)
+            reserved = {
+                row["id"]
+                for row in rows
+                if isinstance(row, dict) and isinstance(row.get("id"), str)
+            }
+            for row in rows:
+                if not isinstance(row, dict) or "id" in row:
+                    continue
+                if field == "deferred" and _has_candidate_metadata(row):
+                    continue
+                content = {"receiptRefs": [], **row} if field == "surfaces" else row
+                identity = next(
+                    (
+                        named["id"]
+                        for named in named_rows[owner]
+                        if named["id"] not in reserved
+                        and {
+                            **({"receiptRefs": []} if field == "surfaces" else {}),
+                            **{key: value for key, value in named.items() if key != "id"},
+                        }
+                        == content
+                    ),
+                    None,
+                )
+                if identity is not None:
+                    inferred_coverage_ids.add(id(row))
+                    row["id"] = identity
+                    reserved.add(identity)
+
+    # A discarded local surface must not fall back to another source's reused ID.
+    surface_ids_by_source: dict[tuple[str, str], list[str]] = {
+        (relative, row["id"]): []
+        for relative, draft, _ in all_sources
+        for row in _coverage_rows(draft["reviewState"], "surfaces")
+        if isinstance(row, dict) and isinstance(row.get("id"), str)
+    }
+    discarded_coverage_sources: set[str] = set()
+    if preserve_canonical_parent:
+        for relative, draft, worker_id in sources:
+            if worker_id is None:
+                continue
+            if _recover_preserved_worker_coverage(
+                scan_dir,
+                relative,
+                worker_id,
+                draft,
+                discarded_by_source.get(relative, []),
+                warnings,
+            ):
+                discarded_coverage_sources.add(relative)
+
+    if parent is None and not sources:
+        return None
+    if (
+        parent_manifest
+        and parent_manifest["scan"].get("sealedAt")
+        and parent_manifest["scan"].get("status") == binding["status"]
+        and parent_manifest["scan"].get("preservedSources") == source_digests
+        and parent_manifest["scan"].get("preservedCheckpointHeads", {}) == checkpoint_heads
+        and all(warning in initial_warnings for warning in warnings)
+    ):
+        return None
+
+    target_kind = binding["allowedTargetKinds"][0]
+    if (
+        target_kind == "git_worktree"
+        and "snapshotDigest" not in binding["target"]
+        and "git_revision" in binding["allowedTargetKinds"]
+    ):
+        target_kind = "git_revision"
+    target = {"kind": target_kind, **binding["target"]}
+    if target["kind"] == "git_diff" and "snapshotDigest" not in target:
+        diff_kind = {"commit": "commit", "branch_diff": "range"}[binding["coverageMode"]]
+        target["snapshotDigest"] = committed_diff_snapshot_digest(
+            diff_kind, target["baseRevision"], target["headRevision"]
+        )
+    manifest = (
+        copy.deepcopy(parent_manifest)
+        if parent_manifest
+        else {"scan": {"target": target, "scope": binding["scope"]}}
+    )
+    if allow_frozen_legacy_parent:
+        manifest["scan"]["target"] = target
+    for key in ("sealedAt", "artifacts", "coverageRef"):
+        manifest["scan"].pop(key, None)
+    manifest["scan"]["preservedSources"] = source_digests
+    manifest["scan"]["preservedCheckpointHeads"] = checkpoint_heads
+    # Completion follows the selected parent, including legacy terminal drafts
+    # that omit the optional marker, rather than an older canonical manifest.
+    if parent is not None:
+        manifest["scan"].pop("complete", None)
+        if "complete" in parent:
+            manifest["scan"]["complete"] = parent["complete"]
+        if isinstance(parent.get("scope"), dict):
+            manifest["scan"]["scope"] = copy.deepcopy(parent["scope"])
+        if isinstance(manifest["scan"].get("scope"), dict):
+            manifest["scan"]["scope"].update(copy.deepcopy(binding["scope"]))
+    model_checks: dict[str, dict[str, Any] | None] = {}
+
+    def recovered_model(
+        relative: str, draft: dict[str, Any], owner: str | None
+    ) -> dict[str, Any] | None:
+        if relative not in model_checks:
+            model = copy.deepcopy(draft.get("threatModel"))
+            if isinstance(model, dict) and owner is not None:
+                model["origin"] = "recovered"
+            schema = _read_json(
+                Path(__file__).resolve().parents[2] / "schemas/scan-manifest.schema.json"
+            )
+            try:
+                _require_safe_json_value(model, f"Saved threat model {relative}")
+                _validate_schema_node(
+                    model,
+                    schema["properties"]["scan"]["properties"]["threatModel"],
+                    f"Saved threat model {relative}",
+                    schema,
+                )
+            except ContractError as exc:
+                warnings.append(f"Skipped malformed saved threat model {relative}: {exc}")
+                model = None
+            model_checks[relative] = model
+        return model_checks[relative]
+
+    parent_model = (
+        recovered_model(parent_model_source or "parent", parent, None)
+        if parent is not None and "threatModel" in parent
+        else None
+    )
+    canonical_model = manifest["scan"].pop("threatModel", canonical_model)
+    if parent_model is not None:
+        manifest["scan"]["threatModel"] = parent_model
+        if (
+            selected_model_source is not None
+            and parent_model_source in drafts_by_path
+            and (
+                parent_model_source != canonical_model_source
+                or canonical_model_digest is None
+                or source_digests[parent_model_source] == canonical_model_digest
+            )
+        ):
+            selected_model_source[:] = [parent_model_source]
+    elif frozen_model_source is None:
+        # Model fallback is independent of whether older findings are superseded.
+        if canonical_model is not None:
+            canonical_model = recovered_model("canonical", {"threatModel": canonical_model}, None)
+        if (
+            canonical_model_source is not None
+            and Path(canonical_model_source).parent != Path("checkpoints")
+        ) or (
+            canonical_model_source is None
+            and isinstance(canonical_model, dict)
+            and canonical_model.get("origin") == "recovered"
+        ):
+            # Worker models follow their own selected head and independent result.
+            canonical_model = None
+            canonical_model_source = None
+        if (
+            canonical_model_source in drafts_by_path
+            and recovered_model(
+                canonical_model_source, drafts_by_path[canonical_model_source], None
+            )
+            is not None
+            and (
+                canonical_model_digest is None
+                or source_digests[canonical_model_source] == canonical_model_digest
+            )
+        ):
+            canonical_model = drafts_by_path[canonical_model_source].get("threatModel")
+            canonical_model_order = max(
+                canonical_model_order or source_order[canonical_model_source],
+                source_order[canonical_model_source],
+            )
+        else:
+            # A skipped checkpoint cannot supply provenance for valid canonical data.
+            canonical_model_source = None
+        root_models = [
+            path
+            for path in drafts_by_path
+            if path in selected_observations
+            and Path(path).parent == Path("checkpoints")
+            and isinstance(drafts_by_path[path].get("threatModel"), dict)
+            and recovered_model(path, drafts_by_path[path], None) is not None
+        ]
+        selected_root_models = [path for path in root_models if path in authoritative_heads]
+        if isinstance(canonical_model, dict) and canonical_model_order is None:
+            # Legacy publications have no model-source identity. Only newly admitted
+            # observations can supersede that fallback without an explicit selection.
+            new_models = {
+                f"checkpoints/{checkpoint}"
+                for head, checkpoint in saved_heads.items()
+                if _checkpoint_head_directory(head) == Path(".")
+                and head not in (canonical_sources or {})
+            }
+            root_models = [path for path in root_models if path in new_models]
+        model_source = max(
+            selected_root_models or root_models,
+            key=lambda path: source_order[path],
+            default=None,
+        )
+        if model_source is not None and (
+            selected_root_models
+            or not isinstance(canonical_model, dict)
+            or canonical_model_order is None
+            or source_order[model_source] > canonical_model_order
+        ):
+            manifest["scan"]["threatModel"] = copy.deepcopy(
+                drafts_by_path[model_source]["threatModel"]
+            )
+            if selected_model_source is not None:
+                selected_model_source[:] = [model_source]
+        elif isinstance(canonical_model, dict):
+            manifest["scan"]["threatModel"] = copy.deepcopy(canonical_model)
+            if stopped and frozen_source_digests is None and canonical_model_source is None:
+                # An unreadable canonical checkpoint must not leave a valid
+                # inherited model dependent on live files after the first stop.
+                model_draft = _model_capture(scan_id, canonical_model)
+                digest = _digest(model_draft)
+                canonical_model_source = f"checkpoints/{digest}.json"
+                observed = (canonical_model_order or (0, parent_modified))[1]
+                source_digests[canonical_model_source] = digest
+                source_times[canonical_model_source] = observed
+                try:
+                    if not (scan_dir / canonical_model_source).exists():
+                        if created_paths is not None and not os.path.lexists(
+                            scan_dir / canonical_model_source
+                        ):
+                            created_paths.add(canonical_model_source)
+                        write_scan_local_bytes(
+                            scan_dir, canonical_model_source, _encoded(model_draft)
+                        )
+                        os.utime(scan_dir / canonical_model_source, ns=(observed, observed))
+                    _, actual, _ = _read_saved_result(scan_dir, canonical_model_source, scan_id)
+                    if actual != digest:
+                        raise ContractError("Saved inherited model checkpoint changed.")
+                except (ContractError, OSError) as exc:
+                    snapshot_error = snapshot_error or exc
+            if selected_model_source is not None and canonical_model_source is not None:
+                selected_model_source[:] = [canonical_model_source]
+
+    if frozen_model_source is not None:
+        # Publication retries retain a valid choice from the frozen source set.
+        model = drafts_by_path.get(frozen_model_source, {}).get("threatModel")
+        if not isinstance(model, dict):
+            raise ContractError("Frozen stopped-scan model source is unavailable.")
+        model = recovered_model(
+            frozen_model_source, drafts_by_path[frozen_model_source], paths[frozen_model_source]
+        )
+        if model is not None:
+            manifest["scan"]["threatModel"] = model
+        if selected_model_source is not None:
+            selected_model_source[:] = [] if model is None else [frozen_model_source]
+    coverage = (
+        copy.deepcopy(parent["reviewState"])
+        if parent and parent["reviewState"]
+        else {
+            "mode": binding["coverageMode"],
+            "inventoryStrategy": "diff"
+            if binding["coverageMode"] in {"commit", "branch_diff", "working_tree"}
+            else "scoped_path"
+            if binding["coverageMode"] == "scoped_path"
+            else "repository",
+            **binding["scope"],
+            "surfaces": [],
+            "explicitExclusions": [],
+            "deferred": [],
+        }
+    )
+    if isinstance(coverage.get("openQuestions"), list):
+        coverage["openQuestions"] = [
+            {"question": item.strip()} if isinstance(item, str) else item
+            for item in coverage["openQuestions"]
+        ]
+    # Closure reconciliation can reuse original parent rows instead of their copies.
+    canonical_rows = (
+        {
+            id(item)
+            for parent_coverage in (
+                (coverage, parent["reviewState"]) if preserve_canonical_parent else (coverage,)
+            )
+            for field in ("surfaces", "explicitExclusions", "deferred")
+            for item in _coverage_rows(parent_coverage, field)
+        }
+        if parent_is_canonical
+        else set()
+    )
+    # Links use source-local IDs until all retained surfaces receive their final IDs.
+    coverage_sources: dict[int, tuple[dict[str, Any], list[str]]] = {}
+    source_owners = {relative: owner for relative, _, owner in all_sources}
+    retained_surface_rows: set[int] = set()
+    for relative, draft, _ in all_sources:
+        for field in ("surfaces", "deferred"):
+            for row in _coverage_rows(draft["reviewState"], field):
+                if isinstance(row, dict):
+                    paths_for_row = coverage_sources.setdefault(id(row), (row, []))[1]
+                    if relative not in paths_for_row:
+                        paths_for_row.append(relative)
+    if parent:
+        for field in ("surfaces", "deferred"):
+            rows, originals = coverage.get(field), parent["reviewState"].get(field)
+            if isinstance(rows, list) and isinstance(originals, list):
+                for row, original in zip(rows, originals):
+                    _inherit_coverage_sources(row, [original], coverage_sources)
+                if field == "surfaces":
+                    retained_surface_rows.update(id(original) for original in originals)
+
+    findings: list[dict[str, Any]] = []
+    finding_positions: dict[str, tuple[int, dict[str, Any] | None]] = {}
+    canonical_finding_keys: set[str] = set()
+    represented: dict[str, str | None] = {}
+    represented_candidates: dict[tuple[str, str, Any, Any, Any], str | None] = {}
+    represented_history: dict[str, set[str]] = {}
+    represented_candidate_history: dict[tuple[str, str, Any, Any, Any], set[str]] = {}
+    rejected_history: dict[tuple[str, str], list[dict[str, Any]]] = {}
+    stopped_parent_seal = bool(
+        stopped and parent_manifest and parent_manifest["scan"].get("sealedAt")
+    )
+
+    # A damaged canonical row must not replace a checkpoint's established identity.
+    legacy_identities: dict[str, dict[str, Any] | None] = {}
+    legacy_identity_sources: set[str] = set()
+
+    def legacy_identity_key(finding: dict[str, Any], owner: str | None) -> str:
+        content = _finding_content(finding)
+        locations = content.get("locations")
+        if isinstance(locations, list):
+            content["locations"] = sorted(
+                [
+                    {**row, "endLine": row.get("endLine", row.get("startLine"))}
+                    if isinstance(row, dict)
+                    else row
+                    for row in locations
+                ],
+                key=_encoded,
+            )
+        return _digest([owner, _identity_candidate(finding), content])
+
+    def restore_legacy_identity(
+        finding: Any, normalized: Any = None, *, allow_synthesis: bool = True
+    ) -> None:
+        if isinstance(finding, dict) and "identity" not in finding:
+            provenance = finding.get("provenance")
+            owner = provenance.get("workerId") if isinstance(provenance, dict) else None
+            key = legacy_identity_key(finding, owner)
+            identity = legacy_identities.get(key)
+            if identity is not None:
+                finding["identity"] = copy.deepcopy(identity)
+            allow_synthesis = allow_synthesis or key in legacy_identity_sources
+        if not allow_synthesis:
+            return
+        if isinstance(finding, dict) and isinstance(normalized, dict):
+            finding.setdefault("identity", normalized["identity"])
+        else:
+            _ensure_finding_identity(finding)
+
+    def finding_within_scope(finding: dict[str, Any]) -> bool:
+        locations = finding.get("locations", [])
+        return isinstance(locations, list) and any(
+            isinstance(location, dict)
+            and isinstance(location.get("path"), str)
+            and any(
+                PurePosixPath(location["path"]) == PurePosixPath(path)
+                if is_file
+                else path_within_scope(location["path"], path)
+                for path, is_file in (
+                    finding_scope
+                    if finding_scope is not None
+                    else [(path, False) for path in binding["scope"]["includePaths"]]
+                )
+            )
+            for location in locations
+        )
+
+    valid_findings: dict[bytes, bool] = {}
+
+    def valid_finding(value: Any) -> bool:
+        # Use the finalizer's own per-record recovery before a draft can suppress
+        # an earlier checkpoint. Invalid latest records must not hide valid history.
+        document = {"scanId": scan_id, "findings": [copy.deepcopy(value)]}
+        if isinstance(document["findings"][0], dict):
+            restore_legacy_identity(document["findings"][0])
+        key = _encoded(document["findings"][0])
+        if key in valid_findings:
+            return valid_findings[key]
+        _recover_unsealed_findings(
+            {"scan": {"id": scan_id, "target": binding["target"]}},
+            document,
+            Path(__file__).resolve().parents[2] / "schemas",
+            scan_dir,
+            [],
+            current_contract=current_contract,
+        )
+        valid_findings[key] = bool(document["findings"])
+        return valid_findings[key]
+
+    for _, draft, owner in all_sources:
+        for value in draft["findings"]:
+            if not isinstance(value, dict):
+                continue
+            for saved in _retained_findings(value):
+                identity = saved.get("identity")
+                provenance = saved.get("provenance")
+                saved_owner = (
+                    provenance.get("workerId", owner) if isinstance(provenance, dict) else owner
+                )
+                key = legacy_identity_key(saved, saved_owner)
+                if "identity" in saved:
+                    legacy_identity_sources.add(key)
+                if not isinstance(identity, dict) or not valid_finding(saved):
+                    continue
+                if key not in legacy_identities:
+                    legacy_identities[key] = identity
+                elif legacy_identities[key] != identity:
+                    legacy_identities[key] = None
+
+    source_order["parent"] = (0, parent_modified)
+
+    def projection_key(field: str, item: dict[str, Any]) -> tuple[str, str]:
+        # Publication may rename canonical IDs and add retained finding history.
+        ignored = {"id", "previousFindings"} if field == "surfaces" else {"id"}
+        content = {
+            key: value
+            for key, value in canonical_coverage_record(field, item).items()
+            if key not in ignored
+        }
+        return field, _digest(content)
+
+    projected_sources: dict[tuple[str, str], tuple[str, dict[str, Any], tuple[int, int]]] = {}
+    accepted_pending_candidates: set[tuple[str, int, str]] = set()
+    selected_reported_candidates: dict[tuple[str, str], tuple[int, int]] = {}
+    for relative, draft, worker_id in sources:
+        if relative not in selected_observations:
+            continue
+        for finding in draft["findings"]:
+            if isinstance(finding, dict) and valid_finding(finding):
+                candidate_id = finding_candidate_id(finding)
+                if candidate_id:
+                    key = (worker_id, candidate_id)
+                    selected_reported_candidates[key] = max(
+                        selected_reported_candidates.get(key, source_order[relative]),
+                        source_order[relative],
+                    )
+    for (worker_id, relative), draft in accepted_sources.items():
+        worker = workers_by_id[worker_id]
+        reported = {
+            finding_candidate_id(finding)
+            for finding in draft["findings"]
+            if isinstance(finding, dict) and valid_finding(finding)
+        }
+        for field in ("surfaces", "deferred", "explicitExclusions"):
+            for index, row in enumerate(_coverage_rows(draft["reviewState"], field), 1):
+                if not isinstance(row, dict):
+                    continue
+                if (
+                    field == "deferred"
+                    and isinstance(candidate_id := row.get("candidateId"), str)
+                    and candidate_id not in reported
+                    and selected_reported_candidates.get((worker_id, candidate_id), (-1, -1))
+                    < source_order[relative]
+                ):
+                    accepted_pending_candidates.add((worker_id, worker["attempt"], candidate_id))
+                projected = project_missing_record(field, row, index, worker, draft["reviewState"])
+                if field == "surfaces":
+                    projected["receiptRefs"] = coverage_receipts(projected, worker, relative)
+                key = projection_key(field, projected)
+                projected_sources[key] = (worker_id, row, source_order[relative])
+
+    def record_source(
+        field: str, owner: str | None, item: dict[str, Any]
+    ) -> tuple[str | None, dict[str, Any]]:
+        # Parent-authored provenance is data, not authority over another worker.
+        if (source := projected_sources.get(projection_key(field, item))) and (
+            owner is None or owner == source[0]
+        ):
+            return source[0], source[1]
+        return owner, item
+
+    def record_key(field: str, owner: str | None, item: dict[str, Any]) -> tuple[str | None, Any]:
+        source_owner, original = record_source(field, owner, item)
+        identity = original.get("id")
+        return source_owner, identity if isinstance(identity, str) else None
+
+    def coverage_candidate(
+        owner: str | None, item: dict[str, Any]
+    ) -> tuple[str | None, str] | None:
+        for field in ("surfaces", "deferred", "explicitExclusions"):
+            source_owner, original = record_source(field, owner, item)
+            if original is not item:
+                owner, item = source_owner, original
+                break
+        else:
+            # A later parent can complete a known worker proof gap, but its
+            # claimed provenance cannot overturn an accepted worker finding.
+            provenance = item.get("provenance")
+            if owner is None and isinstance(provenance, dict):
+                source_owner = provenance.get("workerId")
+                attempt = provenance.get("attempt")
+                candidate_id = provenance.get("candidateId")
+                if (
+                    isinstance(source_owner, str)
+                    and isinstance(attempt, int)
+                    and isinstance(candidate_id, str)
+                    and (source_owner, attempt, candidate_id) in accepted_pending_candidates
+                ):
+                    return source_owner, candidate_id
+        candidate_id = (
+            _deferred_candidate_id(item, owner, ambiguous_deferred)
+            if any(key in item for key in ("candidate", "finding"))
+            else item.get("candidateId")
+        )
+        return (owner, candidate_id) if isinstance(candidate_id, str) else None
+
+    def candidate_order(
+        relative: str, owner: str | None, item: dict[str, Any] | None = None
+    ) -> tuple[int, int]:
+        order = source_order[relative]
+        if source_owners[relative] is None and owner is not None:
+            if item is not None:
+                for field in ("surfaces", "deferred", "explicitExclusions"):
+                    key = projection_key(field, item)
+                    if (source := projected_sources.get(key)) and source[0] == owner:
+                        return source[2]
+            attempt = int(workers_by_id[owner]["attempt"] or 0) if owner in headed_workers else 0
+            return attempt, order[1]
+        return order
+
+    deferred_rows = {
+        relative: _coverage_rows(draft["reviewState"], "deferred")
+        for relative, draft, _ in all_sources
+    }
+    # Accepted heads can replace equal tasks before they reach output coalescing.
+    equivalent_tasks: dict[str | None, list[dict[str, Any]]] = {}
+    for relative, _, owner in all_sources:
+        known = equivalent_tasks.setdefault(owner, [])
+        for row in deferred_rows[relative]:
+            if not isinstance(row, dict):
+                continue
+            for previous in known:
+                if previous == row:
+                    _inherit_coverage_sources(previous, [row], coverage_sources)
+                    coverage_sources[id(row)] = (row, coverage_sources[id(previous)][1])
+                    break
+            else:
+                known.append(row)
+    # A legacy source can contain independent tasks with the same explicit ID.
+    # Later rewrites cannot make an ID-only closure identify one of those tasks.
+    ambiguous_deferred: set[tuple[str | None, str]] = set()
+    for relative, _, owner in all_sources:
+        by_id: dict[tuple[str | None, Any], dict[str, Any]] = {}
+        candidate_aliases = {
+            (source_owner, identity)
+            for row in deferred_rows[relative]
+            if isinstance(row, dict) and _has_candidate_metadata(row)
+            for source_owner, original in [record_source("deferred", owner, row)]
+            for identity in (original.get("id"), original.get("candidateId"))
+            if isinstance(identity, str)
+        }
+        for row in deferred_rows[relative]:
+            if not isinstance(row, dict) or not isinstance(identity := row.get("id"), str):
+                continue
+            if _has_candidate_metadata(row):
+                continue
+            key = record_key("deferred", owner, row)
+            if key in candidate_aliases or (key in by_id and row != by_id[key]):
+                ambiguous_deferred.add(key)
+            by_id[key] = row
+    current_drafts = ([("parent", parent, None)] if parent else []) + [
+        source for source in sources if source[0] in current_results | selected_observations.keys()
+    ]
+
+    pending_surface_orders: dict[tuple[str | None, str], tuple[int, int]] = {}
+    for relative, draft, owner in all_sources:
+        for surface in _coverage_rows(draft["reviewState"], "surfaces"):
+            if (
+                isinstance(surface, dict)
+                and surface.get("disposition") == "needs_follow_up"
+                and (candidate := coverage_candidate(owner, surface)) is not None
+            ):
+                order = candidate_order(relative, candidate[0], surface)
+                pending_surface_orders[candidate] = max(
+                    pending_surface_orders.get(candidate, order), order
+                )
+    # Generic closures belong to one logical scan or worker, just like candidates.
+    # Keep them when recovering a terminal checkpoint without its canonical write.
+    closed_deferred: dict[tuple[str | None, str], tuple[tuple[int, int], dict[str, Any], str]] = {}
+
+    candidate_ids: set[tuple[str | None, str]] = set()
+    accepted_deferred_orders: dict[tuple[str | None, str], tuple[int, int]] = {}
+    active_deferred: dict[tuple[str | None, str], tuple[tuple[int, int], dict[str, Any], str]] = {}
+    coverage_schema = _read_json(
+        Path(__file__).resolve().parents[2] / "schemas" / "coverage.schema.json"
+    )["properties"]
+
+    projected_closure_sources = _projected_worker_closure_sources(
+        sources, source_order, worker_attempts, coverage_schema["resolvedDeferred"]
+    )
+
+    for relative, draft, owner in all_sources:
+        for item in deferred_rows[relative]:
+            if not isinstance(item, dict):
+                continue
+            source_owner, original = record_source("deferred", owner, item)
+            order = candidate_order(relative, source_owner, item)
+            if isinstance(item.get("candidateId"), str) or "candidate" in item or "finding" in item:
+                candidate_ids.update(
+                    (source_owner, identity)
+                    for identity in (original.get("id"), original.get("candidateId"))
+                    if isinstance(identity, str)
+                )
+            identity = original.get("id") or original.get("candidateId")
+            if isinstance(identity, str):
+                key = (source_owner, identity)
+                previous = active_deferred.get(key)
+                if previous is None or order > previous[0]:
+                    active_deferred[key] = (order, original, relative)
+                if (
+                    relative == "parent"
+                    or relative in current_results
+                    or relative in selected_observations
+                ):
+                    try:
+                        # A malformed update cannot discard valid saved evidence.
+                        _validate_schema_node(
+                            {"id": identity, **item},
+                            coverage_schema["deferred"]["items"],
+                            "coverage.deferred",
+                        )
+                    except ContractError:
+                        continue
+                    accepted_deferred_orders[key] = max(
+                        accepted_deferred_orders.get(key, order), order
+                    )
+        for closure in _resolved_deferred_rows(draft, coverage_schema["resolvedDeferred"]):
+            closure_owner, closure_relative = owner, relative
+            if owner is None and (
+                source := projected_closure_sources.get((closure["id"], closure["reason"]))
+            ):
+                # A copied parent closeout keeps its worker's identity and observation
+                # time, so a later parent write cannot hide reopened worker work.
+                closure_owner, closure, closure_relative = source
+            key = (closure_owner, closure["id"])
+            order = candidate_order(closure_relative, closure_owner)
+            previous = closed_deferred.get(key)
+            if previous is None or order > previous[0]:
+                # The parent comes first, preserving its reason on equal timestamps.
+                closed_deferred[key] = (order, closure, closure_relative)
+    reopened_rows: list[tuple[str | None, dict[str, Any]]] = []
+    reopened_generic: set[tuple[str | None, str]] = set()
+    for key, (order, _, _) in list(closed_deferred.items()):
+        # Equal timestamps cannot distinguish closure from reopened work.
+        reopened = [
+            active
+            for (owner, identity), active in active_deferred.items()
+            if owner == key[0]
+            and (identity == key[1] or active[1].get("candidateId") == key[1])
+            and active[0] >= order
+        ]
+        if key in candidate_ids or key in ambiguous_deferred or reopened:
+            del closed_deferred[key]
+        for _, item, _ in reopened:
+            reopened_rows.append((key[0], item))
+            if key not in candidate_ids:
+                reopened_generic.add(key)
+    # Retain every distinct ambiguous task even when a terminal result supersedes
+    # its source. Existing output ID normalization keeps each row distinct.
+    for relative, _, owner in all_sources:
+        for row in deferred_rows[relative]:
+            if (
+                isinstance(row, dict)
+                and isinstance(identity := row.get("id"), str)
+                and record_key("deferred", owner, row) in ambiguous_deferred
+                and not _has_candidate_metadata(row)
+                and (owner, row) not in reopened_rows
+            ):
+                reopened_rows.append((owner, row))
+    retained_closures = [
+        closure
+        if owner is None
+        else _project_worker_closure(relative, owner, closure, worker_attempts, source_order)
+        for (owner, _), (_, closure, relative) in closed_deferred.items()
+    ]
+    coverage.pop("resolvedDeferred", None)
+    if retained_closures:
+        coverage["resolvedDeferred"] = copy.deepcopy(retained_closures)
+        if parent:
+            coverage["deferred"] = [
+                row
+                for row in deferred_rows["parent"]
+                if not isinstance(row, dict)
+                or not isinstance(row.get("id"), str)
+                or (None, row["id"]) not in closed_deferred
+            ]
+
+    ordered_candidates = {
+        (owner, identity)
+        for owner, row in reopened_rows
+        if (identity := _deferred_candidate_id(row, owner, ambiguous_deferred)) is not None
+        and (owner, identity) in candidate_ids
+    }
+
+    outcomes, pending_candidate_orders = _saved_candidate_outcomes(
+        scan_dir,
+        current_drafts,
+        valid_finding,
+        coverage_candidate,
+        candidate_order,
+        workers_by_id,
+        coverage_schema,
+    )
+    ordered_candidates.update(pending_candidate_orders)
+
+    def select_outcomes(unusable_receipts):
+        permitted = [entry for entry in outcomes if not unusable_receipts.intersection(entry[-1])]
+        resolved, ordered_outcomes = {}, {}
+        candidates = ordered_candidates.union(
+            (owner, candidate_id)
+            for relative, owner, candidate_id, _, _, _ in permitted
+            if relative in selected_observations
+        )
+        selected_head_candidates = {
+            (Path(relative).parent, owner, candidate_id)
+            for relative, owner, candidate_id, _, _, _ in permitted
+            if relative in authoritative_heads
+        }
+        other_root_order = _unselected_root_order(saved_heads, checkpoint_heads, source_order)
+        for relative, owner, candidate_id, disposition, order, _ in permitted:
+            if (
+                relative in selected_observations
+                and relative not in authoritative_heads
+                and relative not in current_results
+                and (Path(relative).parent, owner, candidate_id) in selected_head_candidates
+            ):
+                continue
+            key = (owner, candidate_id)
+            if pending_surface_orders.get(key, (-1, -1)) >= order:
+                continue
+            if key not in candidates:
+                if relative == "parent" or relative in current_results:
+                    resolved.setdefault(key, disposition)
+                continue
+            root_terminal = (
+                owner is None
+                and (relative == "parent" or relative in authoritative_heads)
+                and (parent if relative == "parent" else drafts_by_path[relative]).get("complete")
+                is not False
+                and other_root_order < order
+            )
+            pending_order = pending_candidate_orders.get(key, (-1, -1))
+            if (pending_order > order or (pending_order == order and not root_terminal)) or any(
+                (
+                    coverage_candidate(saved_owner, row)
+                    or (saved_owner, _deferred_candidate_id(row, saved_owner, ambiguous_deferred))
+                )
+                == key
+                and (
+                    saved_order > order
+                    or saved_order == order
+                    and (
+                        not root_terminal
+                        or accepted_deferred_orders.get((saved_owner, identity)) == saved_order
+                    )
+                )
+                for (saved_owner, identity), (saved_order, row, _) in active_deferred.items()
+            ):
+                continue
+            previous = ordered_outcomes.get(key)
+            if (
+                previous is None
+                or order > previous[0]
+                or (
+                    order == previous[0]
+                    and previous[1] != relative
+                    and previous[1] in current_results
+                    and (
+                        relative in checkpoint_heads.values()
+                        or relative in authoritative_observations
+                    )
+                )
+            ):
+                resolved[key] = disposition
+                ordered_outcomes[key] = (order, relative)
+        return resolved, ordered_outcomes
+
+    resolved, ordered_outcomes = select_outcomes(set())
+    # Only the current parent may claim that another worker finding was absorbed.
+    # A superseded checkpoint must not suppress a newer independent result.
+    if parent:
+        for finding in parent["findings"]:
+            if valid_finding(finding):
+                canonical = copy.deepcopy(finding)
+                restore_legacy_identity(canonical)
+                canonical_key = _finding_key(canonical)
+                for retained in _retained_findings(finding):
+                    retained_key = _finding_key(retained)
+                    if retained is not finding:
+                        represented_history.setdefault(retained_key, set()).add(
+                            _digest(_finding_content(retained))
+                        )
+                    previous_key = represented.get(retained_key)
+                    if retained_key not in represented:
+                        represented[retained_key] = canonical_key
+                    elif previous_key != canonical_key:
+                        # Ambiguous history cannot suppress an independent source.
+                        represented[retained_key] = None
+                originals = finding["provenance"].get("sourceFindings", [])
+                for original in originals if isinstance(originals, list) else []:
+                    if isinstance(original, dict) and isinstance(original.get("finding"), dict):
+                        source_id = original.get("id")
+                        candidate_id = finding_candidate_id(original["finding"])
+                        if isinstance(source_id, str) and ":" in source_id and candidate_id:
+                            candidate_key = _worker_candidate_key(
+                                source_id.rsplit(":", 1)[0],
+                                candidate_id,
+                                original["finding"],
+                            )
+                            previous_key = represented_candidates.get(candidate_key)
+                            if candidate_key not in represented_candidates:
+                                represented_candidates[candidate_key] = canonical_key
+                            elif previous_key != canonical_key:
+                                # Candidate ids are only authoritative within one
+                                # logical worker. Multiple canonical owners make
+                                # that worker-local identity ambiguous.
+                                represented_candidates[candidate_key] = None
+                            represented_candidate_history.setdefault(candidate_key, set()).add(
+                                _digest(_finding_content(original["finding"]))
+                            )
+    selected_terminal_orders: dict[str | None, tuple[int, int]] = {}
+    for relative, draft, worker_id in sources:
+        if (
+            relative in authoritative_heads
+            and draft.get("complete") is not False
+            and relative not in discarded_by_source
+            and relative not in discarded_coverage_sources
+        ):
+            order = source_order[relative]
+            selected_terminal_orders[worker_id] = max(
+                selected_terminal_orders.get(worker_id, order), order
+            )
+    terminal_worker_orders: dict[str | None, tuple[int, int]] = {}
+    terminal_coverage_orders: dict[str | None, tuple[int, int]] = {}
+    for relative, draft, worker_id in sources:
+        if (
+            relative in current_results
+            and draft.get("complete") is not False
+            and relative not in discarded_by_source
+        ):
+            order = source_order[relative]
+            terminal_worker_orders[worker_id] = max(
+                terminal_worker_orders.get(worker_id, order), order
+            )
+            if relative not in reducer_paths and relative not in discarded_coverage_sources:
+                terminal_coverage_orders[worker_id] = max(
+                    terminal_coverage_orders.get(worker_id, order), order
+                )
+    prior_terminal_orders: dict[str | None, tuple[int, int]] = {}
+    partial_head_orders = {
+        Path(path).parent: selected_observations[path]
+        for path in authoritative_heads
+        if drafts_by_path[path].get("complete") is False
+    }
+    for head, checkpoint in saved_heads.items():
+        directory = _checkpoint_head_directory(head)
+        relative = (directory / "checkpoints" / checkpoint).as_posix()
+        partial_order = partial_head_orders.get(Path(relative).parent)
+        if partial_order is None:
+            continue
+        order = (partial_order[0], source_order[head][1])
+        if (
+            drafts_by_path[relative].get("complete") is not False
+            and relative not in discarded_by_source
+            and relative not in discarded_coverage_sources
+            and order <= partial_order
+        ):
+            # A partial head adds coverage after the preceding terminal replacement.
+            worker_id = paths[relative]
+            prior_terminal_orders[worker_id] = max(
+                prior_terminal_orders.get(worker_id, order), order
+            )
+
+    # Reconcile raw records before generating context-dependent publication IDs.
+    logical_rows: dict[tuple[Any, ...], dict[str, dict[str, Any]]] = {}
+    row_groups: dict[tuple[str, int], dict[str, Any]] = {}
+    published_groups: list[dict[str, Any]] = []
+
+    def same_owner(left: str | None, right: str | None) -> bool:
+        # Canonical recovery needs identity or recorded lineage to absorb worker evidence.
+        return left == right or (not preserve_canonical_parent and (left is None or right is None))
+
+    def finding_source_order(source, within_worker: bool = False):
+        relative, draft, _ = source
+        attempt, modified = source_order[relative]
+        return (
+            draft.get("complete") is not False,
+            attempt if within_worker else 0,
+            modified,
+            relative in selected_observations,
+            relative in current_results,
+            relative == "parent",
+        )
+
+    terminal_findings: dict[str, list[dict[str, Any]]] = {}
+    # A reducer replaces only its claimed batch, not the whole parent scan.
+    parent_sources = {
+        relative
+        for relative, _, _ in all_sources
+        if Path(relative).parent == Path("checkpoints") or (relative == "parent" and parent_is_root)
+    }
+    projected_paths = {
+        relative
+        for relative, draft, _ in all_sources
+        if relative in parent_sources
+        and (
+            relative == "parent"
+            or relative == parent_context.get("canonical")
+            # The semantic tool schema forbids this host-owned projection field.
+            or draft["reviewState"].get("mode") == binding["coverageMode"]
+        )
+    }
+    projected_parents = [draft for relative, draft, _ in all_sources if relative in projected_paths]
+
+    def same_published_finding(left: dict[str, Any], right: dict[str, Any]) -> bool:
+        if not valid_finding(left) or not valid_finding(right):
+            return False
+        return (
+            same_raw_value(_finding_content(left), _finding_content(right))
+            and (
+                "identity" not in left
+                or same_raw_value(_finding_identity(left), _finding_identity(right))
+            )
+            and same_raw_value(
+                {
+                    key: value
+                    for key, value in left.get("provenance", {}).items()
+                    if key not in ("previousFindings", "preservedIdentity")
+                },
+                {
+                    key: value
+                    for key, value in right.get("provenance", {}).items()
+                    if key not in ("previousFindings", "preservedIdentity")
+                },
+            )
+        )
+
+    def represented_by_parent(values: list[dict[str, Any]], draft: dict[str, Any]) -> bool:
+        remaining = [row for row in draft["findings"] if isinstance(row, dict)]
+        for value in values:
+            match = next(
+                (
+                    index
+                    for index, row in enumerate(remaining)
+                    if same_published_finding(value, row)
+                ),
+                None,
+            )
+            if match is None:
+                return False
+            remaining.pop(match)
+        return True
+
+    terminal_sources: set[str] = set()
+    for relative, draft, _ in all_sources:
+        if (
+            scan_mode == "deep"
+            and not allow_frozen_legacy_parent
+            and relative in parent_sources
+            and draft.get("complete") is not False
+            and all(valid_finding(value) for value in draft["findings"])
+        ):
+            terminal_sources.add(relative)
+            if relative not in projected_paths:
+                identified = copy.deepcopy(draft["findings"])
+                _ensure_finding_identities(identified)
+                terminal_findings[relative] = identified
+    # Legacy projections alone do not record the submitted replacement batch.
+    if not terminal_findings:
+        terminal_sources.clear()
+    head_path = (
+        f"checkpoints/{saved_heads[parent_context['head']]}"
+        if "head" in parent_context and not allow_frozen_legacy_parent
+        else None
+    )
+    head_input = saved_inputs.get(parent_context.get("head"))
+    ancestors = _parent_publication_ancestors(head_input, drafts_by_path)
+    committed_parent = parent
+    committed_path = "parent" if parent_is_root else None
+    if head_path and (
+        not parent_is_canonical or any(parent == drafts_by_path.get(path) for path in ancestors)
+    ):
+        committed_path = head_path
+        committed_parent = drafts_by_path[head_path]
+    committed_time = source_order.get(committed_path, (0, 0))[1]
+    pending_terminals = set()
+    superseded_terminals = set()
+    unordered_terminals = set()
+    for relative, values in terminal_findings.items():
+        publication = drafts_by_path[relative].get("publication")
+        if isinstance(publication, dict):
+            previous = publication.get("previousCheckpoint")
+            if Path(relative).name == head_input:
+                continue
+            if (
+                f"checkpoints/{previous}" if previous is not None else None
+            ) != head_path or publication.get("previousInputCheckpoint") != head_input:
+                superseded_terminals.add(relative)
+                continue
+            pending_terminals.add(relative)
+        elif not any(represented_by_parent(values, draft) for draft in projected_parents):
+            # Legacy inputs have no causal link to an accepted publication. A
+            # backdated observation cannot prove that accepted findings were removed.
+            if source_order[relative][1] >= committed_time:
+                pending_terminals.add(relative)
+            else:
+                unordered_terminals.add(relative)
+    terminal_cutoffs = (
+        {committed_path}
+        if committed_path in terminal_sources
+        else terminal_sources - superseded_terminals
+    )
+    terminal_parent_time = max(
+        (source_order[relative][1] for relative in pending_terminals or terminal_cutoffs),
+        default=None,
+    )
+    pending_terminals = {
+        relative
+        for relative in pending_terminals
+        if source_order[relative][1] == terminal_parent_time
+    }
+    for relative in pending_terminals | unordered_terminals:
+        identified = copy.deepcopy(drafts_by_path[relative]["findings"])
+        _ensure_finding_identities(identified, deep=True)
+        terminal_findings[relative] = identified
+    current_findings = [
+        previous
+        for value in (committed_parent["findings"] if committed_parent else [])
+        if isinstance(value, dict)
+        for previous in _retained_findings(value)
+    ]
+    replaced_findings = [
+        value
+        for draft in projected_parents
+        for value in draft["findings"]
+        if isinstance(value, dict)
+        and (
+            pending_terminals
+            or (
+                terminal_sources
+                and not any(
+                    same_published_finding(value, previous) for previous in current_findings
+                )
+            )
+        )
+    ]
+
+    def replaced_parent_finding(relative: str, owner: str | None, value: Any) -> bool:
+        if (
+            owner is not None
+            or relative in pending_terminals | unordered_terminals
+            or not isinstance(value, dict)
+        ):
+            return False
+        return any(same_published_finding(value, previous) for previous in replaced_findings)
+
+    terminal_worker_attempts: dict[str, int] = {}
+    if terminal_parent_time is not None:
+        for relative, _, owner in all_sources:
+            attempt, modified = source_order[relative]
+            if owner is not None and modified <= terminal_parent_time:
+                terminal_worker_attempts[owner] = max(
+                    terminal_worker_attempts.get(owner, attempt), attempt
+                )
+
+    def precedes_terminal_parent(relative: str, owner: str | None) -> bool:
+        attempt, modified = source_order[relative]
+        return relative in superseded_terminals or (
+            relative not in unordered_terminals
+            and terminal_parent_time is not None
+            and (
+                modified < terminal_parent_time
+                or attempt < terminal_worker_attempts.get(owner, attempt)
+            )
+        )
+
+    finding_sources = [
+        source for source in all_sources if not precedes_terminal_parent(source[0], source[2])
+    ]
+    # Publication chronology spans workers; attempt numbers only order one worker's revisions.
+    for source in sorted(finding_sources, key=lambda item: finding_source_order(item)[2:]):
+        relative, draft, source_owner = source
+        explicit_identity_counts = Counter(
+            _semantic_identity_key(sibling, _finding_identity(sibling))
+            for sibling in draft["findings"]
+            if isinstance(sibling, dict)
+            and isinstance(sibling.get("identity"), dict)
+            and ((relative == "parent" and parent_is_canonical) or finding_within_scope(sibling))
+        )
+        pending = []
+        for index, value in enumerate(draft["findings"]):
+            if (
+                not isinstance(value, dict)
+                or replaced_parent_finding(relative, source_owner, value)
+                or not valid_finding(value)
+                or (
+                    not (relative == "parent" and parent_is_canonical)
+                    and not finding_within_scope(value)
+                )
+            ):
+                continue
+            owner = raw_owner(value, source_owner)
+            scope = raw_scope(value)
+            candidate = finding_candidate_id(value)
+            scopes = [scope, (scope[0], candidate)] if candidate else [scope]
+            publication_identity = (
+                _finding_identity(
+                    value if "identity" in value else terminal_findings[relative][index]
+                )
+                if relative in terminal_findings
+                else None
+            )
+            matches = [
+                group
+                for group in {
+                    key: group
+                    for saved_scope in scopes
+                    for key, group in logical_rows.get(saved_scope, {}).items()
+                }.values()
+                if same_owner(owner, group["owner"])
+                and (
+                    publication_identity is None
+                    or group["identity"] is None
+                    or _semantic_identity_key(value, group["identity"])
+                    == _semantic_identity_key(value, publication_identity)
+                )
+                and (
+                    (relative == "parent" and parent_is_canonical)
+                    or group["identity"] is None
+                    or "identity" not in value
+                    or _semantic_identity_key(value, group["identity"])
+                    == _semantic_identity_key(value, _finding_identity(value))
+                )
+                and all(same_raw_finding(value, previous) for previous in group["rows"])
+            ]
+            ranked = []
+            for group in matches:
+                latest = group["latest"]
+                if (
+                    isinstance(value.get("identity"), dict)
+                    and explicit_identity_counts[
+                        _semantic_identity_key(value, _finding_identity(value))
+                    ]
+                    == 1
+                    and group["identity"] is not None
+                    and _semantic_identity_key(value, _finding_identity(value))
+                    == _semantic_identity_key(value, group["identity"])
+                ):
+                    rank = 4
+                elif (
+                    owner == group["owner"]
+                    and same_raw_content(value, latest)
+                    and _identity_candidate(value) == _identity_candidate(latest)
+                    and identifiers(value) == identifiers(latest)
+                ):
+                    rank = 3
+                elif any(same_raw_content(value, previous) for previous in group["rows"]):
+                    rank = 2
+                elif (
+                    latest.get("title") == value.get("title")
+                    and raw_scope(latest) == scope
+                    and all(
+                        previous is None or current == previous
+                        for current, previous in zip(
+                            identifiers(value), identifiers(latest), strict=True
+                        )
+                    )
+                ):
+                    rank = 1
+                else:
+                    rank = 0
+                ranked.append((group, rank))
+            pending.append((index, value, owner, scopes, ranked))
+        assigned = {}
+        claimed = set()
+        for index, value, owner, _, matches in pending:
+            for group, _ in matches:
+                if (
+                    group["key"] not in claimed
+                    and owner == group["owner"]
+                    and same_raw_value(value, group["latest"])
+                ):
+                    assigned[index] = group
+                    claimed.add(group["key"])
+                    break
+        for rank in (4, 3, 2, 1, 0):
+            identity_claims = {
+                group["key"]
+                for index, _, _, _, matches in pending
+                for group, score in matches
+                if score == 4 and assigned.get(index) is group
+            }
+            options = {
+                index: [
+                    group
+                    for group, score in matches
+                    if score >= rank
+                    and (
+                        group["key"] not in claimed
+                        or (rank == 0 and group["key"] not in identity_claims)
+                    )
+                ]
+                for index, _, _, _, matches in pending
+                if index not in assigned
+            }
+            counts = {}
+            for groups in options.values():
+                for group in groups:
+                    counts[group["key"]] = counts.get(group["key"], 0) + 1
+            chosen = {
+                index: groups[0]
+                for index, groups in options.items()
+                if len(groups) == 1
+                and groups[0]["key"] not in claimed
+                and counts[groups[0]["key"]] == 1
+            }
+            assigned.update(chosen)
+            claimed.update(group["key"] for group in chosen.values())
+        current_groups: list[tuple[int, dict[str, Any]]] = []
+        for index, value, owner, scopes, _ in pending:
+            match = assigned.get(index)
+            if match is None:
+                match = {
+                    "owner": owner,
+                    "rows": [],
+                    "identity": None,
+                    "key": f"raw:{len(row_groups)}",
+                }
+            for saved_scope in scopes:
+                logical_rows.setdefault(saved_scope, {})[match["key"]] = match
+            if match["owner"] is None:
+                match["owner"] = owner
+            if not any(same_raw_value(value, previous) for previous in match["rows"]):
+                match["rows"].append(value)
+            observations = match.setdefault("observations", {})
+            previous = observations.get(source_owner)
+            if previous is None or (
+                finding_source_order(source, True),
+                _finding_strength(value),
+            ) > (
+                finding_source_order(previous[0], True),
+                _finding_strength(previous[1]),
+            ):
+                observations[source_owner] = (source, value)
+                match["latest"] = max(
+                    observations.values(),
+                    key=lambda observation: (
+                        finding_source_order(observation[0]),
+                        _finding_strength(observation[1]),
+                    ),
+                )[1]
+            if relative in terminal_findings:
+                match["identity"] = copy.deepcopy(
+                    _finding_identity(
+                        value if "identity" in value else terminal_findings[relative][index]
+                    )
+                )
+            elif "identity" in value and (match["identity"] is None or relative == "parent"):
+                match["identity"] = copy.deepcopy(_finding_identity(value))
+            row_groups[(relative, index)] = match
+            current_groups.append((index, match))
+        if source_owner is None:
+            current_ordered = [
+                group for _, group in sorted(current_groups, key=lambda item: item[0])
+            ]
+            ordered = current_ordered + [
+                group for group in published_groups if group not in current_ordered
+            ]
+            normalized = []
+            for group in ordered:
+                value = copy.deepcopy(group["latest"])
+                if group["identity"] is not None:
+                    value["identity"] = copy.deepcopy(group["identity"])
+                normalized.append(value)
+            _ensure_finding_identities(normalized)
+            for group, value in zip(ordered, normalized, strict=True):
+                group["identity"] = value["identity"]
+            published_groups = ordered
+
+    # A later worker draft can collapse raw duplicates that it fully contains.
+    # Keep established identities and any evidence absent from the newer report.
+    contained_groups = set()
+    for group in {group["key"]: group for group in row_groups.values()}.values():
+        owner = group["owner"]
+        previous = group["observations"].get(owner)
+        if owner is None or group["identity"] is not None or previous is None:
+            continue
+        for current in logical_rows.get(raw_scope(group["latest"]), {}).values():
+            observed = current["observations"].get(owner)
+            if (
+                current["owner"] == owner
+                and observed is not None
+                and finding_source_order(observed[0], True)
+                > finding_source_order(previous[0], True)
+                and all(contains_raw_value(current["latest"], row) for row in group["rows"])
+            ):
+                contained_groups.add(group["key"])
+                break
+
+    # An absorbed source represents every reconciled version of that worker report.
+    for groups in logical_rows.values():
+        for group in groups.values():
+            destinations = set()
+            for value in group["rows"]:
+                history_key = _finding_key(value)
+                if _digest(_finding_content(value)) in represented_history.get(history_key, set()):
+                    destinations.add(represented.get(history_key))
+                elif group["owner"] and (candidate_id := finding_candidate_id(value)):
+                    candidate_key = _worker_candidate_key(group["owner"], candidate_id, value)
+                    if _digest(_finding_content(value)) in represented_candidate_history.get(
+                        candidate_key, set()
+                    ):
+                        destinations.add(represented_candidates[candidate_key])
+            if len(destinations) == 1 and None not in destinations:
+                group["parent_key"] = destinations.pop()
+
+    generated_worker_findings: list[dict[str, Any]] = []
+
+    def source_coverage_selection(
+        relative: str,
+        worker_id: str | None,
+    ) -> tuple[bool, set[str], bool, bool, bool]:
+        worker_result_order = terminal_worker_orders.get(worker_id)
+        selected_terminal_order = selected_terminal_orders.get(worker_id)
+        terminal_coverage_order = max(
+            (
+                order
+                for order in (
+                    terminal_coverage_orders.get(worker_id),
+                    selected_terminal_order,
+                    prior_terminal_orders.get(worker_id),
+                )
+                if order is not None
+            ),
+            default=None,
+        )
+        selected_coverage_superseded = (
+            terminal_coverage_order is not None and source_order[relative] < terminal_coverage_order
+        ) or (
+            selected_terminal_order is not None
+            and source_order[relative][0] == selected_terminal_order[0]
+            and (
+                relative in selected_observations
+                and relative not in authoritative_heads
+                and relative not in current_results
+                or (
+                    relative in current_results
+                    and relative not in authoritative_heads
+                    and source_order[relative] <= selected_terminal_order
+                )
+            )
+        )
+        selected_candidates = {
+            candidate_id
+            for (owner, candidate_id), (_, source) in ordered_outcomes.items()
+            if owner == worker_id and source == relative
+        }
+        superseded = (
+            worker_id is None
+            and saved_parent is not None
+            and saved_parent.get("complete") is not False
+            and relative != "parent"
+            and source_order[relative] <= (0, parent_modified)
+            and (not stopped_parent_seal or relative in parent_preserved_sources)
+            and (
+                # Explicit recovery can admit checkpoints written after this parent.
+                frozen_parent_path is None
+                or relative == frozen_parent_path
+                or relative in saved_parent.get("previousParentCheckpoints", [])
+            )
+        ) or (
+            worker_id is not None
+            and relative not in current_results
+            and worker_result_order is not None
+            and (
+                relative not in selected_observations
+                or source_order[relative] < worker_result_order
+            )
+        )
+        worker_coverage_order = terminal_coverage_orders.get(worker_id)
+        coverage_superseded = (
+            superseded
+            if worker_id is None
+            else (
+                relative not in current_results
+                and worker_coverage_order is not None
+                and (
+                    relative not in selected_observations
+                    or source_order[relative] < worker_coverage_order
+                )
+            )
+        )
+        # A failed result write can leave pending work outside the accepted result.
+        accepted_order = (
+            (0, parent_modified)
+            if worker_id is None and parent is not None
+            else worker_coverage_order
+        )
+        retain_pending = (
+            coverage_superseded
+            and (worker_id in headed_workers or (worker_id is None and parent_heads))
+            and accepted_order is not None
+            and source_order[relative] >= accepted_order
+            and any(isinstance(row, dict) for row in deferred_rows[relative])
+        )
+        return (
+            selected_coverage_superseded,
+            selected_candidates,
+            superseded,
+            retain_pending,
+            coverage_superseded,
+        )
+
+    def coverage_row_is_retained(
+        field: str,
+        item: Any,
+        worker_id: str | None,
+        selection: tuple[bool, set[str], bool, bool, bool],
+    ) -> bool:
+        (
+            selected_coverage_superseded,
+            selected_candidates,
+            superseded,
+            retain_pending,
+            coverage_superseded,
+        ) = selection
+        # A selected terminal checkpoint replaces ordinary coverage, while
+        # candidate evidence and pending tasks retain their own reconciliation.
+        if (
+            selected_coverage_superseded
+            and field != "deferred"
+            and not (isinstance(item, dict) and _has_candidate_metadata(item))
+        ):
+            return False
+        # A selected outcome must retain its evidence even if its result write failed.
+        if coverage_superseded and not (
+            isinstance(item, dict)
+            and (
+                (field == "deferred" and retain_pending)
+                or (
+                    isinstance(item.get("candidateId"), str)
+                    and item["candidateId"] in selected_candidates
+                    and item.get("disposition") == resolved.get((worker_id, item["candidateId"]))
+                )
+            )
+        ):
+            return False
+        if (
+            isinstance(item, dict)
+            and isinstance(
+                identity := _deferred_candidate_id(item, worker_id, ambiguous_deferred)
+                if field == "deferred"
+                else item.get("candidateId"),
+                str,
+            )
+            and (coverage_candidate(worker_id, item) or (worker_id, identity)) in resolved
+            and (field == "deferred" or item.get("disposition") == "needs_follow_up")
+        ):
+            return False
+        return True
+
+    def source_surface_receipts(relative: str, row: dict[str, Any]) -> Any:
+        worker = workers_by_id.get(source_owners.get(relative))
+        return coverage_receipts(row, worker, relative) if worker else row.get("receiptRefs", [])
+
+    replaced_deferred = {
+        id(row)
+        for relative, _, owner in all_sources
+        for row in deferred_rows[relative]
+        if isinstance(row, dict)
+        and isinstance(row.get("id"), str)
+        and (key := record_key("deferred", owner, row)) not in candidate_ids
+        and key not in ambiguous_deferred
+        and (updated := accepted_deferred_orders.get(key)) is not None
+        and updated > candidate_order(relative, key[0], row)
+    }
+    ambiguous_surface_ids = {
+        (owner, identity)
+        for owner, row in reopened_rows
+        if isinstance(row.get("id"), str)
+        and (owner, row["id"]) in ambiguous_deferred
+        and not _has_candidate_metadata(row)
+        for identity in [
+            row["id"],
+            *(row.get("surfaceIds", []) if isinstance(row.get("surfaceIds", []), list) else []),
+        ]
+        if isinstance(identity, str)
+    }
+    for _, draft, owner in all_sources:
+        by_id: dict[str, dict[str, Any]] = {}
+        for surface in _coverage_rows(draft["reviewState"], "surfaces"):
+            if not isinstance(surface, dict) or not isinstance(identity := surface.get("id"), str):
+                continue
+            if identity in by_id and surface != by_id[identity]:
+                ambiguous_surface_ids.add((owner, identity))
+            by_id[identity] = surface
+
+    def ambiguous_pending_surface(row: dict[str, Any], owner: str | None) -> bool:
+        return (
+            isinstance(row.get("id"), str)
+            and (owner, row["id"]) in ambiguous_surface_ids
+            and row.get("disposition") == "needs_follow_up"
+            and not _has_candidate_metadata(row)
+        )
+
+    def retain_findings(relative, draft, worker_id, selected_candidates, skip_superseded_findings):
+        normalized_findings = copy.deepcopy(draft["findings"])
+        _ensure_finding_identities(
+            [finding for finding in normalized_findings if valid_finding(finding)]
+        )
+        for index, (value, normalized) in enumerate(
+            zip(draft["findings"], normalized_findings, strict=True)
+        ):
+            if precedes_terminal_parent(relative, worker_id) or replaced_parent_finding(
+                relative, worker_id, value
+            ):
+                continue
+            _ensure_finding_identity(normalized)
+            group = row_groups.get((relative, index))
+            if group is not None and group["key"] in contained_groups:
+                continue
+            if skip_superseded_findings and not (
+                isinstance(value, dict)
+                and (candidate_id := finding_candidate_id(value)) in selected_candidates
+                and resolved.get((worker_id, candidate_id)) == "reported"
+            ):
+                continue
+            if relative == "parent" and parent_is_canonical:
+                finding = copy.deepcopy(value)
+                group = row_groups.get((relative, index))
+                restore_legacy_identity(
+                    finding,
+                    group or normalized,
+                    allow_synthesis=stopped
+                    or (isinstance(finding, dict) and _identity_candidate(finding) is not None)
+                    or (group is not None and any("identity" in row for row in group["rows"])),
+                )
+                provenance = finding.get("provenance") if isinstance(finding, dict) else None
+                owner = provenance.get("workerId") if isinstance(provenance, dict) else None
+                candidate_id = finding_candidate_id(finding) if isinstance(finding, dict) else None
+                if (
+                    stopped_parent_seal
+                    and isinstance(owner, str)
+                    and candidate_id
+                    and resolved.get((owner, candidate_id)) in ("rejected", "not_applicable")
+                ):
+                    rejected_history.setdefault((owner, candidate_id), []).append(finding)
+                    continue
+                if valid_finding(finding):
+                    key = _finding_key(finding)
+                    if group is not None:
+                        key = group.setdefault("merge_key", key)
+                    finding_positions.setdefault(key, (len(findings), group))
+                    if preserve_canonical_parent:
+                        canonical_finding_keys.add(key)
+                findings.append(finding)
+                continue
+            if (
+                relative != "parent"
+                and parent
+                and value in parent["findings"]
+                and not precedes_terminal_parent("parent", None)
+                and not replaced_parent_finding("parent", None, value)
+            ):
+                continue
+            if not isinstance(value, dict):
+                warnings.append(f"Retained malformed finding evidence in {relative}.")
+                continue
+            finding = copy.deepcopy(value)
+            candidate_id = finding_candidate_id(finding)
+            if relative != "parent" and resolved.get((worker_id, candidate_id)) in {
+                "rejected",
+                "not_applicable",
+            }:
+                if preserve_canonical_parent:
+                    rejected_history.setdefault((worker_id, candidate_id), []).append(finding)
+                for item in _coverage_rows(coverage, "surfaces"):
+                    if isinstance(item, dict) and (
+                        coverage_candidate(None, item) == (worker_id, candidate_id)
+                        or (
+                            preserve_canonical_parent
+                            and item.get("candidateId") == candidate_id
+                            and any(
+                                source_owners[source] == worker_id
+                                for source in coverage_sources.get(id(item), (item, []))[1]
+                            )
+                        )
+                        or (
+                            not preserve_canonical_parent
+                            and coverage_candidate(None, item) == (None, candidate_id)
+                        )
+                    ):
+                        _append_previous_finding(item, finding)
+                continue
+            for key in ("findingId", "occurrenceId", "fingerprints"):
+                finding.pop(key, None)
+            if not finding_within_scope(finding):
+                warnings.append(f"Skipped out-of-scope finding from {relative}.")
+                continue
+            provenance = finding.setdefault("provenance", {"source": "local_plugin"})
+            if not isinstance(provenance, dict):
+                findings.append(finding)
+                continue
+            if worker_id:
+                provenance.setdefault("workerId", worker_id)
+            group = row_groups.get((relative, index))
+            if relative in terminal_findings:
+                terminal = terminal_findings[relative][index]
+                finding["identity"] = copy.deepcopy(terminal["identity"])
+                if "preservedIdentity" in terminal.get("provenance", {}):
+                    provenance.setdefault(
+                        "preservedIdentity",
+                        copy.deepcopy(terminal["provenance"]["preservedIdentity"]),
+                    )
+            elif group is not None and group["identity"] is not None:
+                finding.setdefault("identity", copy.deepcopy(group["identity"]))
+            if worker_id is not None and "identity" not in finding:
+                generated_worker_findings.append(finding)
+            finding.setdefault("identity", normalized["identity"])
+            if not valid_finding(finding):
+                findings.append(finding)
+                continue
+            # Terminal siblings remain separate even when their preserved authored
+            # identities and locations coincide. Worker revisions reuse the group.
+            key = (
+                group["key"]
+                if group is not None
+                and (group["identity"] is None or relative in terminal_findings)
+                else _finding_key(finding)
+            )
+            if group is not None:
+                key = group.setdefault("merge_key", key)
+                # Distinct reconciled reports may share an anchor and source location.
+                if key in finding_positions and distinct_reports(group, finding_positions[key][1]):
+                    key = group["merge_key"] = group["key"]
+                key = group.get("parent_key", key)
+            represented_by_parent = False
+            if relative != "parent":
+                history_key = _finding_key(value)
+                # A singleton key is not evidence that a new batch sibling was
+                # absorbed. Only recorded content may reuse that historical edge.
+                if _digest(_finding_content(value)) not in represented_history.get(
+                    history_key, set()
+                ):
+                    history_key = key
+                if history_key in represented:
+                    mapped_key = represented[history_key]
+                    historical_contents = represented_history.get(history_key, set())
+                elif worker_id and candidate_id:
+                    candidate_key = _worker_candidate_key(worker_id, candidate_id, finding)
+                    mapped_key = represented_candidates.get(candidate_key)
+                    historical_contents = represented_candidate_history.get(candidate_key, set())
+                else:
+                    mapped_key = None
+                    historical_contents = set()
+                if mapped_key is not None:
+                    key = mapped_key
+                    represented_by_parent = _digest(_finding_content(value)) in historical_contents
+            if key in finding_positions:
+                position, retained_group = finding_positions[key]
+                retained = findings[position]
+                for field in ("anchor", "instance"):
+                    if field in retained["identity"]:
+                        finding["identity"][field] = retained["identity"][field]
+                    else:
+                        finding["identity"].pop(field, None)
+                if finding != retained:
+                    if (
+                        key not in canonical_finding_keys
+                        and not represented_by_parent
+                        and (
+                            value is group["latest"]
+                            if group is not None and group is retained_group
+                            else _finding_strength(finding) > _finding_strength(retained)
+                        )
+                    ):
+                        previous = copy.deepcopy(retained)
+                        previous_history = previous["provenance"].pop("previousFindings", [])
+                        if "preservedIdentity" in retained["provenance"]:
+                            finding["provenance"]["preservedIdentity"] = copy.deepcopy(
+                                retained["provenance"]["preservedIdentity"]
+                            )
+                        retained = finding
+                        findings[position] = retained
+                        finding_positions[key] = (position, group)
+                    else:
+                        previous = copy.deepcopy(value)
+                        previous_history = previous.get("provenance", {}).pop(
+                            "previousFindings", []
+                        )
+                    retained_provenance = retained["provenance"]
+                    for field in ("sourceFindingIds", "sourceFindings", "originalCandidates"):
+                        values = retained_provenance.get(field, [])
+                        values = list(values) if isinstance(values, list) else []
+                        previous_values = previous.get("provenance", {}).get(field, [])
+                        for item in previous_values if isinstance(previous_values, list) else []:
+                            if item not in values:
+                                values.append(copy.deepcopy(item))
+                        if values:
+                            retained_provenance[field] = values
+                    retained_history = retained_provenance.get("previousFindings")
+                    history = (
+                        [item for item in retained_history if isinstance(item, dict)]
+                        if isinstance(retained_history, list)
+                        else []
+                    )
+                    for original in [
+                        *(previous_history if isinstance(previous_history, list) else []),
+                        previous,
+                    ]:
+                        if not isinstance(original, dict):
+                            continue
+                        owner = retained_provenance.get("workerId", worker_id)
+                        source_key = _finding_key(original, owner)
+                        source_content = _finding_content(original)
+                        already_retained = any(
+                            source_key == _finding_key(historical, owner)
+                            and source_content == _finding_content(historical)
+                            for historical in _retained_findings(retained)
+                        )
+                        if (
+                            not already_retained
+                            and original not in history
+                            and original != retained
+                        ):
+                            history.append(original)
+                    if history or retained_history is not None:
+                        retained_provenance["previousFindings"] = history
+                continue
+            finding_positions[key] = (len(findings), group)
+            findings.append(finding)
+
+    competing_receipts = _competing_rejection_receipts(
+        outcomes, all_sources, source_surface_receipts
+    )
+    check_outcome_receipts = bool(competing_receipts)
+    dry_run = check_outcome_receipts
+    unavailable = set()
+    if dry_run:
+        initial_coverage = coverage
+        initial_canonical_rows = canonical_rows
+        initial_sources = coverage_sources
+        initial_surface_rows = retained_surface_rows
+        initial_ids = surface_ids_by_source
+        initial_projection = projection
+        output_warnings = warnings
+
+    def retain_surface_links(owner, row):
+        if isinstance(row, dict):
+            links = row.get("surfaceIds", [])
+            for identity in [row.get("id"), *(links if isinstance(links, list) else [])]:
+                if isinstance(identity, str):
+                    pending_surface_ids.add((owner, identity))
+
+    def surface_is_retained(relative: str, owner: str | None, row: Any) -> bool:
+        selection = source_coverage_selection(relative, owner)
+        if (
+            isinstance(row, dict)
+            and isinstance(row.get("id"), str)
+            and (owner, row["id"]) in pending_surface_ids
+        ):
+            selection = (False, *selection[1:])
+        return coverage_row_is_retained("surfaces", row, owner, selection)
+
+    while True:
+        if check_outcome_receipts:
+            warnings = [] if dry_run else output_warnings
+            coverage = copy.deepcopy(initial_coverage)
+            canonical_rows = initial_canonical_rows.copy()
+            coverage_sources = {
+                identity: (row, paths.copy()) for identity, (row, paths) in initial_sources.items()
+            }
+            for field in ("surfaces", "deferred", "explicitExclusions"):
+                for initial, current in zip(
+                    _coverage_rows(initial_coverage, field),
+                    _coverage_rows(coverage, field),
+                    strict=True,
+                ):
+                    if id(initial) in initial_canonical_rows:
+                        canonical_rows.add(id(current))
+                    _inherit_coverage_sources(current, [initial], coverage_sources)
+            retained_surface_rows = initial_surface_rows.copy()
+            surface_ids_by_source = {key: ids.copy() for key, ids in initial_ids.items()}
+            reconciled_surface_ids.clear()
+            projection = type(initial_projection)(
+                initial_projection.project_worker_coverage,
+                initial_projection.legacy_surface_links,
+                projection_origins,
+            )
+        # Apply reconciled outcomes to coverage already copied from the parent too.
+        for field in ("surfaces", "deferred"):
+            rows = coverage.get(field)
+            if isinstance(rows, list):
+                coverage[field] = [
+                    row
+                    for row in rows
+                    if not (
+                        isinstance(row, dict)
+                        and (
+                            (
+                                field == "deferred"
+                                and record_key(field, None, row) in closed_deferred
+                            )
+                            or (
+                                coverage_candidate(None, row) in resolved
+                                and (
+                                    field == "deferred"
+                                    or row.get("disposition") == "needs_follow_up"
+                                )
+                            )
+                        )
+                    )
+                ]
+
+        # Reserve receipts for supporting surfaces before repairing historical refs.
+        prospective_tasks = []
+        for relative, _, owner in all_sources:
+            selection = source_coverage_selection(relative, owner)
+            for row in deferred_rows[relative]:
+                if (
+                    coverage_row_is_retained("deferred", row, owner, selection)
+                    and id(row) not in replaced_deferred
+                    and not (
+                        isinstance(row, dict)
+                        and isinstance(row.get("id"), str)
+                        and record_key("deferred", owner, row) in closed_deferred
+                    )
+                ):
+                    prospective_tasks.append((owner, row))
+        prospective_tasks.extend(
+            (owner, row)
+            for owner, row in reopened_rows
+            if (owner, _deferred_candidate_id(row, owner, ambiguous_deferred)) not in resolved
+        )
+        pending_surface_ids = set()
+
+        for owner, row in prospective_tasks:
+            retain_surface_links(owner, row)
+        if parent and isinstance(coverage.get("deferred"), list):
+            previous = parent["reviewState"].get("deferred", [])
+            removed_parent = (
+                [row for row in previous if id(row) in replaced_deferred]
+                if isinstance(previous, list)
+                else []
+            )
+            for row in coverage["deferred"]:
+                if row not in removed_parent:
+                    retain_surface_links(None, row)
+
+        fallback_surfaces = projection.fallback_surfaces(
+            coverage,
+            all_sources,
+            prospective_tasks,
+            surface_is_retained=surface_is_retained,
+            ambiguous_surface_ids=ambiguous_surface_ids,
+        )
+
+        replaced_surfaces, surface_updates = _generic_surface_updates(
+            all_sources,
+            closed_deferred,
+            active_deferred,
+            resolved,
+            reopened_generic,
+            coverage_schema["surfaces"]["items"],
+            deferred_rows,
+            ambiguous_deferred,
+            record_source,
+            candidate_order,
+            source_surface_receipts,
+            canonical_rows=canonical_rows,
+            coverage_sources=coverage_sources,
+            receipt_root=scan_dir if project_worker_coverage else None,
+            receipt_warnings=warnings,
+            fallback_surfaces=fallback_surfaces,
+            surface_is_retained=surface_is_retained,
+            eligible_receipt_sources={
+                relative
+                for relative, draft, _ in all_sources
+                if draft.get("complete") is not False or relative in selected_observations
+            },
+        )
+        replaced_rows = {
+            "surfaces": replaced_surfaces,
+            "deferred": {
+                id(row)
+                for relative, _, owner in all_sources
+                for row in deferred_rows[relative]
+                if isinstance(row, dict)
+                and isinstance(identity := row.get("id"), str)
+                and (key := record_key("deferred", owner, row)) not in candidate_ids
+                and key not in ambiguous_deferred
+                and (updated := accepted_deferred_orders.get(key)) is not None
+                and updated > candidate_order(relative, key[0], row)
+            },
+        }
+        for field, replaced in replaced_rows.items():
+            if parent and isinstance(coverage.get(field), list):
+                previous = parent["reviewState"].get(field, [])
+                if isinstance(previous, list):
+                    removed_parent = [row for row in previous if id(row) in replaced]
+                    coverage[field] = [row for row in coverage[field] if row not in removed_parent]
+        if isinstance(coverage.get("surfaces"), list):
+            for relative, owner, source_surface, surface in surface_updates:
+                original_surface = surface
+                # Generic updates already resolve each receipt at its saved source.
+                surface = projection.repair_reviewed_surface(
+                    coverage,
+                    projected_coverage if parent_is_canonical else {},
+                    workers_by_id.get(owner),
+                    source_surface,
+                    surface,
+                ) or project_record("surfaces", surface, source_surface, receipts_resolved=True)
+                reconciled_surface_ids[record_key("surfaces", owner, source_surface)] = surface[
+                    "id"
+                ]
+                if surface not in coverage["surfaces"] and (
+                    surface is original_surface
+                    or retained_coverage_record("surfaces", surface) is None
+                ):
+                    retain_coverage_row(
+                        coverage["surfaces"],
+                        surface,
+                        owner,
+                        "surfaces",
+                        source_surface,
+                        surface is not original_surface or relative == "parent",
+                    )
+            for surface in coverage["surfaces"]:
+                if isinstance(surface, dict):
+                    surface.setdefault("receiptRefs", [])
+
+        # Reopened work survives a superseded checkpoint, but current candidate
+        # outcomes still apply. Parent closures cannot remove another worker's row.
+        for owner, item in reopened_rows:
+            source_owner, original = record_source("deferred", owner, item)
+            if (
+                identity := _deferred_candidate_id(original, source_owner, ambiguous_deferred)
+            ) is not None and (
+                source_owner,
+                identity,
+            ) in resolved:
+                continue
+            original_item = item
+            item = project_record("deferred", item)
+            pending = coverage.setdefault("deferred", [])
+            if (
+                isinstance(pending, list)
+                and item not in pending
+                and (item is original_item or retained_coverage_record("deferred", item) is None)
+            ):
+                retain_coverage_row(
+                    pending, item, owner, "deferred", original_item, item is not original_item
+                )
+        for _, draft, owner in all_sources:
+            for surface in _coverage_rows(draft["reviewState"], "surfaces"):
+                if (
+                    isinstance(surface, dict)
+                    and ambiguous_pending_surface(surface, owner)
+                    and isinstance(coverage.get("surfaces"), list)
+                ):
+                    original_surface = {**surface, "receiptRefs": surface.get("receiptRefs", [])}
+                    retained_surface = project_record("surfaces", original_surface, surface)
+                    if retained_surface not in coverage["surfaces"] and (
+                        retained_surface is original_surface
+                        or retained_coverage_record("surfaces", retained_surface) is None
+                    ):
+                        retain_coverage_row(
+                            coverage["surfaces"],
+                            retained_surface,
+                            owner,
+                            "surfaces",
+                            surface,
+                            retained_surface is not original_surface,
+                        )
+        for relative, draft, worker_id in all_sources:
+            selection = source_coverage_selection(relative, worker_id)
+            (
+                selected_coverage_superseded,
+                selected_candidates,
+                superseded,
+                retain_pending,
+                coverage_superseded,
+            ) = selection
+            skip_superseded_findings = (
+                superseded
+                and not stopped
+                and all(
+                    valid_finding(finding) for finding in (parent["findings"] if parent else [])
+                )
+            )
+            if (
+                skip_superseded_findings
+                and coverage_superseded
+                and not selected_candidates
+                and not retain_pending
+            ):
+                continue
+            if (
+                not dry_run
+                and not skip_superseded_findings
+                and "threatModel" not in manifest["scan"]
+                and isinstance(draft.get("threatModel"), dict)
+            ):
+                model = recovered_model(relative, draft, worker_id)
+                model_path = relative
+                checkpoint_dir = Path(relative).parent
+                root_checkpoint = checkpoint_dir == Path("checkpoints")
+                prefer_checkpoint_head = root_checkpoint or (
+                    worker_id is not None
+                    and (checkpoint_dir.name == "checkpoints" or draft.get("complete") is False)
+                )
+                if worker_id is not None or root_checkpoint:
+                    if checkpoint_dir.name != "checkpoints":
+                        checkpoint_dir /= "checkpoints"
+                    selected_models = [
+                        path
+                        for path in drafts_by_path
+                        if (
+                            path in selected_observations
+                            or (
+                                path in current_results
+                                and drafts_by_path[path].get("complete") is not False
+                            )
+                        )
+                        and (
+                            Path(path).parent == checkpoint_dir
+                            or (
+                                path in current_results
+                                and Path(path).parent / "checkpoints" == checkpoint_dir
+                            )
+                        )
+                        and isinstance(drafts_by_path[path].get("threatModel"), dict)
+                        and recovered_model(path, drafts_by_path[path], worker_id) is not None
+                    ]
+                    if selected_models:
+                        authoritative_models = [
+                            path
+                            for path in selected_models
+                            if path in authoritative_heads or path in current_results
+                        ]
+                        if not any(path in authoritative_heads for path in selected_models):
+                            authoritative_models = selected_models
+                        head_path = max(
+                            authoritative_models or selected_models,
+                            key=lambda path: (source_order[path], path in authoritative_heads),
+                        )
+                        current = drafts_by_path[head_path]
+                        # A terminal checkpoint is committed before result.json is replaced.
+                        # Use the admitted observation, including its frozen ordering on retries.
+                        if not prefer_checkpoint_head and current.get("complete") is not False:
+                            prefer_checkpoint_head = (
+                                source_order[head_path] >= source_order[relative]
+                            )
+                        if prefer_checkpoint_head:
+                            model = recovered_model(head_path, current, worker_id)
+                            model_path = head_path
+                if model is not None:
+                    manifest["scan"]["threatModel"] = model
+                    if selected_model_source is not None and model_path in source_digests:
+                        selected_model_source[:] = [model_path]
+            if not dry_run:
+                retain_findings(
+                    relative, draft, worker_id, selected_candidates, skip_superseded_findings
+                )
+            worker = workers_by_id.get(worker_id)
+            # Only the accepted current output belongs to this worker attempt. An
+            # unsuperseded archive can remain evidence after that output is lost.
+            project_coverage = (worker_id, relative) in accepted_sources
+            if coverage_superseded and not selected_candidates and not retain_pending:
+                continue
+            if project_coverage:
+                reviews = coverage.setdefault("reviews", [])
+                if isinstance(reviews, list) and not any(
+                    isinstance(review, dict)
+                    and review.get("workerId") == worker_id
+                    and review.get("attempt") == worker["attempt"]
+                    for review in reviews
+                ):
+                    reviews.append(
+                        {
+                            "workerId": worker_id,
+                            "attempt": worker["attempt"],
+                            "completeness": draft["reviewState"].get("completeness", "partial"),
+                        }
+                    )
+            for field in ("surfaces", "explicitExclusions", "deferred", "openQuestions", "reviews"):
+                if field == "reviews" and (
+                    worker_id is not None or field not in draft["reviewState"]
+                ):
+                    continue
+                if coverage_superseded and field not in {
+                    "surfaces",
+                    "explicitExclusions",
+                    "deferred",
+                }:
+                    continue
+                items = draft["reviewState"].get(field, [])
+                if field == "deferred":
+                    items = deferred_rows[relative]
+                if not isinstance(items, list):
+                    continue
+                output = coverage.setdefault(field, [])
+                if not isinstance(output, list):
+                    # Keep malformed canonical collections for the existing finalizer's
+                    # recovery and warnings rather than silently changing its contract.
+                    continue
+                for index, item in enumerate(items, 1):
+                    source_item = item
+                    if not (
+                        surface_is_retained(relative, worker_id, item)
+                        if field == "surfaces"
+                        else coverage_row_is_retained(field, item, worker_id, selection)
+                    ):
+                        continue
+                    if id(item) in replaced_rows.get(field, ()):
+                        continue
+                    if (
+                        field == "deferred"
+                        and isinstance(item, dict)
+                        and isinstance(item.get("id"), str)
+                        and record_key("deferred", worker_id, item) in closed_deferred
+                    ):
+                        continue
+                    if field == "openQuestions" and isinstance(item, str):
+                        item = {"question": item.strip()}
+                    if (
+                        field == "surfaces"
+                        and isinstance(item, dict)
+                        and item.get("disposition") in ("rejected", "not_applicable")
+                        and isinstance(item.get("candidateId"), str)
+                        and (
+                            history_findings := rejected_history.get(
+                                (worker_id, item["candidateId"])
+                            )
+                        )
+                    ):
+                        item = copy.deepcopy(item)
+                        for finding in history_findings:
+                            _append_previous_finding(item, finding, clone=True)
+                    projected_row = False
+                    if isinstance(item, dict):
+                        original_item = item
+                        item = (
+                            project_missing_record(field, item, index, worker, draft["reviewState"])
+                            if project_coverage
+                            else project_record(field, item, source_item)
+                        )
+                        projected_row = item is not original_item
+                    if field == "surfaces" and isinstance(item, dict):
+                        item = {**item, "receiptRefs": item.get("receiptRefs", [])}
+                    if (
+                        field == "surfaces"
+                        and worker is not None
+                        and isinstance(item, dict)
+                        and (project_coverage or not projected_row)
+                    ):
+                        item = copy.deepcopy(item)
+                        item["receiptRefs"] = coverage_receipts(item, worker, relative)
+                    if (
+                        projected_row
+                        and isinstance(item, dict)
+                        and retained_coverage_record(field, item) is not None
+                    ):
+                        continue
+                    if isinstance(item, dict) and "id" not in item:
+                        semantic_item = dict(item)
+                        existing = next(
+                            (
+                                existing
+                                for existing in output
+                                if isinstance(existing, dict)
+                                and {key: value for key, value in existing.items() if key != "id"}
+                                == semantic_item
+                            ),
+                            None,
+                        )
+                        if existing is not None:
+                            _inherit_coverage_sources(existing, [source_item], coverage_sources)
+                            if field == "surfaces":
+                                retained_surface_rows.add(id(source_item))
+                            continue
+                    retain_coverage_row(
+                        output,
+                        item,
+                        worker_id,
+                        field,
+                        source_item,
+                        projected_row or project_coverage,
+                    )
+
+        projection.finalize(
+            coverage,
+            canonical_rows,
+            _digest,
+            preserve_canonical_parent=preserve_canonical_parent,
+            all_sources=all_sources,
+            source_order=source_order,
+            coverage_sources=coverage_sources,
+            surface_ids_by_source=surface_ids_by_source,
+            retained_surface_rows=retained_surface_rows,
+            resolved=resolved,
+        )
+        if not dry_run:
+            break
+        invalid = _conflicting_outcome_receipts(
+            coverage,
+            scan_dir,
+            competing_receipts - unavailable,
+        )
+        if invalid:
+            unavailable.update(invalid)
+            resolved, ordered_outcomes = select_outcomes(unavailable)
+        else:
+            dry_run = False
+
+    # Generate new worker identities from the retained collection, as a normal
+    # Deep parent does. Authored, restored and canonical identities stay stable.
+    generated_worker_ids = {id(finding) for finding in generated_worker_findings}
+    for finding in generated_worker_findings:
+        finding.pop("identity", None)
+
+    def publication_order(item):
+        _, group = item
+        source, value = group["observations"][group["owner"]]
+        index = next(index for index, row in enumerate(source[1]["findings"]) if row is value)
+        return finding_source_order(source, True), -index
+
+    identity_order = list(findings)
+    for owner in {group["owner"] for _, group in finding_positions.values() if group is not None}:
+        positions = [
+            (position, group)
+            for position, group in finding_positions.values()
+            if group is not None and group["owner"] == owner and group["identity"] is None
+        ]
+
+        for (position, _), (published_position, _) in zip(
+            positions, sorted(positions, key=publication_order, reverse=True), strict=True
+        ):
+            identity_order[position] = findings[published_position]
+    identity_order = [
+        finding
+        for finding in identity_order
+        if valid_finding(finding) and ("identity" in finding or id(finding) in generated_worker_ids)
+    ]
+    _ensure_finding_identities(identity_order)
+
+    identities: dict[bytes, list[tuple[str, dict[str, Any] | None, str | None]]] = {}
+    retained_groups = {
+        position: group for position, group in finding_positions.values() if group is not None
+    }
+    reserved_identities = {_semantic_identity_key(finding) for finding in identity_order}
+    for position, finding in enumerate(findings):
+        if not valid_finding(finding):
+            continue
+        identity = finding.get("identity")
+        if not isinstance(identity, dict):
+            continue
+        key = _semantic_identity_key(finding)
+        variant = _finding_key(finding)
+        group = retained_groups.get(position)
+        previous = next(
+            (
+                entry
+                for entry in identities.get(key, [])
+                if entry[0] == variant and not distinct_reports(group, entry[1])
+            ),
+            None,
+        )
+        if previous is not None and previous[2] is not None:
+            if identity.get("instance") != previous[2]:
+                finding.setdefault("provenance", {}).setdefault(
+                    "preservedIdentity", copy.deepcopy(identity)
+                )
+                identity["instance"] = previous[2]
+        elif previous is None and key in identities:
+            finding.setdefault("provenance", {}).setdefault(
+                "preservedIdentity", copy.deepcopy(identity)
+            )
+            base_instance = identity.get("instance", "saved")
+            suffix = 2
+            while True:
+                identity["instance"] = f"{base_instance}-{suffix}"
+                distinct = _semantic_identity_key(finding)
+                if distinct not in reserved_identities:
+                    reserved_identities.add(distinct)
+                    break
+                suffix += 1
+        identities.setdefault(key, []).append((variant, group, identity.get("instance")))
+    coverage.pop("completeness", None)
+    if stopped:
+        if not isinstance(coverage.get("deferred"), list):
+            coverage["deferred"] = []
+        item = {"id": "scan-stopped", "reason": reason}
+        if item not in coverage["deferred"]:
+            coverage["deferred"].append(item)
+    for surface in _coverage_rows(coverage, "surfaces"):
+        if isinstance(surface, dict) and isinstance(surface.get("provenance"), dict):
+            surface["provenance"].pop("scanReceiptRefs", None)
+    if (
+        frozen_source_digests is None
+        or heads_snapshotted
+        or snapshot_error is not None
+        or any(_is_source_order_snapshot(path) for path in source_digests)
+        or allow_frozen_legacy_parent
+    ):
+        try:
+            if snapshot_error is not None:
+                raise snapshot_error
+            _freeze_source_times(
+                scan_dir,
+                scan_id,
+                source_digests,
+                source_times,
+                parent_context,
+                created_paths=created_paths,
+            )
+        except (ContractError, OSError) as exc:
+            failure = _CheckpointSnapshotError(
+                str(exc),
+                {
+                    path: (digest, source_times[path])
+                    for path, digest in source_digests.items()
+                    if not _is_source_order_snapshot(path)
+                },
+            )
+            failure.parent_context = parent_context
+            failure.heads = checkpoint_heads
+            failure.documents = (manifest, {"findings": findings}, coverage)
+            if isinstance(manifest["scan"].get("threatModel"), dict):
+                failure.model_source = list(selected_model_source or [])
+            raise failure from exc
+
+    return manifest, {"findings": findings}, coverage
Full technical diff · 281 changed fields

changed /files/.codex-plugin~1plugin.json/sha256

BEFORE
"527d1a0db286884729572d400b0ad9b0ff852d4a12b36228ff5fbef180f7de9d"
AFTER
"3766646eafb09a5e691657999f4f423c9652bbac286c0e0f55e179169aa97e99"

changed /files/.codex-plugin~1plugin.json/size

BEFORE
1582
AFTER
1846

changed /files/.mcp.json/sha256

BEFORE
"7c5968060f6e848859ce02450d6e02e67029d8d39011bbda1059b19de6309ebf"
AFTER
"69bbc0f86c92397eb7540ff09c17d69d429b0dc45dc1de3e02b16d101adfe7c0"

changed /files/.mcp.json/size

BEFORE
1679
AFTER
2078

removed /files/examples~1completed-scan~1coverage.json

BEFORE
{
  "sha256": "d55b9b98d48323b4659dfee6531ec83ec538f2084325412b7188bf85ad68b01b",
  "size": 467
}
AFTER
Field is absent

changed /files/examples~1completed-scan~1findings.json/sha256

BEFORE
"a6dc4521d6478828224fbafc33585401a47bfeb0e56e07b5d2886e8a29937f2f"
AFTER
"3c63586ea38b07b1d5ad9004ba2afc27f67e79ed164da508c7beae72648eb3b7"

changed /files/examples~1completed-scan~1findings.json/size

BEFORE
1844
AFTER
2678

changed /files/examples~1completed-scan~1report.md/sha256

BEFORE
"83b7c709c0b49d1500b52e61a88ea70b8423ebebec38308b1294cf094838b66f"
AFTER
"fe1ef26b96b22a519f3a1367cade27d466a7ced669cf8e2ddb0b2adb3e9246dc"

changed /files/examples~1completed-scan~1report.md/size

BEFORE
4116
AFTER
2910

changed /files/examples~1completed-scan~1scan-manifest.json/sha256

BEFORE
"d245ae9fc62a676293c6821e562d1a2d7d59db12d5b8dc99b85f7c5f1462fe00"
AFTER
"85d7e8ce925bfc49cab180ab87e24f156b9c470fada7511ddc70ce4390dfaae6"

changed /files/examples~1completed-scan~1scan-manifest.json/size

BEFORE
1245
AFTER
1227

added /files/examples~1legacy-completed-scan~1coverage.json

BEFORE
Field was absent
AFTER
{
  "sha256": "d55b9b98d48323b4659dfee6531ec83ec538f2084325412b7188bf85ad68b01b",
  "size": 467
}

added /files/examples~1legacy-completed-scan~1findings.json

BEFORE
Field was absent
AFTER
{
  "sha256": "a6dc4521d6478828224fbafc33585401a47bfeb0e56e07b5d2886e8a29937f2f",
  "size": 1844
}

added /files/examples~1legacy-completed-scan~1report.md

BEFORE
Field was absent
AFTER
{
  "sha256": "062030ba6d342c615aaed926775813b1c3a69bb503e3fa621298fe30914520df",
  "size": 4158
}

added /files/examples~1legacy-completed-scan~1scan-manifest.json

BEFORE
Field was absent
AFTER
{
  "sha256": "d245ae9fc62a676293c6821e562d1a2d7d59db12d5b8dc99b85f7c5f1462fe00",
  "size": 1245
}

removed /files/integrity.json

BEFORE
{
  "sha256": "6b342df66fb9b5ce7fc8c9de0e974b59d21340cdc06167df46d1a19bd4ea9441",
  "size": 17465
}
AFTER
Field is absent

added /files/mcp~1fzstd-LICENSE.txt

BEFORE
Field was absent
AFTER
{
  "sha256": "62249119bb7df6e54300f37a37145c26a6d4420410aac8881a119c5b427cf751",
  "size": 1069
}

changed /files/mcp~1helpers.mjs/sha256

BEFORE
"c272f3761e5c405619b26e4d0fd621df5ac189f2ee1bb32b975480e9835f9ca8"
AFTER
"1cf4f6bfaa9462c467a61f743ca9cd65f0a61fedf8839dc4f78f1179774673ba"

changed /files/mcp~1helpers.mjs/size

BEFORE
1097
AFTER
766

added /files/mcp~1helpers.mjs.br

BEFORE
Field was absent
AFTER
{
  "sha256": "b26250268c324738d87354096135f9df52405eea495c89f96aedf2b1d879753c",
  "size": 160967
}

removed /files/mcp~1helpers.mjs.br.part-000

BEFORE
{
  "sha256": "6299f73c92c4f924bffc6b1bed001480603473967006b3e75941bc49a21f18d5",
  "size": 63398
}
AFTER
Field is absent

changed /files/mcp~1native~1THIRD_PARTY_NOTICES.txt/sha256

BEFORE
"16ac63908855f5bb7eab864923cc1855b406bd7051dfcd70d7e69684f6c69955"
AFTER
"32c4db438d7141ea680b20b3d7e6093e548012ca482a6399176cf20985a3a55f"

changed /files/mcp~1native~1THIRD_PARTY_NOTICES.txt/size

BEFORE
308404
AFTER
286866

changed /files/mcp~1native~1darwin-arm64~1unix.node/sha256

BEFORE
"093e87d8de3d2676fc9a2a1430f571bf4fc970b2bbef4c7ded0bf8924e45f473"
AFTER
"0fc69686798e3f71f02a7f9d802e39f7c44f6a9bc1a5e3ea863960afaba13c23"

changed /files/mcp~1native~1darwin-arm64~1unix.node/size

BEFORE
354352
AFTER
421776

changed /files/mcp~1native~1darwin-x64~1unix.node/sha256

BEFORE
"57c45d212d35ce7599afc7b9b21693e18443753231bad1fb5146a4e224db68ec"
AFTER
"8ca00589f8f565d286ed5eeb6fbaa33acfe993fbd3a3e2c0ac552cc1a2100e48"

changed /files/mcp~1native~1darwin-x64~1unix.node/size

BEFORE
343296
AFTER
430688

changed /files/mcp~1native~1linux-arm64-gnu~1unix.node/sha256

BEFORE
"6b352aaaac21f9ad9b772481429ba7bc8433a0e44ca5ffe433ad47289c3007f6"
AFTER
"dd83a0bd82214da9da00583fdab234bebfd86e20c7e352c5b93d9e93603ab932"

changed /files/mcp~1native~1linux-arm64-gnu~1unix.node/size

BEFORE
465088
AFTER
531752

changed /files/mcp~1native~1linux-arm64-musl~1unix.node/sha256

BEFORE
"3a55ec4f42202c58a29654701c31a8deab386969d14e2ab85f23e81345b4fedb"
AFTER
"998b604f3f32c40e119e122e16d9d3f91e201d6066fb7a0369f6d273c8ff556a"

changed /files/mcp~1native~1linux-arm64-musl~1unix.node/size

BEFORE
332456
AFTER
463536

changed /files/mcp~1native~1linux-x64-gnu~1unix.node/sha256

BEFORE
"ed2061078400010852a9f8d3ecdf7bc0a008d13adc9e9d5c6954f5cb686a2a2a"
AFTER
"7b447ad208c2c52182843ac1042f13da86cbbcb932bb48e07812cb8bdb8dac5e"

changed /files/mcp~1native~1linux-x64-gnu~1unix.node/size

BEFORE
365352
AFTER
458464

changed /files/mcp~1native~1linux-x64-musl~1unix.node/sha256

BEFORE
"c2e4c07ac6dde175464c6315937652465b200e5f28590898663523beaf4e9ab6"
AFTER
"c2bbb330743b264052ec677b60b3d0bc7e6356eb64116cf19fd0f00b2400e4fb"

changed /files/mcp~1native~1linux-x64-musl~1unix.node/size

BEFORE
369304
AFTER
459432

changed /files/mcp~1native~1win32-arm64~1windows.node/sha256

BEFORE
"19f78e88fd8934038201c26b044123bc05db74f5d7065df10a32583ccbcf7a55"
AFTER
"0856b9c435fd5407bec2fce4c3d536f14e27f2bb298eb80b267f4260577635d1"

changed /files/mcp~1native~1win32-arm64~1windows.node/size

BEFORE
419840
AFTER
571904

changed /files/mcp~1native~1win32-x64~1windows.node/sha256

BEFORE
"5aed21edb5fe06efac49d9bd3899d6242f60b1bfac2b710b967a76c924d98298"
AFTER
"b3cfc53a2efe0da8581ffe8a13203b4a1921bc0f11f2b3ea52e5962a72a0951b"

changed /files/mcp~1native~1win32-x64~1windows.node/size

BEFORE
453120
AFTER
623104

added /files/mcp~1package.json

BEFORE
Field was absent
AFTER
{
  "sha256": "5bbbec757633dcbc268e91dd63a59bd3c09b9626ea5cedd3b6656379ed0cb643",
  "size": 17
}

added /files/mcp~1permission-profile-preflight.mjs

BEFORE
Field was absent
AFTER
{
  "sha256": "cacb1f399a1e53a732ff09a33babf886d8691e1eb2762adbbaf57ee6c5bde84f",
  "size": 24633
}

changed /files/mcp~1server.mjs/sha256

BEFORE
"c58624aa4c4bd3efbb67601c9c2e98759f167f608320a6cd342814b2f2e6a636"
AFTER
"acb2bdf8446b3116d48dc075a64613d92805a690a178277f612e5082cf1f2687"

changed /files/mcp~1server.mjs/size

BEFORE
1096
AFTER
765

added /files/mcp~1server.mjs.br

BEFORE
Field was absent
AFTER
{
  "sha256": "456bf45d8653a176a5ee28a6923766488e75f05546738ac6d0f32af3e4fc27ab",
  "size": 339502
}

removed /files/mcp~1server.mjs.br.part-000

BEFORE
{
  "sha256": "7ef9c7387b405b51e2aec793a86696bf793506a8f34155199035aa515b3a415a",
  "size": 140000
}
AFTER
Field is absent

removed /files/mcp~1server.mjs.br.part-001

BEFORE
{
  "sha256": "94d6412009e284ecbc17bd14d07e0116d8e74e572a62198912ac5a03f95a50c2",
  "size": 126028
}
AFTER
Field is absent

added /files/mcp~1session-decompression.mjs

BEFORE
Field was absent
AFTER
{
  "sha256": "bacebc26fe0d726622d2af9b9007b27bd0b717662098b29c6b2130ca901d2d21",
  "size": 17439
}

removed /files/preflight~1capability-profiles.toml

BEFORE
{
  "sha256": "543a0f6a0e81cbbac1fe43e2e3d44d6163a6792384ab9c768ac519295d9ec8a1",
  "size": 2350
}
AFTER
Field is absent

added /files/references~1access-advisory.md

BEFORE
Field was absent
AFTER
{
  "sha256": "7f4bf0905d60e35a70e0bbfe27d5578f8af4777afc46a92f33cb43f4250fe68c",
  "size": 1448
}

changed /files/references~1artifact-storage.md/sha256

BEFORE
"ccce9c76f5d044fbce333d6129fbb55eb63f512c15c2ebeeca405e296f38325b"
AFTER
"e8c173d1e89ec7b930953bf04220905a6ab35c3798c8e66799ded3b06c1a87d2"

changed /files/references~1artifact-storage.md/size

BEFORE
7632
AFTER
7947

added /files/references~1baseline-auditor.md

BEFORE
Field was absent
AFTER
{
  "sha256": "717ad7cdcda32fe212e7f930ea5c1cb301eae005833490808dce35d49314a74b",
  "size": 2839
}

removed /files/references~1config-preflight.md

BEFORE
{
  "sha256": "5894f9fd7efcae7034404a2c062ee3d7417520753be16ddcdb3acf5b884f048d",
  "size": 19162
}
AFTER
Field is absent

changed /files/references~1core-scan.md/sha256

BEFORE
"9c0eca53147383a89cd345eac7791ea75b954f7f083448ef25019d8f9ba30afe"
AFTER
"6954c9a971611b79dcf03b4c62991e70cfd437fe249627249af6dc2709517868"

changed /files/references~1core-scan.md/size

BEFORE
22978
AFTER
7479

added /files/references~1default-severity-rubric.md

BEFORE
Field was absent
AFTER
{
  "sha256": "b718f8314712b307690d31d9c6f533c113ad1754f725b8d37856b6dc58a42043",
  "size": 3348
}

removed /files/references~1desktop-config-preflight.md

BEFORE
{
  "sha256": "d03e7c604a0459509a4a3238289c3ad0725811e8b11fb7d0044ce8bcee6a7a26",
  "size": 1587
}
AFTER
Field is absent

changed /files/references~1final-report.md/sha256

BEFORE
"9c34375584c8ae76959b0eae038b86b2b8ed7874517c249fcae8715314c76298"
AFTER
"f742994e8c9109cf6072c578104f75a7353bd562614ee7288a30105c53717c89"

changed /files/references~1final-report.md/size

BEFORE
29931
AFTER
12135

changed /files/references~1finding-detail-fields.md/sha256

BEFORE
"9e4dcc5633ca1f31291688606e4ec0d56067ed485e748ac9e7d433984f9ab451"
AFTER
"6580ca83b7a9208dfa23f0e3626b5ce957b331c6c861815005720a3a2370752f"

changed /files/references~1finding-detail-fields.md/size

BEFORE
11920
AFTER
10874

added /files/references~1focused-investigator.md

BEFORE
Field was absent
AFTER
{
  "sha256": "5624cca98860204c50ac3f281486594b690a04a4979144fd608769a50aadfc18",
  "size": 2548
}

added /files/references~1investigation-time-budget.md

BEFORE
Field was absent
AFTER
{
  "sha256": "3216d053bd2e4ede72d3a64ef38974d293dfb54a000a40782d73357070b0f1e9",
  "size": 1749
}

changed /files/references~1sarif-adapter.md/sha256

BEFORE
"32725cc851d998c9b33f0232c435d720383c86bc13526b04d356b85d08101cc5"
AFTER
"76c69bd20b0e4fca20daeaad5e5dd89ad742a210afb7dce6331eec3defc7cb3e"

changed /files/references~1sarif-adapter.md/size

BEFORE
2341
AFTER
2829

changed /files/references~1scan-artifacts.md/sha256

BEFORE
"eecdccac30b8ad65bb702dc9ac8d9718dcb0b95532a94a61195268d22bdf504b"
AFTER
"30a83f78ed066b1b4cfec3486b9f87952fb3c188fe16d16f654e025c6d3737e6"

changed /files/references~1scan-artifacts.md/size

BEFORE
11243
AFTER
11701

changed /files/references~1scan-contract.md/sha256

BEFORE
"b362636c29d1e8b18053481abe2f97d7bb099a97040f5b63aa2702a41c1d62c8"
AFTER
"ba4e01a4c3c753f41d1ffd69d6bb10c51fb12b9a6a8904c42e6e66e3fbe2a13c"

changed /files/references~1scan-contract.md/size

BEFORE
14537
AFTER
16529

changed /files/references~1scan-prologue.md/sha256

BEFORE
"1d23ab6db651134b54307cdea873ffa711a83458bda563f1e126f35e83b278e9"
AFTER
"87f0e966103ab5dd608611854370599a8fd2aa7ff91fe342b52f777352449c73"

changed /files/references~1scan-prologue.md/size

BEFORE
4812
AFTER
5747

added /files/references~1scan-runtime.md

BEFORE
Field was absent
AFTER
{
  "sha256": "5ebe088747c8458b768609d058c7a53305e1b78af660e5a1f328baead1ef5686",
  "size": 1558
}

changed /files/references~1security-guidance.md/sha256

BEFORE
"a0f49ad3bd09fa6180a100d81326b75bf87a2d49893ca9e37b64ab151c759a80"
AFTER
"f52e88c85634c0a3b254f9a0f2ed0aa6652c63c34453bd0a87a73c20c990459f"

changed /files/references~1security-guidance.md/size

BEFORE
1801
AFTER
2830

added /files/references~1standalone-validation.md

BEFORE
Field was absent
AFTER
{
  "sha256": "a2357b01e308bea046a4cfa65a7734f2b7e2e2d84ef72dcb9efade68ff76f5b3",
  "size": 2134
}

changed /files/references~1threat-model.md/sha256

BEFORE
"f3dd2d05d7f0c61b13d29a78e810b367772fe22d5ac58adbbc00080a9495706e"
AFTER
"5cd54326b7b7801b28e1480d76e19bfeda7ff30129d911359c9d5fa31c9b0b45"

changed /files/references~1threat-model.md/size

BEFORE
15203
AFTER
7751

added /files/references~1validate-scan-findings.md

BEFORE
Field was absent
AFTER
{
  "sha256": "32ed68556c537f479b0fc09aa78e184d75ddc13cac9b9bec1d9297fe06b92737",
  "size": 1131
}

changed /files/schemas~1coverage.schema.json/sha256

BEFORE
"6ac14e659e884e9582d8bd9ba480f6364ca17309e1a3dee9469ab025a3380b11"
AFTER
"3629bdde34e73e13be85d54c81487805677560c6d7c9077a50444715afcf188d"

changed /files/schemas~1coverage.schema.json/size

BEFORE
5198
AFTER
3893

changed /files/schemas~1definitions~1artifact-common.schema.json/sha256

BEFORE
"8187236867a2397515571d937deac92dcbf23d3db5e330d32b1f24aced4b9abc"
AFTER
"73f7137f00e61e714e2903e427daabeb71d646310005f90b582fa468fac53aae"

changed /files/schemas~1definitions~1artifact-common.schema.json/size

BEFORE
1065
AFTER
870

changed /files/schemas~1definitions~1discovery-candidate.schema.json/sha256

BEFORE
"b0cf54fc1ae1947db0f6a6f73e17d1124d528226de763fb89489d05fd612331b"
AFTER
"1fc379a8c79c57d9889a7a3d278f4f3e31fd8337dd0aa0a59ff171ecf817624d"

changed /files/schemas~1definitions~1discovery-candidate.schema.json/size

BEFORE
2951
AFTER
4203

changed /files/schemas~1findings.schema.json/sha256

BEFORE
"a480337cc0fa4c48c44fc7be17c6c4348767815570775cda80f2aaf797b8e56c"
AFTER
"c53067bf1f17b88de5b555ed4d074f7d17975294345b40f16c7a9f91019c9f67"

changed /files/schemas~1findings.schema.json/size

BEFORE
19167
AFTER
10591

changed /files/schemas~1patch-risk-assessment.schema.json/sha256

BEFORE
"536492481c5b67910ce8d3754d61c7d5a44c5cb78fe3f081e8f5d1620d6ae9c9"
AFTER
"f36759528740edd9c6c86e76b034cf59a3c6796b143f2ed0d8bbfd011f02811d"

changed /files/schemas~1patch-risk-assessment.schema.json/size

BEFORE
6854
AFTER
6858

changed /files/schemas~1scan-manifest.schema.json/sha256

BEFORE
"c621d4136ac81741ac8da1960c7f5e92ade22c0b5490e378ea4339b09e45b6f3"
AFTER
"4bac4a5b898ebe72d9bf1128f3a8530979159b3c3bfe2c37ccd3c651f47ce234"

changed /files/schemas~1scan-manifest.schema.json/size

BEFORE
9513
AFTER
7815

changed /files/schemas~1tools~1candidate-attack-paths.schema.json/sha256

BEFORE
"f6fcb643b4b975466c4717356a0768b0572812cd832578d8714557f5e3d16935"
AFTER
"0550e20a4b51f5d7d0edc71f98a31441c92df55b5f36eb366b39b2e878ae9a0c"

changed /files/schemas~1tools~1candidate-attack-paths.schema.json/size

BEFORE
6055
AFTER
6810

changed /files/schemas~1tools~1candidate-validations.schema.json/sha256

BEFORE
"c871eb3462b7873c1774e6aade62acdd570636e43c0ac3c7b41b7041ca5627e9"
AFTER
"e89cd513a320d376b6366ea1f1365b62415c7a1355778c285103b34f23733f48"

changed /files/schemas~1tools~1candidate-validations.schema.json/size

BEFORE
4916
AFTER
4519

removed /files/schemas~1tools~1deep-reducer.schema.json

BEFORE
{
  "sha256": "5f0c25f826445251415986097c41127018d19b6c690cd99720fd9365893b0028",
  "size": 2221
}
AFTER
Field is absent

changed /files/schemas~1tools~1discovery-candidates.schema.json/sha256

BEFORE
"dcd2031d64015c69b415c66e57d6e90cbdef91152a445a6f409c14d80153afa6"
AFTER
"5ebffa84b6a60e6e15c2eecb08f05353af2a239f6f463883efe954b482997d7c"

changed /files/schemas~1tools~1discovery-candidates.schema.json/size

BEFORE
2473
AFTER
1152

changed /files/schemas~1tools~1review-items.schema.json/sha256

BEFORE
"acc4f4909446a62811728dd1d6581456053da8d26f774b7af208a1856f86ac5b"
AFTER
"f7c4522e9e6faf736347b40a42a0839df5fe6818ad1cfd377ef1d452a233a87b"

changed /files/schemas~1tools~1review-items.schema.json/size

BEFORE
2250
AFTER
1431

changed /files/schemas~1tools~1scan-draft.schema.json/sha256

BEFORE
"151f9dffc83e1c5b4f0a7fba20b90fb3196fdaa9719180eb0009ba2b50f75d48"
AFTER
"fc3cdd65c39a22d6fc110076696a43fbf67226044e989a1047682473521973d4"

changed /files/schemas~1tools~1scan-draft.schema.json/size

BEFORE
23475
AFTER
28295

removed /files/schemas~1tools~1worker-threat-model.schema.json

BEFORE
{
  "sha256": "a00f875918794661316a033bd2d03426d61ab1e41d4a36c548c07525dcfde478",
  "size": 435
}
AFTER
Field is absent

added /files/scripts~1check_deep_scan_target.py

BEFORE
Field was absent
AFTER
{
  "sha256": "165230b549343af0ad28cc5397459441506e2dfc4978ba00d717f9eb964a34c5",
  "size": 3538
}

added /files/scripts~1codex_profile.mjs

BEFORE
Field was absent
AFTER
{
  "sha256": "f739efe073f5243556d2073fdf10ecf4be1305878e3334d7ce8642ed1a885311",
  "size": 8621
}

added /files/scripts~1codex_session.mjs

BEFORE
Field was absent
AFTER
{
  "sha256": "11685e239918a11fd811b36a9259b800013d3e914ee4e33c20ce024e52eeed12",
  "size": 1730
}

removed /files/scripts~1config_preflight.py

BEFORE
{
  "sha256": "f4d4103650977d078b71f49da6b1e287b6db2f2b7b5fb08e943722a6d869354e",
  "size": 35176
}
AFTER
Field is absent

changed /files/scripts~1deep_scan_config.py/sha256

BEFORE
"44229bc7b2e7f4c7654e2e9ed91650a28630eeb00fcc38358f19d69739771f8c"
AFTER
"f9e384daa017afa553ef4fb99fdff5cbec93cb22bfd76b722d962bf32534f49d"

changed /files/scripts~1deep_scan_config.py/size

BEFORE
5042
AFTER
6510

changed /files/scripts~1deep_scan_workbench.py/sha256

BEFORE
"5012b337503f44e086fbf021be9db8340f8ba992fe5169c5534752e900947cf5"
AFTER
"d5f65879341d97d18f531fae0ce197e11207761add9787c2c0031f2980dca6d9"

changed /files/scripts~1deep_scan_workbench.py/size

BEFORE
84709
AFTER
78126

added /files/scripts~1dispatch_inventory_tool

BEFORE
Field was absent
AFTER
{
  "sha256": "eff576e0e584cc093dcf2bd18ea6c64bc33eb1c448d8558ef557f7373d962a83",
  "size": 238
}

changed /files/scripts~1filesystem_identity.py/sha256

BEFORE
"5298f2012b6e48ab1106837a5440ef2b3966383e2321507a47593010bb4dd01f"
AFTER
"b9d0b916c1b8a1fbc3a7c1e6692af2d0ef19f36a36d1d66d0a9a4190112c9387"

changed /files/scripts~1filesystem_identity.py/size

BEFORE
893
AFTER
991

changed /files/scripts~1finalize_scan_contract.py/sha256

BEFORE
"3fa92d8e2ccadb032cf458f0fde444785e8ee5ced0abe6346c285b07ef153e27"
AFTER
"339d9f2068634e65147373fe87b4a88c44d4f17d3e36fa06c0fcb3e97b66f8da"

changed /files/scripts~1finalize_scan_contract.py/size

BEFORE
133770
AFTER
147094

changed /files/scripts~1finding_preview.py/sha256

BEFORE
"ebdf8e7b7e465c0937e73e945e3593d659b2f15ff1db08d0b4a2d3b106174c4d"
AFTER
"4d93ed0170cbf4f4d37b3ff202eb313ea71a19b89b5953d40c1ac05d1c7c2e90"

changed /files/scripts~1finding_preview.py/size

BEFORE
16089
AFTER
16692

removed /files/scripts~1generate_in_scope_files.py

BEFORE
{
  "sha256": "0b420d786b17e4f91451b5b686fdb4d6beee3913eebb952f8fcbf220aec6230e",
  "size": 11646
}
AFTER
Field is absent

removed /files/scripts~1generate_rank_input.py

BEFORE
{
  "sha256": "e7c0bddbdb7e9236f7431d84b86be4c3fc202daa8d1306d6baa930110635b671",
  "size": 17899
}
AFTER
Field is absent

changed /files/scripts~1launch_codex_security_mcp/sha256

BEFORE
"56794e736a1e8f588f9959a2e707ea3ed9bc7d4d2b796c132e91d5fbed59e600"
AFTER
"497680a7ecc2163da04338d2f7ec26549362b0f098b810ed57ee64c56dea3665"

changed /files/scripts~1launch_codex_security_mcp/size

BEFORE
1793
AFTER
4646

changed /files/scripts~1launch_codex_security_mcp.cmd/sha256

BEFORE
"2539c0914bb130d76629e8176ac93762cd0051677ac2c525e7ba524b0b828f80"
AFTER
"7859298f6ebdb8d58f58d163bfe2fc9023e5f1b6f336f10180269f05bdec602f"

changed /files/scripts~1launch_codex_security_mcp.cmd/size

BEFORE
2582
AFTER
2667

added /files/scripts~1legacy_findings.py

BEFORE
Field was absent
AFTER
{
  "sha256": "bb1209b9963a1698c51ba29b3047fbf3cf31fb0f1e98e4c118ecedde3ee673be",
  "size": 6125
}

added /files/scripts~1posix_scan_local_files.py

BEFORE
Field was absent
AFTER
{
  "sha256": "0911b75dc67fdc04d0284fb97977063fe88ab3dfc2ec79becc426ff55483dfd7",
  "size": 8949
}

removed /files/scripts~1rank_preview.py

BEFORE
{
  "sha256": "627d0b89c9d4436162ab9bcb80f7aa562605695e784dc612307c7eda6fef3a7f",
  "size": 34726
}
AFTER
Field is absent

added /files/scripts~1read_codex_session.mjs

BEFORE
Field was absent
AFTER
{
  "sha256": "09b47a949ae78879adc49afab1cc4ba29a450e333838ab20da429883448e752d",
  "size": 816
}

changed /files/scripts~1report_projection.py/sha256

BEFORE
"1b24978a3cdb3c336ac27a2b39fb35457bade13a4aad0782710fe38ac39965cf"
AFTER
"6e950c378fece395b7cb648425a814ae6a45211abade77b96ddeca1e743f65e5"

changed /files/scripts~1report_projection.py/size

BEFORE
41098
AFTER
41680

added /files/scripts~1review_state.py

BEFORE
Field was absent
AFTER
{
  "sha256": "567f0cef32dff8fab7fba364ad75fd42f303b5efbf85bf4a457024cd3c2342e0",
  "size": 2661
}

added /files/scripts~1servicenow_avit.py

BEFORE
Field was absent
AFTER
{
  "sha256": "f852c39d2d10adfd7d38e2aef492ccf425f56162b3f618ffd9b21a06072c7e3f",
  "size": 4625
}

changed /files/scripts~1snapshot_sqlite.py/sha256

BEFORE
"9e0be851702f0962070ece6e0e2959e3955fc99126f68452d175fc22bc38423b"
AFTER
"9f3c4835730e2e766c3b082242594bd773a3cae2cc76aa9be47a7faab96c3947"

changed /files/scripts~1snapshot_sqlite.py/size

BEFORE
1084
AFTER
1738

changed /files/scripts~1threat_model_projection.py/sha256

BEFORE
"32e4d5cd370a49cdc5658c3ded3d4d63ba7f41a44b34b67da87321048d088111"
AFTER
"e87dddf2bca93b4bd066c8c631e981ed14c770ee4fd33be8f5523f29cf6abf1a"

changed /files/scripts~1threat_model_projection.py/size

BEFORE
6711
AFTER
6687

changed /files/scripts~1validate_scan_contract.py/sha256

BEFORE
"38a5eb0126ea06b22eb82c5829e4ffcbebd2c1e55f99634454622fedd7b9e1a0"
AFTER
"a8b10d0bc03dc1b2cf040f121f65d8896e0c8f6bd4fdb7339d679234cb5ba08e"

changed /files/scripts~1validate_scan_contract.py/size

BEFORE
3803
AFTER
3224

removed /files/scripts~1validate_tracking_source.py

BEFORE
{
  "sha256": "802fb3062456128c7adceb6048183811120255b222018e123e10c5ba0caa4bdc",
  "size": 2813
}
AFTER
Field is absent

changed /files/scripts~1windows_scan_local_files.py/sha256

BEFORE
"c26276695435d134c1354048c3c74c3c6b0ed203158a93b63b67ef0b6bfab843"
AFTER
"9ab01a477f944f0ce4d3f7ef8646d477b40dc6b775b5b615b464fcf461beaee7"

changed /files/scripts~1windows_scan_local_files.py/size

BEFORE
24919
AFTER
60676

changed /files/scripts~1workbench~1__init__.py/sha256

BEFORE
"3635fffd60f51d5a5d889e20c91df803c667f8b1b29cbcf68c96cb2e0a9c33ed"
AFTER
"b33e759162aeda0e8489f518bbc13b991f8c3a2ef5270cfb381177f838d321ac"

changed /files/scripts~1workbench~1__init__.py/size

BEFORE
58
AFTER
98

changed /files/scripts~1workbench~1handoff.py/sha256

BEFORE
"83606054cc47064514a612d8ce16353cce669fe07b61852d73bc0c94b75c8ee5"
AFTER
"af4eb66124ea1d66b8625ab54c6e846a6d7375d242c5509fa0bf8ef75c202fe0"

changed /files/scripts~1workbench~1handoff.py/size

BEFORE
8914
AFTER
11403

added /files/scripts~1workbench~1retained_coverage.py

BEFORE
Field was absent
AFTER
{
  "sha256": "f6dec9dbd0197d1d4593086bbb9ebe36ea39d4891d101df0a584dad55aaa6a72",
  "size": 148411
}

added /files/scripts~1workbench~1retained_records.py

BEFORE
Field was absent
AFTER
{
  "sha256": "98d1996f869bd0071510bc3c9dffadd7cf3e6d33c960e7c6f8ea090ba69b93ac",
  "size": 24885
}

added /files/scripts~1workbench~1runtime_toml.py

BEFORE
Field was absent
AFTER
{
  "sha256": "119fe79d8ecf4feedd5f17be578b9a84b3c2b450b36fed058b5aa2cb64c750e8",
  "size": 802
}

added /files/scripts~1workbench~1saved_coverage.py

BEFORE
Field was absent
AFTER
{
  "sha256": "8884d54caaed1f8f3fa0b4a7ac128eb17535a03445cdbfabeec49731f6f076cf",
  "size": 35410
}

added /files/scripts~1workbench~1saved_outputs.py

BEFORE
Field was absent
AFTER
{
  "sha256": "f845413ad0a16542d8d3728dc0ca1231c450c7898d4770a11bd3d319c61c8fd2",
  "size": 2921
}

added /files/scripts~1workbench~1saved_sources.py

BEFORE
Field was absent
AFTER
{
  "sha256": "53859519948b55e74bbdb26d44d355e63ce8705f0db8dd117cc25d52beb5a977",
  "size": 30156
}

changed /files/scripts~1workbench~1storage.py/sha256

BEFORE
"5e389073520fb7668defd433228befd9e7b9c8309c1b6024bffd6213d59f1d88"
AFTER
"4791845b4a6b6e3437a5403e984ea2e97bc2758be052719b51aa3b353ce01d85"

changed /files/scripts~1workbench~1storage.py/size

BEFORE
973
AFTER
4390

changed /files/scripts~1workbench_cli.py/sha256

BEFORE
"959e951fa5daf326049ee61bd0773999be92600b65a9062e56b4f62fc4e2aa55"
AFTER
"79bb508b068f73b8f5444c5af82ff58e26562f08eaa9cd9aec368766970deb8f"

changed /files/scripts~1workbench_cli.py/size

BEFORE
21260
AFTER
21516

changed /files/scripts~1workbench_constants.py/sha256

BEFORE
"0ff12b11b2ae9f71c1de6cff0afc234b035379bb1193f1ca9a56ddeb7aa32cf7"
AFTER
"8cc007a47d6f687ea2860896adff1e51eb98ae6e1811b370c53e36f37fe9dde3"

changed /files/scripts~1workbench_constants.py/size

BEFORE
2187
AFTER
3177

added /files/scripts~1workbench_coverage_receipts.py

BEFORE
Field was absent
AFTER
{
  "sha256": "ab88ee90de1ff4607f9599607f76f0c619d4d5067b52a84d745b4c896703ee5a",
  "size": 21284
}

removed /files/scripts~1workbench_dashboard.py

BEFORE
{
  "sha256": "5770b77ff551cde46c22fae9239ef8ce28254320da77876e0b936dc35b829967",
  "size": 5990
}
AFTER
Field is absent

changed /files/scripts~1workbench_db.py/sha256

BEFORE
"94bf11d7d74202ae7efbdd4f70a036393d4ba013ffc2ada44172a59be41f97f2"
AFTER
"95e263bca1c718e444ddd2afe43d661264014192b4cf8cfbc157391b42920a27"

changed /files/scripts~1workbench_db.py/size

BEFORE
146186
AFTER
149908

changed /files/scripts~1workbench_feedback.py/sha256

BEFORE
"675bc5897444a39950297f74353fa6fd296f73d3a5ac87d294647ae8425151dd"
AFTER
"92ab94e29eb654a5077a2532140750d9cbe2a5ac2967cfc206e4e026eb550564"

changed /files/scripts~1workbench_feedback.py/size

BEFORE
4120
AFTER
6259

changed /files/scripts~1workbench_finding_index.py/sha256

BEFORE
"4618f994786fa2300e78592fa2868bc0a585368127027c1940a0e504b0254265"
AFTER
"dcf3482bb31f3248a84a7b9e7aa69b331fe4c50d28e501db6a10fe97ade17d3c"

changed /files/scripts~1workbench_finding_index.py/size

BEFORE
3938
AFTER
4745

changed /files/scripts~1workbench_finding_workflows.py/sha256

BEFORE
"de44bfc28c0a4d2021643a50d5a42408f4853bb4a21cf9d1f4ffb43a695b06ce"
AFTER
"2d3914e553d5e5bf710a8d27bd25f878a023449270b2045db97a9752c1f7ba51"

changed /files/scripts~1workbench_finding_workflows.py/size

BEFORE
8754
AFTER
15010

removed /files/scripts~1workbench_findings.py

BEFORE
{
  "sha256": "b78e2ca68f29cf002b6215985225e1b3996c8edd08601569945405d42c33b301",
  "size": 8881
}
AFTER
Field is absent

changed /files/scripts~1workbench_native_indexes.py/sha256

BEFORE
"114dbf1e4050302948c4b8f24d69454f127d128e3bc35e34a5f3ec9dd3b187cd"
AFTER
"a40b4cfae313b6799541f70dc251508ce9d9a474a2298742c23a823d7819139d"

changed /files/scripts~1workbench_native_indexes.py/size

BEFORE
9870
AFTER
18571

changed /files/scripts~1workbench_progress.py/sha256

BEFORE
"42c7d0b8b4d253095e1062922cd9e59b10b966ac314bef092cb78cad2217b967"
AFTER
"85fedf2b9f3095a5abb30b55f5b4a56acc0d8bdc7f2a16268123aa0d855773e2"

changed /files/scripts~1workbench_progress.py/size

BEFORE
13296
AFTER
16640

changed /files/scripts~1workbench_publication.py/sha256

BEFORE
"9312a2962b797ed355d6b05fb375da6325aeb5c5ead5d52f2fb7114ef3ad9635"
AFTER
"90834075ed64ec43a30f2f15fe265baa730ce4a473101ca4b0a420a5fef4948b"

changed /files/scripts~1workbench_publication.py/size

BEFORE
20346
AFTER
20245

changed /files/scripts~1workbench_remediation.py/sha256

BEFORE
"96585805c4956917bb473c3b60493a3c15daa2028b074b756e36358a9ac76525"
AFTER
"8e3a6e766edb0649d913af24562e8cdbe29455f742adfdb3f1c31536df5d814b"

changed /files/scripts~1workbench_remediation.py/size

BEFORE
7281
AFTER
35923

changed /files/scripts~1workbench_saved_results.py/sha256

BEFORE
"436b23a4d169006437985bb352bfd792da9e465c4c7506dce31bfd5e78524c6d"
AFTER
"f0a4ac2411dd12dccce1c911e3bff5a60054a66c5d3706090661e4b1cc1bc8ea"

changed /files/scripts~1workbench_saved_results.py/size

BEFORE
119202
AFTER
71471

changed /files/scripts~1workbench_scan_history.py/sha256

BEFORE
"920a4c6448c4ee87500e4488fdfa5a294dfa0696f94f55f2e2cbe544e5acf60f"
AFTER
"375425ddd2afcaff361905a6c2d9882e99453ece79aa75068d5c6121cd3aa81a"

changed /files/scripts~1workbench_scan_history.py/size

BEFORE
48177
AFTER
60835

changed /files/scripts~1workbench_scan_start.py/sha256

BEFORE
"647e54ce40a7dc5b17d6abe547406f22ca0cb4eee628938b4c21629eb8e73c35"
AFTER
"1ee02b3ff745b0926330c993757448be7b813067642abbdf024352b32ad1fd6e"

changed /files/scripts~1workbench_scan_start.py/size

BEFORE
7963
AFTER
19611

changed /files/scripts~1workbench_scan_usage.py/sha256

BEFORE
"21d845f8967c9206351e54f94fd2b4bbfe834434e35b642992d7a829b76cd94e"
AFTER
"eea597036388f90977d358ea4f66801aad2138c304f6ff7d573f35f3495148aa"

changed /files/scripts~1workbench_scan_usage.py/size

BEFORE
22094
AFTER
65712

changed /files/scripts~1workbench_schema.py/sha256

BEFORE
"25ef8550ded14785fa47b19f1fa358422d8883affc94641c84e68c172e800cc0"
AFTER
"08d7451b45ac74c211ad1be360854f12719cb02e876ca9ed03274c9e1315044c"

changed /files/scripts~1workbench_schema.py/size

BEFORE
51783
AFTER
18275

added /files/scripts~1workbench_setup.py

BEFORE
Field was absent
AFTER
{
  "sha256": "90a18fddfd853c8a305d8191ec098693a53dee30e6a087e092ebbdeb54fd472c",
  "size": 9683
}

removed /files/scripts~1workbench_severity.py

BEFORE
{
  "sha256": "ec74f540595e8052e295846303f31988329e0dc68fcebdd92572673555b1c99d",
  "size": 4625
}
AFTER
Field is absent

changed /files/scripts~1workbench_source_excerpt.py/sha256

BEFORE
"5681d4a5c547404f687c644f54432c10e0770b6ba4c1e6be321664579a252a24"
AFTER
"97667580f629597a284939ff60e137af3526e217165a7946de2420f19ea489d7"

changed /files/scripts~1workbench_source_excerpt.py/size

BEFORE
3210
AFTER
5200

added /files/scripts~1workbench_source_scopes.py

BEFORE
Field was absent
AFTER
{
  "sha256": "2ecd66dc35c390cecbacbb8c92a444e3f2d5ce49284581fcea036a0c11450529",
  "size": 15576
}

changed /files/scripts~1workbench_target.py/sha256

BEFORE
"08ed149295b9347ac37f2b8523c822a35f165283422c7644dabecfa236b81b72"
AFTER
"ccefc18e546174426276f99f9ea09e1f55eaa533a77e652185391bf1bffa3a1c"

changed /files/scripts~1workbench_target.py/size

BEFORE
32451
AFTER
71863

changed /files/scripts~1workbench_target_state.py/sha256

BEFORE
"9c133f67397ab4b90ce1275edc09a7e6d05900236209bc72e8f113b9f0cde287"
AFTER
"5471646ac8fe3f62d358c49ee2c0f0833ae14f57affe4bb9cea855158d0d6d1c"

changed /files/scripts~1workbench_target_state.py/size

BEFORE
1920
AFTER
44552

changed /files/scripts~1workbench_validation.py/sha256

BEFORE
"11259b8ce1e135c5a86677964f29e6331e65e5fd80a1931c80f7fac507cccb13"
AFTER
"06746a3aae15e85cd5c1671bf4da16f000cc2ad1cb19bbea9e63e00fa524e2ea"

changed /files/scripts~1workbench_validation.py/size

BEFORE
6547
AFTER
10189

added /files/shared~1workbench-history-repairs.json

BEFORE
Field was absent
AFTER
{
  "sha256": "9ce97bb58f0803c9bf67b0bc11a56d015a0444b08fbf7f2ee3bb51ab5f87b755",
  "size": 16081
}

added /files/shared~1workbench-migrations.json

BEFORE
Field was absent
AFTER
{
  "sha256": "ac63f2f69d36428a5fea82ac4bc522b7f98b8e825f7f9bf35d3aae009c89258f",
  "size": 47324
}

changed /files/skills~1assess-patch-risk~1SKILL.md/sha256

BEFORE
"c3b62a8c1d6135945a055134f50329047bb908972fc7b320a592edbc3d38b419"
AFTER
"5e115b0ba2f346e52efd2033a191da4aa40f1ff3f7b1ff5e2bde586e48eabf0d"

changed /files/skills~1assess-patch-risk~1SKILL.md/size

BEFORE
9511
AFTER
8299

added /files/skills~1assess-patch-risk~1references~1windows-validation.md

BEFORE
Field was absent
AFTER
{
  "sha256": "9a7d12e493497b2aa7135493e3d23ec35da05f687f6513266a5c45ffb67dad94",
  "size": 1173
}

changed /files/skills~1attack-path-analysis~1SKILL.md/sha256

BEFORE
"9465d2750182acbf6dd8f61e60bb47dc1ca502be5cc3f4a71da7ad39935d1eb1"
AFTER
"cacb4a0dc7676db7346b8295e555cb515092528cdd6b07a1ebb7c22790241eed"

changed /files/skills~1attack-path-analysis~1SKILL.md/size

BEFORE
8568
AFTER
5355

changed /files/skills~1attack-path-analysis~1references~1attack-path-facts.md/sha256

BEFORE
"8c8f1abb46ddf045d76908df78e3a273da8d61aaa0f37fc992534a3ddfe42430"
AFTER
"1979ea81991ba1c095c1846d4b8e09429edc6295912f87a6ebb7fa7e32651a1e"

changed /files/skills~1attack-path-analysis~1references~1attack-path-facts.md/size

BEFORE
2882
AFTER
1585

changed /files/skills~1attack-path-analysis~1references~1severity-policy.md/sha256

BEFORE
"44719bb96a1065df7683a4f7968145efd3b3f365ec95c22a4bed5b20b5d8a0a1"
AFTER
"8b715db602fc58ea48a6e96d9a69648ddd835c2c39a2fe962c0958d0a2594008"

changed /files/skills~1attack-path-analysis~1references~1severity-policy.md/size

BEFORE
15288
AFTER
2644

added /files/skills~1check-skills~1SKILL.md

BEFORE
Field was absent
AFTER
{
  "sha256": "790204df7e162d44b4ea509bb67aaa1b61ffb1f602f6f01cad0ae89e085c16fb",
  "size": 5844
}

added /files/skills~1check-skills~1agents~1openai.yaml

BEFORE
Field was absent
AFTER
{
  "sha256": "d0a8f882b30deec19f1dfdcae61b191f8a312bee3ddccc6b9536d7daf32e4862",
  "size": 272
}

added /files/skills~1cloud-findings~1SKILL.md

BEFORE
Field was absent
AFTER
{
  "sha256": "a534ce50f358a1076b4d4c186a22675a0d23f6dd97564009ea66a08813497e64",
  "size": 10563
}

added /files/skills~1cloud-findings~1agents~1openai.yaml

BEFORE
Field was absent
AFTER
{
  "sha256": "37c9d9ca3047fbc71f27726dad8f7136e8a84fd8fbf3cedea57422a7cf9af5cb",
  "size": 295
}

changed /files/skills~1deep-security-scan~1SKILL.md/sha256

BEFORE
"d6aed0d9b47065a1384a96d0a45c843b0cda8ba48e3d2cbe96c65357c6e55ee3"
AFTER
"1d8328232b225b50526b2aaec54b253e4018956531ef22860c70789ae0410fe8"

changed /files/skills~1deep-security-scan~1SKILL.md/size

BEFORE
14096
AFTER
3127

changed /files/skills~1define-security-policy~1SKILL.md/sha256

BEFORE
"2817e1a03980a7ebea478c8d9e6c622e3c6205123e767a1e32f0204c06729cc7"
AFTER
"8a63f6af4570ed2e152155d1891f61948fa66678d354930e6e7922e568af866a"

changed /files/skills~1define-security-policy~1SKILL.md/size

BEFORE
6256
AFTER
5982

changed /files/skills~1finding-discovery~1SKILL.md/sha256

BEFORE
"14cc797e750ca4bdd8b060c4cf96d7d32f25b132aa8f80d0a0837683fe010790"
AFTER
"ca30309e330daddc0caf2dd6ff6529dbb67e83084cb3e6387029305ea194de99"

changed /files/skills~1finding-discovery~1SKILL.md/size

BEFORE
25598
AFTER
5076

changed /files/skills~1fix-finding~1SKILL.md/sha256

BEFORE
"ba7311f43b2c0742da0d5c6bdb2f0b26601c09cc59747cf8c62a09f8d0bb86d2"
AFTER
"5182ad87bd342a7785bb6ef1800abfe59af5d98662522f6fa43c53f4d7c5cf3e"

changed /files/skills~1fix-finding~1SKILL.md/size

BEFORE
9477
AFTER
18461

changed /files/skills~1propose-security-hardening~1SKILL.md/sha256

BEFORE
"ad07d88da7c2bc9e551849cdde686b0daad380ed0aac798e6c06444681d75959"
AFTER
"815d626877332e5178afedc2ef6ee267faa9d3b3ecfe411f09c7a16290406043"

changed /files/skills~1propose-security-hardening~1SKILL.md/size

BEFORE
22791
AFTER
5026

changed /files/skills~1propose-security-hardening~1references~1proposal-format.md/sha256

BEFORE
"72b93c32f1cbe7d25a3d347d0894e7b642942e68f2d8a3c0409bc398a41b06e7"
AFTER
"041df983ccb0e2923067c86e500fa22bbbe20c8d557ad36b71214e0811eb0ede"

changed /files/skills~1propose-security-hardening~1references~1proposal-format.md/size

BEFORE
25933
AFTER
4144

added /files/skills~1publish-findings~1SKILL.md

BEFORE
Field was absent
AFTER
{
  "sha256": "3e233cde046fea1161417e5757393fe40de9ff234762636ed559c608bae38d69",
  "size": 11118
}

added /files/skills~1publish-findings~1agents~1openai.yaml

BEFORE
Field was absent
AFTER
{
  "sha256": "d3c61dcec1b7d800bc2d12d0d2330c00535cb1685ecad2252838f8942ffc0a9c",
  "size": 284
}

added /files/skills~1publish-findings~1references~1checkmarx-import.md

BEFORE
Field was absent
AFTER
{
  "sha256": "9e1a1c131b1987011c3db37051fec9c817b9001190cf3cfa98698a3390f488e0",
  "size": 4888
}

added /files/skills~1publish-findings~1references~1wiz-import.md

BEFORE
Field was absent
AFTER
{
  "sha256": "81fd16f06d936d9f0720f9233eed782e5b67a4fe0a33ab7e402084dfe403dbf2",
  "size": 5153
}

added /files/skills~1publish-findings~1scripts~1collect_checkmarx.py

BEFORE
Field was absent
AFTER
{
  "sha256": "06d0638171f1b10ec3b2dc1fb810dd5935c2fcc73f300d3ad875ecd6b17b6892",
  "size": 17126
}

added /files/skills~1publish-findings~1scripts~1collector_paths.py

BEFORE
Field was absent
AFTER
{
  "sha256": "f74939f2435a62c85432028d16b404aa3d24f5bc33759b24b12682e1e2a428ed",
  "size": 2210
}

added /files/skills~1resolve-dependency-alert~1SKILL.md

BEFORE
Field was absent
AFTER
{
  "sha256": "2a0e0a68e7dba39cebb5a810a9d15d10282638c6ad2c1b2f5f8ce219d3e78f23",
  "size": 2548
}

added /files/skills~1resolve-dependency-alert~1agents~1openai.yaml

BEFORE
Field was absent
AFTER
{
  "sha256": "0e6d5ebea26253ea7113bbe6570ee308e7f1393872fbdf28b747b9ccc90272c1",
  "size": 250
}

changed /files/skills~1security-diff-scan~1SKILL.md/sha256

BEFORE
"f85962d46f141227d794a25253a39232bc4e1ad756509ecd3d8769b85b735136"
AFTER
"09232fd5d96cfed2a5bdccd176c09b7e9ca53ebd7ac136d283bec884fde94b0d"

changed /files/skills~1security-diff-scan~1SKILL.md/size

BEFORE
6102
AFTER
5405

changed /files/skills~1security-scan~1SKILL.md/sha256

BEFORE
"104e2f93fc965c34e91970f517a89e330d5b29dbb243dcea5d95d83f14d135cf"
AFTER
"1e678be7315aefe1c101baf6ef6c01c4002ea3e5297f029589244554c31fd78b"

changed /files/skills~1security-scan~1SKILL.md/size

BEFORE
9007
AFTER
2972

changed /files/skills~1security-scan~1agents~1openai.yaml/sha256

BEFORE
"5952ae0b0f7d378b7e6ab3fe793335a0e26e5d15bd2d7fdd14ecdd795607ceb6"
AFTER
"0790c2851c5b595ed376954f34a22c04f346a0a32fff6dfe1d30b3d2dee1b66a"

changed /files/skills~1security-scan~1agents~1openai.yaml/size

BEFORE
271
AFTER
245

changed /files/skills~1security-scan~1references~1desktop-scan.md/sha256

BEFORE
"62a3b3baac5773c36eb291c74c0304dd97157aff5b89dd56fa8b0fed08803389"
AFTER
"7e48dfbcd1d478bf0ca73de9d1a1a1d583face2d0755d7ba04d606e30b8aedfb"

changed /files/skills~1security-scan~1references~1desktop-scan.md/size

BEFORE
4747
AFTER
580

added /files/skills~1security-scan~1references~1managed-scan.md

BEFORE
Field was absent
AFTER
{
  "sha256": "b4680ddd79fab1d215c92696e1fbfb49db82ef0983f4d04680567f294bdd2c38",
  "size": 1356
}

changed /files/skills~1security-scan~1references~1scan-artifacts-and-ledger.md/sha256

BEFORE
"c95780a7af36fd42716f4c909bb57e68b438769b13f8d6f02ac06ffa73c838ff"
AFTER
"13678fd302742e5c728989912705765332e2b6ae5203562a9b549786f2819db9"

changed /files/skills~1security-scan~1references~1scan-artifacts-and-ledger.md/size

BEFORE
14716
AFTER
7021

added /files/skills~1security-scan~1references~1scan-results.md

BEFORE
Field was absent
AFTER
{
  "sha256": "ddc6b6d1041b45de338c0f50849ec3f003a57c46e202c95d5c52e4cf18d3c522",
  "size": 2871
}

added /files/skills~1security-scan~1references~1scoped-paths.md

BEFORE
Field was absent
AFTER
{
  "sha256": "0d4f77b51276fc1541397c9dd387464493fb9bb2d451ac2d580d1f3f35195bc5",
  "size": 2359
}

added /files/skills~1security-scan~1references~1sdk-files.md

BEFORE
Field was absent
AFTER
{
  "sha256": "5a6df47271bc1a9b4fd61024e3d389311be70f732759fb2439a32e5675fb05de",
  "size": 2192
}

added /files/skills~1threat-model-visualize~1SKILL.md

BEFORE
Field was absent
AFTER
{
  "sha256": "96e1a7517575ee419284d219f5a6e75d9a7825ae499480bd78b7393b544b106a",
  "size": 19102
}

added /files/skills~1threat-model-visualize~1agents~1openai.yaml

BEFORE
Field was absent
AFTER
{
  "sha256": "3b31472477c1e6f05e299df82b4a61d89b62f42ff8cec0c9394f53fa42e3cda7",
  "size": 259
}

added /files/skills~1threat-model-visualize~1assets~1context-reference-overview.svg

BEFORE
Field was absent
AFTER
{
  "sha256": "b5f01ae1842c96c54d7dfe74cc0f1cb5ab1a62a4f39395162031c048e1a9c4a5",
  "size": 36850
}

added /files/skills~1threat-model-visualize~1assets~1context-reference-path.svg

BEFORE
Field was absent
AFTER
{
  "sha256": "7f62d1bb0e054c44630e2a9e934ed2a6f3e15645360302b536818833c979ec00",
  "size": 60788
}

added /files/skills~1threat-model-visualize~1assets~1control-effects.js

BEFORE
Field was absent
AFTER
{
  "sha256": "667abbdc09dbe20428db6eda6d12c46d1b6630ed981bf6a7eefc4fb02c671763",
  "size": 4005
}

added /files/skills~1threat-model-visualize~1assets~1explorer.css

BEFORE
Field was absent
AFTER
{
  "sha256": "323849e45cbe90d0bc7efe62101c72dd21af775e493fb1e9e5a65eefcaaf4db0",
  "size": 12126
}

added /files/skills~1threat-model-visualize~1assets~1explorer.html

BEFORE
Field was absent
AFTER
{
  "sha256": "bb23f19f561b59b964ab00b314d1e15a768b70f6e879e57123e3ac6d0e3d4293",
  "size": 2673
}

added /files/skills~1threat-model-visualize~1assets~1explorer.js

BEFORE
Field was absent
AFTER
{
  "sha256": "117c772583d29a504137e5fefeb62bd996050175f3da5d40f214b471d072481f",
  "size": 42283
}

added /files/skills~1threat-model-visualize~1assets~1route-paths.js

BEFORE
Field was absent
AFTER
{
  "sha256": "54edff9691a35a118653fcf5e128f9402fb3cc602bf25c0875514dbf328a40ae",
  "size": 3648
}

added /files/skills~1threat-model-visualize~1assets~1source-roles.js

BEFORE
Field was absent
AFTER
{
  "sha256": "a304027486857462974783c12d6bfd8f09dadc7cabd2e7ed0e8fe2b7862c1ece",
  "size": 2762
}

added /files/skills~1threat-model-visualize~1assets~1svg-layout.js

BEFORE
Field was absent
AFTER
{
  "sha256": "9404259952ae08a80e4877b1ac28781d453974c0d1828fb46bbec172c50f42cf",
  "size": 11530
}

added /files/skills~1threat-model-visualize~1references~1context-explorer.md

BEFORE
Field was absent
AFTER
{
  "sha256": "2ec94ffc33589100cead235eacdb6ce80596272c12285532ae4a682b064fbed9",
  "size": 5636
}

added /files/skills~1threat-model-visualize~1references~1view-model.md

BEFORE
Field was absent
AFTER
{
  "sha256": "05c81e732bca0b64b182329e68d47900d18da5b3c22354b11f2a0183d890b019",
  "size": 12062
}

added /files/skills~1threat-model-visualize~1scripts~1build_explorer.py

BEFORE
Field was absent
AFTER
{
  "sha256": "d2036f1d8783b6d3b5a7673412b80ba6f9d2e63112f8fd8802fee1395964c90f",
  "size": 27557
}

changed /files/skills~1threat-model~1SKILL.md/sha256

BEFORE
"42568e50c787c4c0bfb9495ad67e72ab6c1a951bb910ecba2c67cff8961c4d56"
AFTER
"79a1b6282f80804227a28f9a1fae71bbfcd6928c1de5d2c84ab0ebf9c1f49226"

changed /files/skills~1threat-model~1SKILL.md/size

BEFORE
3606
AFTER
2986

changed /files/skills~1track-findings~1SKILL.md/sha256

BEFORE
"a6d2f30e6d5ca7bd9d74d83017f2f5481c5829585941208a1673b82c683d292b"
AFTER
"ef1cbf5e8b0240a78f32903540f6c1b500cd329c00bfcefc405fec1e382c46e9"

changed /files/skills~1track-findings~1SKILL.md/size

BEFORE
11371
AFTER
13459

changed /files/skills~1track-findings~1references~1github-security-advisories.md/sha256

BEFORE
"5e583aa2f77db32e4983b8b4bb857b1c7eaebfa1f43fc833b551c96acab70d4e"
AFTER
"1d0a4e10e837834e00f1c041a3aa972f176529385c5161e55821adb9d1f3cdf4"

changed /files/skills~1track-findings~1references~1github-security-advisories.md/size

BEFORE
3288
AFTER
3420

changed /files/skills~1triage-finding~1SKILL.md/sha256

BEFORE
"83081950bd4b29ff37cf82d137aec164532ae56b03dbaad3f4dd1d5423e758a7"
AFTER
"2c71d6a89ef0c61ed2f5f1f6af9d05de43e38547eec777937774fd1054b0afaa"

changed /files/skills~1triage-finding~1SKILL.md/size

BEFORE
10004
AFTER
8394

changed /files/skills~1triage-finding~1references~1github-rest-intake.md/sha256

BEFORE
"f026bef041ca92f3d9b47a131794aa54e98cf8d7716fae3f71ab53e8ab09c79f"
AFTER
"3ff78c08946b3731d2672c08817ad654724df8573ae8bc1d7560c2850e17a832"

changed /files/skills~1triage-finding~1references~1github-rest-intake.md/size

BEFORE
9314
AFTER
12277

changed /files/skills~1triage-finding~1references~1ticket-intake.md/sha256

BEFORE
"693b415fdfcdcf8e6d5539677ff89c79bb36995ae22916d87866ce2c25113439"
AFTER
"b8044c6d2e15c4372fa08f6fd6946be02ce9444f1f1be4416f2e435466c73bff"

changed /files/skills~1triage-finding~1references~1ticket-intake.md/size

BEFORE
3645
AFTER
5231

changed /files/skills~1validation~1SKILL.md/sha256

BEFORE
"3c4660f79b12a92728e6bb25027064c3a911d0960d39aeafc8fda9e42ce517a5"
AFTER
"aac2d8598af99fc27c163c24204b264427100b89f15e203822b108262fcb7876"

changed /files/skills~1validation~1SKILL.md/size

BEFORE
12845
AFTER
4619

changed /files/skills~1validation~1references~1validation-guidance.md/sha256

BEFORE
"42f7a9d85b78d0deb5e6eda82b8c59ed101c40d36065833b9cf39fe50699e255"
AFTER
"48439b292c9e92195ef9905062b1c948df7202ddc1a99aa9192c71e54c46d6ab"

changed /files/skills~1validation~1references~1validation-guidance.md/size

BEFORE
26823
AFTER
4408

changed /files/skills~1verify-fix~1SKILL.md/sha256

BEFORE
"3d4530484c7e4c18b6afe7c6527247e96517dce1ebd1bda9d349cd367ecb0ae3"
AFTER
"3569c165dffeae015ede1ab1c0dbfd03164673f5b6a54c263b4941ed9a9703a5"

changed /files/skills~1verify-fix~1SKILL.md/size

BEFORE
3025
AFTER
4193

changed /files/skills~1vulnerability-writeup~1SKILL.md/sha256

BEFORE
"d08582d9963ce3bfbc3fe81b6e85a01e6fe306713d7951bfd8dd2fbc3df75de4"
AFTER
"9c15d78cca5b847e270740daa405276e9e8ba5fcbfeeeb5b2a68d7752b1bda99"

changed /files/skills~1vulnerability-writeup~1SKILL.md/size

BEFORE
27640
AFTER
5571

changed /files/skills~1vulnerability-writeup~1references~1report-format.md/sha256

BEFORE
"60568466f7057562d7359dc3a396632c760c147582603896d7e569a77487d0b1"
AFTER
"68a1b4a293f0379ba5ae2c21a32d6618245f6de1b6dd977c5a2cf9d62a25c874"

changed /files/skills~1vulnerability-writeup~1references~1report-format.md/size

BEFORE
14682
AFTER
4482
Full snapshot data
{
  "files": {
    ".app.json": {
      "sha256": "a7bbe314059c7311e169474823e3978f267e560c3e961ba49fb94032da9843fe",
      "size": 479
    },
    ".codex-plugin/plugin.json": {
      "sha256": "3766646eafb09a5e691657999f4f423c9652bbac286c0e0f55e179169aa97e99",
      "size": 1846
    },
    ".mcp.json": {
      "sha256": "69bbc0f86c92397eb7540ff09c17d69d429b0dc45dc1de3e02b16d101adfe7c0",
      "size": 2078
    },
    "OWNERS": {
      "sha256": "49be76d15302e4f158b3ef907e9802a955ab9c0a59a039827eab4cb6221f0e5f",
      "size": 41
    },
    "assets/logo.png": {
      "sha256": "9b9c2b09b2fa064611fb62307d321d5c2ea70cf0789f7ce34cdb0fc0d9190b3a",
      "size": 99567
    },
    "examples/completed-scan/findings.json": {
      "sha256": "3c63586ea38b07b1d5ad9004ba2afc27f67e79ed164da508c7beae72648eb3b7",
      "size": 2678
    },
    "examples/completed-scan/report.md": {
      "sha256": "fe1ef26b96b22a519f3a1367cade27d466a7ced669cf8e2ddb0b2adb3e9246dc",
      "size": 2910
    },
    "examples/completed-scan/scan-manifest.json": {
      "sha256": "85d7e8ce925bfc49cab180ab87e24f156b9c470fada7511ddc70ce4390dfaae6",
      "size": 1227
    },
    "examples/legacy-completed-scan/coverage.json": {
      "sha256": "d55b9b98d48323b4659dfee6531ec83ec538f2084325412b7188bf85ad68b01b",
      "size": 467
    },
    "examples/legacy-completed-scan/findings.json": {
      "sha256": "a6dc4521d6478828224fbafc33585401a47bfeb0e56e07b5d2886e8a29937f2f",
      "size": 1844
    },
    "examples/legacy-completed-scan/report.md": {
      "sha256": "062030ba6d342c615aaed926775813b1c3a69bb503e3fa621298fe30914520df",
      "size": 4158
    },
    "examples/legacy-completed-scan/scan-manifest.json": {
      "sha256": "d245ae9fc62a676293c6821e562d1a2d7d59db12d5b8dc99b85f7c5f1462fe00",
      "size": 1245
    },
    "mcp/fzstd-LICENSE.txt": {
      "sha256": "62249119bb7df6e54300f37a37145c26a6d4420410aac8881a119c5b427cf751",
      "size": 1069
    },
    "mcp/helpers.mjs": {
      "sha256": "1cf4f6bfaa9462c467a61f743ca9cd65f0a61fedf8839dc4f78f1179774673ba",
      "size": 766
    },
    "mcp/helpers.mjs.br": {
      "sha256": "b26250268c324738d87354096135f9df52405eea495c89f96aedf2b1d879753c",
      "size": 160967
    },
    "mcp/native/COPYRIGHT-library.html": {
      "sha256": "0a65bb747c49c7bb816cbc7188319bd6e4e8d08091c1190b8a3c0971c47968ed",
      "size": 279302
    },
    "mcp/native/THIRD_PARTY_NOTICES.txt": {
      "sha256": "32c4db438d7141ea680b20b3d7e6093e548012ca482a6399176cf20985a3a55f",
      "size": 286866
    },
    "mcp/native/darwin-arm64/unix.node": {
      "sha256": "0fc69686798e3f71f02a7f9d802e39f7c44f6a9bc1a5e3ea863960afaba13c23",
      "size": 421776
    },
    "mcp/native/darwin-x64/unix.node": {
      "sha256": "8ca00589f8f565d286ed5eeb6fbaa33acfe993fbd3a3e2c0ac552cc1a2100e48",
      "size": 430688
    },
    "mcp/native/licenses/Apache-2.0.txt": {
      "sha256": "074e6e32c86a4c0ef8b3ed25b721ca23aca83df277cd88106ef7177c354615ff",
      "size": 10280
    },
    "mcp/native/licenses/BSD-2-Clause.txt": {
      "sha256": "f32fb3b417a194167cfad068223fc975ba96c5960513a10f66a3c28720aec1df",
      "size": 1267
    },
    "mcp/native/licenses/MIT.txt": {
      "sha256": "b85dcd3e453d05982552c52b5fc9e0bdd6d23c6f8e844b984a88af32570b0cc0",
      "size": 1078
    },
    "mcp/native/licenses/Unicode-3.0.txt": {
      "sha256": "f5062c9a188d81dfe66b56db4182dcf9e4b17c0d9b0d311a8e20b3a1b075c443",
      "size": 1995
    },
    "mcp/native/linux-arm64-gnu/unix.node": {
      "sha256": "dd83a0bd82214da9da00583fdab234bebfd86e20c7e352c5b93d9e93603ab932",
      "size": 531752
    },
    "mcp/native/linux-arm64-musl/unix.node": {
      "sha256": "998b604f3f32c40e119e122e16d9d3f91e201d6066fb7a0369f6d273c8ff556a",
      "size": 463536
    },
    "mcp/native/linux-x64-gnu/unix.node": {
      "sha256": "7b447ad208c2c52182843ac1042f13da86cbbcb932bb48e07812cb8bdb8dac5e",
      "size": 458464
    },
    "mcp/native/linux-x64-musl/unix.node": {
      "sha256": "c2bbb330743b264052ec677b60b3d0bc7e6356eb64116cf19fd0f00b2400e4fb",
      "size": 459432
    },
    "mcp/native/win32-arm64/windows.node": {
      "sha256": "0856b9c435fd5407bec2fce4c3d536f14e27f2bb298eb80b267f4260577635d1",
      "size": 571904
    },
    "mcp/native/win32-x64/windows.node": {
      "sha256": "b3cfc53a2efe0da8581ffe8a13203b4a1921bc0f11f2b3ea52e5962a72a0951b",
      "size": 623104
    },
    "mcp/package.json": {
      "sha256": "5bbbec757633dcbc268e91dd63a59bd3c09b9626ea5cedd3b6656379ed0cb643",
      "size": 17
    },
    "mcp/permission-profile-preflight.mjs": {
      "sha256": "cacb1f399a1e53a732ff09a33babf886d8691e1eb2762adbbaf57ee6c5bde84f",
      "size": 24633
    },
    "mcp/server.mjs": {
      "sha256": "acb2bdf8446b3116d48dc075a64613d92805a690a178277f612e5082cf1f2687",
      "size": 765
    },
    "mcp/server.mjs.br": {
      "sha256": "456bf45d8653a176a5ee28a6923766488e75f05546738ac6d0f32af3e4fc27ab",
      "size": 339502
    },
    "mcp/session-decompression.mjs": {
      "sha256": "bacebc26fe0d726622d2af9b9007b27bd0b717662098b29c6b2130ca901d2d21",
      "size": 17439
    },
    "references/access-advisory.md": {
      "sha256": "7f4bf0905d60e35a70e0bbfe27d5578f8af4777afc46a92f33cb43f4250fe68c",
      "size": 1448
    },
    "references/artifact-storage.md": {
      "sha256": "e8c173d1e89ec7b930953bf04220905a6ab35c3798c8e66799ded3b06c1a87d2",
      "size": 7947
    },
    "references/baseline-auditor.md": {
      "sha256": "717ad7cdcda32fe212e7f930ea5c1cb301eae005833490808dce35d49314a74b",
      "size": 2839
    },
    "references/core-scan.md": {
      "sha256": "6954c9a971611b79dcf03b4c62991e70cfd437fe249627249af6dc2709517868",
      "size": 7479
    },
    "references/default-severity-rubric.md": {
      "sha256": "b718f8314712b307690d31d9c6f533c113ad1754f725b8d37856b6dc58a42043",
      "size": 3348
    },
    "references/final-report.md": {
      "sha256": "f742994e8c9109cf6072c578104f75a7353bd562614ee7288a30105c53717c89",
      "size": 12135
    },
    "references/finding-detail-fields.md": {
      "sha256": "6580ca83b7a9208dfa23f0e3626b5ce957b331c6c861815005720a3a2370752f",
      "size": 10874
    },
    "references/focused-investigator.md": {
      "sha256": "5624cca98860204c50ac3f281486594b690a04a4979144fd608769a50aadfc18",
      "size": 2548
    },
    "references/investigation-time-budget.md": {
      "sha256": "3216d053bd2e4ede72d3a64ef38974d293dfb54a000a40782d73357070b0f1e9",
      "size": 1749
    },
    "references/sarif-adapter.md": {
      "sha256": "76c69bd20b0e4fca20daeaad5e5dd89ad742a210afb7dce6331eec3defc7cb3e",
      "size": 2829
    },
    "references/scan-artifacts.md": {
      "sha256": "30a83f78ed066b1b4cfec3486b9f87952fb3c188fe16d16f654e025c6d3737e6",
      "size": 11701
    },
    "references/scan-contract.md": {
      "sha256": "ba4e01a4c3c753f41d1ffd69d6bb10c51fb12b9a6a8904c42e6e66e3fbe2a13c",
      "size": 16529
    },
    "references/scan-prologue.md": {
      "sha256": "87f0e966103ab5dd608611854370599a8fd2aa7ff91fe342b52f777352449c73",
      "size": 5747
    },
    "references/scan-runtime.md": {
      "sha256": "5ebe088747c8458b768609d058c7a53305e1b78af660e5a1f328baead1ef5686",
      "size": 1558
    },
    "references/security-guidance.md": {
      "sha256": "f52e88c85634c0a3b254f9a0f2ed0aa6652c63c34453bd0a87a73c20c990459f",
      "size": 2830
    },
    "references/standalone-validation.md": {
      "sha256": "a2357b01e308bea046a4cfa65a7734f2b7e2e2d84ef72dcb9efade68ff76f5b3",
      "size": 2134
    },
    "references/static-finding-assessment.md": {
      "sha256": "78de933caef1c8d971dab83fbb71877602a1197a52eaa7a59d6ff7bc399d0bc7",
      "size": 3949
    },
    "references/threat-model.md": {
      "sha256": "5cd54326b7b7801b28e1480d76e19bfeda7ff30129d911359c9d5fa31c9b0b45",
      "size": 7751
    },
    "references/validate-scan-findings.md": {
      "sha256": "32ed68556c537f479b0fc09aa78e184d75ddc13cac9b9bec1d9297fe06b92737",
      "size": 1131
    },
    "schemas/coverage.schema.json": {
      "sha256": "3629bdde34e73e13be85d54c81487805677560c6d7c9077a50444715afcf188d",
      "size": 3893
    },
    "schemas/definitions/artifact-common.schema.json": {
      "sha256": "73f7137f00e61e714e2903e427daabeb71d646310005f90b582fa468fac53aae",
      "size": 870
    },
    "schemas/definitions/discovery-candidate.schema.json": {
      "sha256": "1fc379a8c79c57d9889a7a3d278f4f3e31fd8337dd0aa0a59ff171ecf817624d",
      "size": 4203
    },
    "schemas/findings.schema.json": {
      "sha256": "c53067bf1f17b88de5b555ed4d074f7d17975294345b40f16c7a9f91019c9f67",
      "size": 10591
    },
    "schemas/patch-risk-assessment.schema.json": {
      "sha256": "f36759528740edd9c6c86e76b034cf59a3c6796b143f2ed0d8bbfd011f02811d",
      "size": 6858
    },
    "schemas/scan-manifest.schema.json": {
      "sha256": "4bac4a5b898ebe72d9bf1128f3a8530979159b3c3bfe2c37ccd3c651f47ce234",
      "size": 7815
    },
    "schemas/tools/candidate-attack-paths.schema.json": {
      "sha256": "0550e20a4b51f5d7d0edc71f98a31441c92df55b5f36eb366b39b2e878ae9a0c",
      "size": 6810
    },
    "schemas/tools/candidate-validations.schema.json": {
      "sha256": "e89cd513a320d376b6366ea1f1365b62415c7a1355778c285103b34f23733f48",
      "size": 4519
    },
    "schemas/tools/discovery-candidates.schema.json": {
      "sha256": "5ebffa84b6a60e6e15c2eecb08f05353af2a239f6f463883efe954b482997d7c",
      "size": 1152
    },
    "schemas/tools/review-items.schema.json": {
      "sha256": "f7c4522e9e6faf736347b40a42a0839df5fe6818ad1cfd377ef1d452a233a87b",
      "size": 1431
    },
    "schemas/tools/scan-draft.schema.json": {
      "sha256": "fc3cdd65c39a22d6fc110076696a43fbf67226044e989a1047682473521973d4",
      "size": 28295
    },
    "scripts/check_deep_scan_target.py": {
      "sha256": "165230b549343af0ad28cc5397459441506e2dfc4978ba00d717f9eb964a34c5",
      "size": 3538
    },
    "scripts/codex_profile.mjs": {
      "sha256": "f739efe073f5243556d2073fdf10ecf4be1305878e3334d7ce8642ed1a885311",
      "size": 8621
    },
    "scripts/codex_session.mjs": {
      "sha256": "11685e239918a11fd811b36a9259b800013d3e914ee4e33c20ce024e52eeed12",
      "size": 1730
    },
    "scripts/deep_scan_config.py": {
      "sha256": "f9e384daa017afa553ef4fb99fdff5cbec93cb22bfd76b722d962bf32534f49d",
      "size": 6510
    },
    "scripts/deep_scan_defaults.json": {
      "sha256": "89bdb96ff721f0f1d509f3c5c83f5fc89022f14406d0a84df781b7e0e42cde66",
      "size": 143
    },
    "scripts/deep_scan_workbench.py": {
      "sha256": "d5f65879341d97d18f531fae0ce197e11207761add9787c2c0031f2980dca6d9",
      "size": 78126
    },
    "scripts/dispatch_inventory_tool": {
      "sha256": "eff576e0e584cc093dcf2bd18ea6c64bc33eb1c448d8558ef557f7373d962a83",
      "size": 238
    },
    "scripts/filesystem_identity.py": {
      "sha256": "b9d0b916c1b8a1fbc3a7c1e6692af2d0ef19f36a36d1d66d0a9a4190112c9387",
      "size": 991
    },
    "scripts/finalize_scan_contract.py": {
      "sha256": "339d9f2068634e65147373fe87b4a88c44d4f17d3e36fa06c0fcb3e97b66f8da",
      "size": 147094
    },
    "scripts/finding_preview.py": {
      "sha256": "4d93ed0170cbf4f4d37b3ff202eb313ea71a19b89b5953d40c1ac05d1c7c2e90",
      "size": 16692
    },
    "scripts/launch_codex_security_mcp": {
      "sha256": "497680a7ecc2163da04338d2f7ec26549362b0f098b810ed57ee64c56dea3665",
      "size": 4646
    },
    "scripts/launch_codex_security_mcp.cmd": {
      "sha256": "7859298f6ebdb8d58f58d163bfe2fc9023e5f1b6f336f10180269f05bdec602f",
      "size": 2667
    },
    "scripts/legacy_findings.py": {
      "sha256": "bb1209b9963a1698c51ba29b3047fbf3cf31fb0f1e98e4c118ecedde3ee673be",
      "size": 6125
    },
    "scripts/posix_scan_local_files.py": {
      "sha256": "0911b75dc67fdc04d0284fb97977063fe88ab3dfc2ec79becc426ff55483dfd7",
      "size": 8949
    },
    "scripts/read_codex_session.mjs": {
      "sha256": "09b47a949ae78879adc49afab1cc4ba29a450e333838ab20da429883448e752d",
      "size": 816
    },
    "scripts/report_projection.py": {
      "sha256": "6e950c378fece395b7cb648425a814ae6a45211abade77b96ddeca1e743f65e5",
      "size": 41680
    },
    "scripts/reserved_artifact_paths.json": {
      "sha256": "58ba1cf42437ac3af65c85a66eeff46f22572e45081fa2620f4b241173efcc50",
      "size": 186
    },
    "scripts/review_state.py": {
      "sha256": "567f0cef32dff8fab7fba364ad75fd42f303b5efbf85bf4a457024cd3c2342e0",
      "size": 2661
    },
    "scripts/servicenow_avit.py": {
      "sha256": "f852c39d2d10adfd7d38e2aef492ccf425f56162b3f618ffd9b21a06072c7e3f",
      "size": 4625
    },
    "scripts/snapshot_sqlite.py": {
      "sha256": "9f3c4835730e2e766c3b082242594bd773a3cae2cc76aa9be47a7faab96c3947",
      "size": 1738
    },
    "scripts/threat_model_projection.py": {
      "sha256": "e87dddf2bca93b4bd066c8c631e981ed14c770ee4fd33be8f5523f29cf6abf1a",
      "size": 6687
    },
    "scripts/validate_scan_contract.py": {
      "sha256": "a8b10d0bc03dc1b2cf040f121f65d8896e0c8f6bd4fdb7339d679234cb5ba08e",
      "size": 3224
    },
    "scripts/windows_scan_local_files.py": {
      "sha256": "9ab01a477f944f0ce4d3f7ef8646d477b40dc6b775b5b615b464fcf461beaee7",
      "size": 60676
    },
    "scripts/workbench/__init__.py": {
      "sha256": "b33e759162aeda0e8489f518bbc13b991f8c3a2ef5270cfb381177f838d321ac",
      "size": 98
    },
    "scripts/workbench/handoff.py": {
      "sha256": "af4eb66124ea1d66b8625ab54c6e846a6d7375d242c5509fa0bf8ef75c202fe0",
      "size": 11403
    },
    "scripts/workbench/retained_coverage.py": {
      "sha256": "f6dec9dbd0197d1d4593086bbb9ebe36ea39d4891d101df0a584dad55aaa6a72",
      "size": 148411
    },
    "scripts/workbench/retained_records.py": {
      "sha256": "98d1996f869bd0071510bc3c9dffadd7cf3e6d33c960e7c6f8ea090ba69b93ac",
      "size": 24885
    },
    "scripts/workbench/runtime_toml.py": {
      "sha256": "119fe79d8ecf4feedd5f17be578b9a84b3c2b450b36fed058b5aa2cb64c750e8",
      "size": 802
    },
    "scripts/workbench/saved_coverage.py": {
      "sha256": "8884d54caaed1f8f3fa0b4a7ac128eb17535a03445cdbfabeec49731f6f076cf",
      "size": 35410
    },
    "scripts/workbench/saved_outputs.py": {
      "sha256": "f845413ad0a16542d8d3728dc0ca1231c450c7898d4770a11bd3d319c61c8fd2",
      "size": 2921
    },
    "scripts/workbench/saved_sources.py": {
      "sha256": "53859519948b55e74bbdb26d44d355e63ce8705f0db8dd117cc25d52beb5a977",
      "size": 30156
    },
    "scripts/workbench/storage.py": {
      "sha256": "4791845b4a6b6e3437a5403e984ea2e97bc2758be052719b51aa3b353ce01d85",
      "size": 4390
    },
    "scripts/workbench_cli.py": {
      "sha256": "79bb508b068f73b8f5444c5af82ff58e26562f08eaa9cd9aec368766970deb8f",
      "size": 21516
    },
    "scripts/workbench_constants.py": {
      "sha256": "8cc007a47d6f687ea2860896adff1e51eb98ae6e1811b370c53e36f37fe9dde3",
      "size": 3177
    },
    "scripts/workbench_coverage_receipts.py": {
      "sha256": "ab88ee90de1ff4607f9599607f76f0c619d4d5067b52a84d745b4c896703ee5a",
      "size": 21284
    },
    "scripts/workbench_db.py": {
      "sha256": "95e263bca1c718e444ddd2afe43d661264014192b4cf8cfbc157391b42920a27",
      "size": 149908
    },
    "scripts/workbench_feedback.py": {
      "sha256": "92ab94e29eb654a5077a2532140750d9cbe2a5ac2967cfc206e4e026eb550564",
      "size": 6259
    },
    "scripts/workbench_finding_index.py": {
      "sha256": "dcf3482bb31f3248a84a7b9e7aa69b331fe4c50d28e501db6a10fe97ade17d3c",
      "size": 4745
    },
    "scripts/workbench_finding_workflows.py": {
      "sha256": "2d3914e553d5e5bf710a8d27bd25f878a023449270b2045db97a9752c1f7ba51",
      "size": 15010
    },
    "scripts/workbench_native_indexes.py": {
      "sha256": "a40b4cfae313b6799541f70dc251508ce9d9a474a2298742c23a823d7819139d",
      "size": 18571
    },
    "scripts/workbench_progress.py": {
      "sha256": "85fedf2b9f3095a5abb30b55f5b4a56acc0d8bdc7f2a16268123aa0d855773e2",
      "size": 16640
    },
    "scripts/workbench_publication.py": {
      "sha256": "90834075ed64ec43a30f2f15fe265baa730ce4a473101ca4b0a420a5fef4948b",
      "size": 20245
    },
    "scripts/workbench_remediation.py": {
      "sha256": "8e3a6e766edb0649d913af24562e8cdbe29455f742adfdb3f1c31536df5d814b",
      "size": 35923
    },
    "scripts/workbench_saved_results.py": {
      "sha256": "f0a4ac2411dd12dccce1c911e3bff5a60054a66c5d3706090661e4b1cc1bc8ea",
      "size": 71471
    },
    "scripts/workbench_scan_history.py": {
      "sha256": "375425ddd2afcaff361905a6c2d9882e99453ece79aa75068d5c6121cd3aa81a",
      "size": 60835
    },
    "scripts/workbench_scan_start.py": {
      "sha256": "1ee02b3ff745b0926330c993757448be7b813067642abbdf024352b32ad1fd6e",
      "size": 19611
    },
    "scripts/workbench_scan_usage.py": {
      "sha256": "eea597036388f90977d358ea4f66801aad2138c304f6ff7d573f35f3495148aa",
      "size": 65712
    },
    "scripts/workbench_schema.py": {
      "sha256": "08d7451b45ac74c211ad1be360854f12719cb02e876ca9ed03274c9e1315044c",
      "size": 18275
    },
    "scripts/workbench_setup.py": {
      "sha256": "90a18fddfd853c8a305d8191ec098693a53dee30e6a087e092ebbdeb54fd472c",
      "size": 9683
    },
    "scripts/workbench_source_excerpt.py": {
      "sha256": "97667580f629597a284939ff60e137af3526e217165a7946de2420f19ea489d7",
      "size": 5200
    },
    "scripts/workbench_source_scopes.py": {
      "sha256": "2ecd66dc35c390cecbacbb8c92a444e3f2d5ce49284581fcea036a0c11450529",
      "size": 15576
    },
    "scripts/workbench_target.py": {
      "sha256": "ccefc18e546174426276f99f9ea09e1f55eaa533a77e652185391bf1bffa3a1c",
      "size": 71863
    },
    "scripts/workbench_target_state.py": {
      "sha256": "5471646ac8fe3f62d358c49ee2c0f0833ae14f57affe4bb9cea855158d0d6d1c",
      "size": 44552
    },
    "scripts/workbench_validation.py": {
      "sha256": "06746a3aae15e85cd5c1671bf4da16f000cc2ad1cb19bbea9e63e00fa524e2ea",
      "size": 10189
    },
    "shared/workbench-history-repairs.json": {
      "sha256": "9ce97bb58f0803c9bf67b0bc11a56d015a0444b08fbf7f2ee3bb51ab5f87b755",
      "size": 16081
    },
    "shared/workbench-migrations.json": {
      "sha256": "ac63f2f69d36428a5fea82ac4bc522b7f98b8e825f7f9bf35d3aae009c89258f",
      "size": 47324
    },
    "skills/assess-patch-risk/SKILL.md": {
      "sha256": "5e115b0ba2f346e52efd2033a191da4aa40f1ff3f7b1ff5e2bde586e48eabf0d",
      "size": 8299
    },
    "skills/assess-patch-risk/agents/openai.yaml": {
      "sha256": "fec61f321e18022579cac25ffb33286f48cc316172a0b8d502f2bf4faecba025",
      "size": 274
    },
    "skills/assess-patch-risk/references/risk-rubric.md": {
      "sha256": "078a71175191580791685808980cb1815dc97265cfee8c0ddad1f4d3b8203b4a",
      "size": 5049
    },
    "skills/assess-patch-risk/references/windows-validation.md": {
      "sha256": "9a7d12e493497b2aa7135493e3d23ec35da05f687f6513266a5c45ffb67dad94",
      "size": 1173
    },
    "skills/attack-path-analysis/SKILL.md": {
      "sha256": "cacb4a0dc7676db7346b8295e555cb515092528cdd6b07a1ebb7c22790241eed",
      "size": 5355
    },
    "skills/attack-path-analysis/agents/openai.yaml": {
      "sha256": "d9355cbcf0bc81098c9e837d9d4e8644e598410d052a862ab11cf91ef9ccb633",
      "size": 261
    },
    "skills/attack-path-analysis/references/attack-path-facts.md": {
      "sha256": "1979ea81991ba1c095c1846d4b8e09429edc6295912f87a6ebb7fa7e32651a1e",
      "size": 1585
    },
    "skills/attack-path-analysis/references/severity-policy.md": {
      "sha256": "8b715db602fc58ea48a6e96d9a69648ddd835c2c39a2fe962c0958d0a2594008",
      "size": 2644
    },
    "skills/check-skills/SKILL.md": {
      "sha256": "790204df7e162d44b4ea509bb67aaa1b61ffb1f602f6f01cad0ae89e085c16fb",
      "size": 5844
    },
    "skills/check-skills/agents/openai.yaml": {
      "sha256": "d0a8f882b30deec19f1dfdcae61b191f8a312bee3ddccc6b9536d7daf32e4862",
      "size": 272
    },
    "skills/cloud-findings/SKILL.md": {
      "sha256": "a534ce50f358a1076b4d4c186a22675a0d23f6dd97564009ea66a08813497e64",
      "size": 10563
    },
    "skills/cloud-findings/agents/openai.yaml": {
      "sha256": "37c9d9ca3047fbc71f27726dad8f7136e8a84fd8fbf3cedea57422a7cf9af5cb",
      "size": 295
    },
    "skills/deep-security-scan/SKILL.md": {
      "sha256": "1d8328232b225b50526b2aaec54b253e4018956531ef22860c70789ae0410fe8",
      "size": 3127
    },
    "skills/deep-security-scan/agents/openai.yaml": {
      "sha256": "3f8d781bf372b0d053a017eabaebf947d5d48d9be2b82cb67da211128924c3f1",
      "size": 192
    },
    "skills/define-security-policy/SKILL.md": {
      "sha256": "8a63f6af4570ed2e152155d1891f61948fa66678d354930e6e7922e568af866a",
      "size": 5982
    },
    "skills/define-security-policy/agents/openai.yaml": {
      "sha256": "8c40b0f8bd1eb7feabdcea69f12c2a7d18e492e96893c0702507ffd808b8e2b4",
      "size": 210
    },
    "skills/finding-discovery/SKILL.md": {
      "sha256": "ca30309e330daddc0caf2dd6ff6529dbb67e83084cb3e6387029305ea194de99",
      "size": 5076
    },
    "skills/finding-discovery/agents/openai.yaml": {
      "sha256": "c044dd83a7624b90ed19f11adc899202685ce64e32502f1d46225f69f9a2c962",
      "size": 220
    },
    "skills/fix-finding/SKILL.md": {
      "sha256": "5182ad87bd342a7785bb6ef1800abfe59af5d98662522f6fa43c53f4d7c5cf3e",
      "size": 18461
    },
    "skills/fix-finding/agents/openai.yaml": {
      "sha256": "5dac397bf3a17e45283691b656179eb56d19e34881af380f098d7c455bce52d7",
      "size": 225
    },
    "skills/propose-security-hardening/SKILL.md": {
      "sha256": "815d626877332e5178afedc2ef6ee267faa9d3b3ecfe411f09c7a16290406043",
      "size": 5026
    },
    "skills/propose-security-hardening/agents/openai.yaml": {
      "sha256": "1bcab19d48eb4b768c0dc435bd2e738f1471c2345cce5865bb31bdca5be0b134",
      "size": 293
    },
    "skills/propose-security-hardening/references/proposal-format.md": {
      "sha256": "041df983ccb0e2923067c86e500fa22bbbe20c8d557ad36b71214e0811eb0ede",
      "size": 4144
    },
    "skills/publish-findings/SKILL.md": {
      "sha256": "3e233cde046fea1161417e5757393fe40de9ff234762636ed559c608bae38d69",
      "size": 11118
    },
    "skills/publish-findings/agents/openai.yaml": {
      "sha256": "d3c61dcec1b7d800bc2d12d0d2330c00535cb1685ecad2252838f8942ffc0a9c",
      "size": 284
    },
    "skills/publish-findings/references/checkmarx-import.md": {
      "sha256": "9e1a1c131b1987011c3db37051fec9c817b9001190cf3cfa98698a3390f488e0",
      "size": 4888
    },
    "skills/publish-findings/references/wiz-import.md": {
      "sha256": "81fd16f06d936d9f0720f9233eed782e5b67a4fe0a33ab7e402084dfe403dbf2",
      "size": 5153
    },
    "skills/publish-findings/scripts/collect_checkmarx.py": {
      "sha256": "06d0638171f1b10ec3b2dc1fb810dd5935c2fcc73f300d3ad875ecd6b17b6892",
      "size": 17126
    },
    "skills/publish-findings/scripts/collector_paths.py": {
      "sha256": "f74939f2435a62c85432028d16b404aa3d24f5bc33759b24b12682e1e2a428ed",
      "size": 2210
    },
    "skills/resolve-dependency-alert/SKILL.md": {
      "sha256": "2a0e0a68e7dba39cebb5a810a9d15d10282638c6ad2c1b2f5f8ce219d3e78f23",
      "size": 2548
    },
    "skills/resolve-dependency-alert/agents/openai.yaml": {
      "sha256": "0e6d5ebea26253ea7113bbe6570ee308e7f1393872fbdf28b747b9ccc90272c1",
      "size": 250
    },
    "skills/security-diff-scan/SKILL.md": {
      "sha256": "09232fd5d96cfed2a5bdccd176c09b7e9ca53ebd7ac136d283bec884fde94b0d",
      "size": 5405
    },
    "skills/security-diff-scan/agents/openai.yaml": {
      "sha256": "f3d31e09befbb8532b53fdccb63a34c0b894a7fb96215b40e84647cd9f8e1b50",
      "size": 284
    },
    "skills/security-scan/SKILL.md": {
      "sha256": "1e678be7315aefe1c101baf6ef6c01c4002ea3e5297f029589244554c31fd78b",
      "size": 2972
    },
    "skills/security-scan/agents/openai.yaml": {
      "sha256": "0790c2851c5b595ed376954f34a22c04f346a0a32fff6dfe1d30b3d2dee1b66a",
      "size": 245
    },
    "skills/security-scan/references/desktop-scan.md": {
      "sha256": "7e48dfbcd1d478bf0ca73de9d1a1a1d583face2d0755d7ba04d606e30b8aedfb",
      "size": 580
    },
    "skills/security-scan/references/managed-scan.md": {
      "sha256": "b4680ddd79fab1d215c92696e1fbfb49db82ef0983f4d04680567f294bdd2c38",
      "size": 1356
    },
    "skills/security-scan/references/scan-artifacts-and-ledger.md": {
      "sha256": "13678fd302742e5c728989912705765332e2b6ae5203562a9b549786f2819db9",
      "size": 7021
    },
    "skills/security-scan/references/scan-results.md": {
      "sha256": "ddc6b6d1041b45de338c0f50849ec3f003a57c46e202c95d5c52e4cf18d3c522",
      "size": 2871
    },
    "skills/security-scan/references/scoped-paths.md": {
      "sha256": "0d4f77b51276fc1541397c9dd387464493fb9bb2d451ac2d580d1f3f35195bc5",
      "size": 2359
    },
    "skills/security-scan/references/sdk-files.md": {
      "sha256": "5a6df47271bc1a9b4fd61024e3d389311be70f732759fb2439a32e5675fb05de",
      "size": 2192
    },
    "skills/threat-model-visualize/SKILL.md": {
      "sha256": "96e1a7517575ee419284d219f5a6e75d9a7825ae499480bd78b7393b544b106a",
      "size": 19102
    },
    "skills/threat-model-visualize/agents/openai.yaml": {
      "sha256": "3b31472477c1e6f05e299df82b4a61d89b62f42ff8cec0c9394f53fa42e3cda7",
      "size": 259
    },
    "skills/threat-model-visualize/assets/context-reference-overview.svg": {
      "sha256": "b5f01ae1842c96c54d7dfe74cc0f1cb5ab1a62a4f39395162031c048e1a9c4a5",
      "size": 36850
    },
    "skills/threat-model-visualize/assets/context-reference-path.svg": {
      "sha256": "7f62d1bb0e054c44630e2a9e934ed2a6f3e15645360302b536818833c979ec00",
      "size": 60788
    },
    "skills/threat-model-visualize/assets/control-effects.js": {
      "sha256": "667abbdc09dbe20428db6eda6d12c46d1b6630ed981bf6a7eefc4fb02c671763",
      "size": 4005
    },
    "skills/threat-model-visualize/assets/explorer.css": {
      "sha256": "323849e45cbe90d0bc7efe62101c72dd21af775e493fb1e9e5a65eefcaaf4db0",
      "size": 12126
    },
    "skills/threat-model-visualize/assets/explorer.html": {
      "sha256": "bb23f19f561b59b964ab00b314d1e15a768b70f6e879e57123e3ac6d0e3d4293",
      "size": 2673
    },
    "skills/threat-model-visualize/assets/explorer.js": {
      "sha256": "117c772583d29a504137e5fefeb62bd996050175f3da5d40f214b471d072481f",
      "size": 42283
    },
    "skills/threat-model-visualize/assets/route-paths.js": {
      "sha256": "54edff9691a35a118653fcf5e128f9402fb3cc602bf25c0875514dbf328a40ae",
      "size": 3648
    },
    "skills/threat-model-visualize/assets/source-roles.js": {
      "sha256": "a304027486857462974783c12d6bfd8f09dadc7cabd2e7ed0e8fe2b7862c1ece",
      "size": 2762
    },
    "skills/threat-model-visualize/assets/svg-layout.js": {
      "sha256": "9404259952ae08a80e4877b1ac28781d453974c0d1828fb46bbec172c50f42cf",
      "size": 11530
    },
    "skills/threat-model-visualize/references/context-explorer.md": {
      "sha256": "2ec94ffc33589100cead235eacdb6ce80596272c12285532ae4a682b064fbed9",
      "size": 5636
    },
    "skills/threat-model-visualize/references/view-model.md": {
      "sha256": "05c81e732bca0b64b182329e68d47900d18da5b3c22354b11f2a0183d890b019",
      "size": 12062
    },
    "skills/threat-model-visualize/scripts/build_explorer.py": {
      "sha256": "d2036f1d8783b6d3b5a7673412b80ba6f9d2e63112f8fd8802fee1395964c90f",
      "size": 27557
    },
    "skills/threat-model/SKILL.md": {
      "sha256": "79a1b6282f80804227a28f9a1fae71bbfcd6928c1de5d2c84ab0ebf9c1f49226",
      "size": 2986
    },
    "skills/threat-model/agents/openai.yaml": {
      "sha256": "a3533478c2548248ef07c9afbbe0a7451f1fa1882883b4def0906d8113b7dd6c",
      "size": 171
    },
    "skills/track-findings/SKILL.md": {
      "sha256": "ef1cbf5e8b0240a78f32903540f6c1b500cd329c00bfcefc405fec1e382c46e9",
      "size": 13459
    },
    "skills/track-findings/agents/openai.yaml": {
      "sha256": "39e73c0003afc8bd9d3cf53c027d8274e724dc41f46e3cd6863ad34bb4de4200",
      "size": 279
    },
    "skills/track-findings/references/github-security-advisories.md": {
      "sha256": "1d0a4e10e837834e00f1c041a3aa972f176529385c5161e55821adb9d1f3cdf4",
      "size": 3420
    },
    "skills/track-findings/references/jira.md": {
      "sha256": "bb1f7bb6fa638f20f1caad35b04482ae33f0cdbf2ab9c617e7805575dff457a0",
      "size": 3027
    },
    "skills/triage-finding/SKILL.md": {
      "sha256": "2c71d6a89ef0c61ed2f5f1f6af9d05de43e38547eec777937774fd1054b0afaa",
      "size": 8394
    },
    "skills/triage-finding/agents/openai.yaml": {
      "sha256": "4a4094210aa6360cf503f5adf7be1e590e27898f3163da1b713632d2828e8563",
      "size": 400
    },
    "skills/triage-finding/references/github-rest-intake.md": {
      "sha256": "3ff78c08946b3731d2672c08817ad654724df8573ae8bc1d7560c2850e17a832",
      "size": 12277
    },
    "skills/triage-finding/references/ticket-intake.md": {
      "sha256": "b8044c6d2e15c4372fa08f6fd6946be02ce9444f1f1be4416f2e435466c73bff",
      "size": 5231
    },
    "skills/triage-finding/references/triage-result-contract.md": {
      "sha256": "709c1d803c001a47c884ba10ac97f8c1434c3ce06a75033778343a662b25729b",
      "size": 4447
    },
    "skills/validation/SKILL.md": {
      "sha256": "aac2d8598af99fc27c163c24204b264427100b89f15e203822b108262fcb7876",
      "size": 4619
    },
    "skills/validation/agents/openai.yaml": {
      "sha256": "7516bcd4748b55566694284d7d953a7db0c94d5a2123895fabb36d7d9d7d74e4",
      "size": 183
    },
    "skills/validation/references/validation-guidance.md": {
      "sha256": "48439b292c9e92195ef9905062b1c948df7202ddc1a99aa9192c71e54c46d6ab",
      "size": 4408
    },
    "skills/verify-fix/SKILL.md": {
      "sha256": "3569c165dffeae015ede1ab1c0dbfd03164673f5b6a54c263b4941ed9a9703a5",
      "size": 4193
    },
    "skills/verify-fix/agents/openai.yaml": {
      "sha256": "ac35fc4704cde35b6bf103e16a16d0a44f2b9c2671e1634292cf285905cf40f3",
      "size": 235
    },
    "skills/vulnerability-writeup/SKILL.md": {
      "sha256": "9c15d78cca5b847e270740daa405276e9e8ba5fcbfeeeb5b2a68d7752b1bda99",
      "size": 5571
    },
    "skills/vulnerability-writeup/agents/openai.yaml": {
      "sha256": "7987566daac59e3dd6c5211fe020f71fc4c862843c231d10c28a45697d680f9e",
      "size": 290
    },
    "skills/vulnerability-writeup/references/report-format.md": {
      "sha256": "68a1b4a293f0379ba5ae2c21a32d6618245f6de1b6dd977c5a2cf9d62a25c874",
      "size": 4482
    }
  }
}

SHA-256 of public snapshot: c86a875d9b371cbd9d94d26cd70600ea7c81c78738e0761c5ce406a32660fb41