← 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/deep_scan_workbench.py

− removed · + added

--- before
+++ after
@@ -3,133 +3,36 @@
 from __future__ import annotations
 
 import argparse
-import hashlib
 import json
 import os
-import shutil
 import sqlite3
 import sys
-import tempfile
 import uuid
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from deep_scan_config import resolve_deep_scan_config
-from finalize_scan_contract import _read_scan_local_json
-from workbench.handoff import require_current_continuation
-from workbench.storage import create_private_directory
+import workbench_saved_results as saved_results
+from deep_scan_config import resolve_deep_scan_setup
+from workbench.handoff import require_current_continuation, require_tokenless_scan_owner
+from workbench.storage import (
+    archived_deep_path,
+    create_private_directory,
+    saved_deep_workers,
+    worker_usage_directory,
+)
+from workbench_constants import PHASES
+from workbench_source_scopes import capture_source_scopes
 from workbench_target import directory_snapshot_regular_file_count
+from workbench_target_state import require_scan_checkout_owner
 from workbench_validation import optional_text, require_uuid, user_context_argument
 
-DEEP_SCAN_WORKER_KINDS = ("setup", "discovery", "dedup")
-DEEP_SCAN_WORKER_STATUSES = ("queued", "running", "succeeded", "failed", "canceled")
-DEEP_SCAN_REPLACEABLE_FAILURE_KINDS = (
-    "policy_refusal",
-    "transient_error",
-    "invalid_discovery_artifacts",
-)
-DEEP_SCAN_TERMINAL_REASONS = ("saturated", "capped")
-DEEP_SCAN_WORKFLOW_VERSION = "deep-security-scan/v1"
 DEEP_SCAN_COORDINATOR_LEASE_SECONDS = 30
 DEEP_SCAN_LEGACY_COORDINATOR_GRACE_SECONDS = 120
-DEEP_SCAN_MAX_ERROR_LENGTH = 2400
 DEEP_SCAN_PUBLICATION_ERROR_SEPARATOR = "\nOriginal Deep Scan failure:\n"
 
 
-def register_subcommands(subparsers: Any, positive_int: Callable[[str], int]) -> None:
-    begin_deep_scan = subparsers.add_parser("begin-deep-scan")
-    begin_deep_scan.add_argument("--thread-id", required=True)
-    begin_target = begin_deep_scan.add_mutually_exclusive_group(required=True)
-    begin_target.add_argument("--scan-id")
-    begin_target.add_argument("--target-path")
-    begin_deep_scan.add_argument("--scope", default=".")
-    begin_user_context = begin_deep_scan.add_mutually_exclusive_group()
-    begin_user_context.add_argument("--user-context")
-    begin_user_context.add_argument("--user-context-stdin", action="store_true")
-    begin_deep_scan.add_argument("--scan-root")
-    begin_deep_scan.add_argument("--claim-token")
-    begin_deep_scan.add_argument("--model")
-    begin_deep_scan.add_argument("--reasoning-effort")
-    begin_deep_scan.add_argument("--available-parallelism", type=positive_int)
-    begin_deep_scan.add_argument("--workflow-version", default=DEEP_SCAN_WORKFLOW_VERSION)
-
-    get_deep_scan = subparsers.add_parser("get-deep-scan")
-    get_deep_scan.add_argument("--scan-id", required=True)
-    get_deep_scan.add_argument("--thread-id", required=True)
-
-    claim_coordinator = subparsers.add_parser("claim-deep-scan-coordinator")
-    claim_coordinator.add_argument("--scan-id", required=True)
-    claim_coordinator.add_argument("--thread-id", required=True)
-    claim_coordinator.add_argument("--claim-token")
-    claim_coordinator.add_argument("--coordinator-generation", type=positive_int)
-
-    upsert_deep_worker = subparsers.add_parser("upsert-deep-scan-worker")
-    upsert_deep_worker.add_argument("--scan-id", required=True)
-    upsert_deep_worker.add_argument("--worker-id", required=True)
-    upsert_deep_worker.add_argument("--kind", choices=DEEP_SCAN_WORKER_KINDS, required=True)
-    upsert_deep_worker.add_argument("--status", choices=DEEP_SCAN_WORKER_STATUSES, required=True)
-    upsert_deep_worker.add_argument("--prompt-path", required=True)
-    upsert_deep_worker.add_argument("--artifact-dir", required=True)
-    upsert_deep_worker.add_argument("--result-manifest-path")
-    upsert_deep_worker.add_argument("--attempt", type=non_negative_int)
-    upsert_deep_worker.add_argument("--sdk-thread-id")
-    upsert_deep_worker.add_argument("--error-message")
-    upsert_deep_worker.add_argument(
-        "--replaceable-failure-kind", choices=DEEP_SCAN_REPLACEABLE_FAILURE_KINDS
-    )
-    upsert_deep_worker.add_argument("--coordinator-generation", type=positive_int)
-
-    claim_deep_dedup = subparsers.add_parser("claim-deep-scan-dedup")
-    claim_deep_dedup.add_argument("--scan-id", required=True)
-    claim_deep_dedup.add_argument("--worker-id", required=True)
-    claim_deep_dedup.add_argument("--prompt-path", required=True)
-    claim_deep_dedup.add_argument("--artifact-dir", required=True)
-    claim_deep_dedup.add_argument("--input-worker-id", action="append", required=True)
-    claim_deep_dedup.add_argument("--coordinator-generation", type=positive_int)
-
-    commit_deep_dedup = subparsers.add_parser("commit-deep-scan-dedup")
-    commit_deep_dedup.add_argument("--scan-id", required=True)
-    commit_deep_dedup.add_argument("--worker-id", required=True)
-    commit_deep_dedup.add_argument("--result-manifest-path", required=True)
-    commit_deep_dedup.add_argument("--candidate-ledger-path")
-    commit_deep_dedup.add_argument("--new-findings-count", type=non_negative_int, required=True)
-    commit_deep_dedup.add_argument("--coordinator-generation", type=positive_int)
-
-    finish_deep_scan = subparsers.add_parser("finish-deep-scan")
-    finish_deep_scan.add_argument("--scan-id", required=True)
-    finish_deep_scan.add_argument(
-        "--terminal-reason", choices=DEEP_SCAN_TERMINAL_REASONS, required=True
-    )
-    finish_deep_scan.add_argument("--manifest-path", required=True)
-    finish_deep_scan.add_argument("--staged-manifest-path")
-    finish_deep_scan.add_argument("--omitted-worker-id", action="append", default=[])
-    finish_deep_scan.add_argument("--coordinator-generation", type=positive_int)
-
-    fail_deep_scan = subparsers.add_parser("fail-deep-scan")
-    fail_deep_scan.add_argument("--scan-id", required=True)
-    fail_deep_scan.add_argument("--message", required=True)
-    fail_deep_scan.add_argument("--manifest-path")
-    fail_deep_scan.add_argument("--staged-manifest-path")
-    fail_deep_scan.add_argument(
-        "--deep-status", choices=("failed", "interrupted"), default="failed"
-    )
-    fail_deep_scan.add_argument("--coordinator-generation", type=positive_int)
-
-    publication_failure = subparsers.add_parser("record-deep-scan-publication-failure")
-    publication_failure.add_argument("--scan-id", required=True)
-    publication_failure.add_argument("--message", required=True)
-    publication_failure.add_argument("--coordinator-generation", type=positive_int)
-
-
-def non_negative_int(value: str) -> int:
-    parsed = int(value)
-    if parsed < 0:
-        raise argparse.ArgumentTypeError("expected a non-negative integer")
-    return parsed
-
-
 _dependencies: Any = None
 
 
@@ -144,32 +47,15 @@
     return _dependencies
 
 
-def _bounded_error_text(message: str, maximum: int) -> str:
-    if len(message) <= maximum:
-        return message
-    digest = hashlib.sha256(message.encode()).hexdigest()
-    suffix = f"\n...[truncated; sha256:{digest}]"
-    if len(suffix) >= maximum:
-        return message[:maximum]
-    return f"{message[: maximum - len(suffix)]}{suffix}"
-
-
 def deep_scan_error(run: sqlite3.Row) -> str | None:
+    """Return recorded error messages, publication error first, or None if both are absent."""
     original = run["error_message"]
     publication = run["publication_error_message"]
     if not isinstance(publication, str):
         return original if isinstance(original, str) else None
     if not isinstance(original, str):
         return publication
-    available = DEEP_SCAN_MAX_ERROR_LENGTH - len(DEEP_SCAN_PUBLICATION_ERROR_SEPARATOR)
-    publication_budget = min(len(publication), available // 2)
-    original_budget = min(len(original), available - publication_budget)
-    publication_budget = min(len(publication), available - original_budget)
-    return (
-        _bounded_error_text(publication, publication_budget)
-        + DEEP_SCAN_PUBLICATION_ERROR_SEPARATOR
-        + _bounded_error_text(original, original_budget)
-    )
+    return publication + DEEP_SCAN_PUBLICATION_ERROR_SEPARATOR + original
 
 
 def _parse_timestamp(value: str) -> datetime:
@@ -189,6 +75,7 @@
 
 
 def deep_scan_deadline_reached(run: sqlite3.Row) -> bool:
+    """Return whether the time since run creation has reached its configured limit in hours."""
     elapsed = _parse_timestamp(dependencies().now()) - _parse_timestamp(str(run["created_at"]))
     return elapsed.total_seconds() / 3600 >= run["max_time_hours"]
 
@@ -196,10 +83,15 @@
 def require_deep_scan_ready_for_parent_completion(
     connection: sqlite3.Connection, scan: sqlite3.Row
 ) -> None:
+    """Require a succeeded discovery run with a saved manifest before a Deep Scan completes.
+
+    For a capped run, also verify its workers have finished. Raise SystemExit
+    when a completion requirement fails. Other scan modes can complete directly.
+    """
     if scan["mode"] != "deep":
         return
     run = connection.execute(
-        "SELECT status, manifest_path FROM deep_scan_runs WHERE scan_id = ?",
+        "SELECT status, manifest_path, terminal_reason FROM deep_scan_runs WHERE scan_id = ?",
         (scan["id"],),
     ).fetchone()
     if run is None or run["status"] != "succeeded" or run["manifest_path"] is None:
@@ -207,11 +99,90 @@
             "Deep Scan discovery orchestration must finish and persist its manifest before "
             "the parent scan can be completed."
         )
+    if run["terminal_reason"] == "capped":
+        require_deep_scan_workers_finished(connection, scan["id"], "capped")
+
+
+def require_deep_scan_workers_finished(
+    connection: sqlite3.Connection,
+    scan_id: str,
+    terminal_reason: str,
+    *,
+    has_omitted_workers: bool = False,
+) -> None:
+    """Check execution state for coordinator completion and resumed parent publication."""
+    failed_worker = connection.execute(
+        """
+        SELECT 1 FROM deep_scan_workers AS failed
+        WHERE failed.scan_id = ? AND failed.status = 'failed'
+            AND (? != 'saturated' OR failed.kind != 'discovery')
+            AND (
+                failed.kind != 'dedup'
+                OR NOT EXISTS (
+                    SELECT 1 FROM deep_scan_dedup_inputs AS failed_inputs
+                    WHERE failed_inputs.dedup_worker_id = failed.id
+                )
+                OR EXISTS (
+                    SELECT 1 FROM deep_scan_dedup_inputs AS failed_inputs
+                    WHERE failed_inputs.dedup_worker_id = failed.id
+                        AND NOT EXISTS (
+                            SELECT 1
+                            FROM deep_scan_dedup_inputs AS replacement_inputs
+                            JOIN deep_scan_workers AS replacement
+                                ON replacement.scan_id = replacement_inputs.scan_id
+                                AND replacement.id = replacement_inputs.dedup_worker_id
+                            WHERE replacement_inputs.scan_id = failed.scan_id
+                                AND replacement_inputs.discovery_worker_id =
+                                    failed_inputs.discovery_worker_id
+                                AND replacement.kind = 'dedup'
+                                AND replacement.status = 'succeeded'
+                        )
+                )
+            )
+        LIMIT 1
+        """,
+        (scan_id, terminal_reason),
+    ).fetchone()
+    if failed_worker is not None:
+        raise SystemExit("Deep Scan cannot finish after a worker has failed.")
+    active_worker = connection.execute(
+        """
+        SELECT 1 FROM deep_scan_workers
+        WHERE scan_id = ? AND status IN ('queued', 'running')
+        LIMIT 1
+        """,
+        (scan_id,),
+    ).fetchone()
+    if active_worker is not None:
+        raise SystemExit("Deep Scan cannot finish while workers are active.")
+    merging_worker = connection.execute(
+        """
+        SELECT 1 FROM deep_scan_workers
+        WHERE scan_id = ? AND merge_state = 'merging'
+        LIMIT 1
+        """,
+        (scan_id,),
+    ).fetchone()
+    if merging_worker is not None:
+        raise SystemExit("Deep Scan cannot finish while discovery output is merging.")
+    if terminal_reason == "capped" and has_omitted_workers:
+        raise SystemExit("Deep Scan capped completion cannot declare omitted buffered workers.")
+    if (
+        terminal_reason == "capped"
+        and connection.execute(
+            "SELECT 1 FROM deep_scan_workers WHERE scan_id = ? "
+            "AND kind = 'discovery' AND merge_state = 'buffered' LIMIT 1",
+            (scan_id,),
+        ).fetchone()
+        is not None
+    ):
+        raise SystemExit("Deep Scan cannot finish capped while discovery output remains buffered.")
 
 
 def require_owned_scan(
     connection: sqlite3.Connection, scan_id: str, thread_id: str
 ) -> tuple[sqlite3.Row, sqlite3.Row]:
+    """Return the scan and workspace rows or raise SystemExit unless thread_id matches the recorded owner."""
     scan = dependencies().require_scan(connection, scan_id)
     workspace = dependencies().require_workspace(connection, scan["workspace_id"])
     owner = optional_text(thread_id, maximum=512)
@@ -230,6 +201,7 @@
     *,
     kind: str,
 ) -> str:
+    """Return the canonical absolute path to an existing scan-local file or directory of the requested kind."""
     supplied = Path(value).expanduser()
     if not supplied.is_absolute():
         raise SystemExit(f"{label} must be an absolute path inside the scan directory.")
@@ -249,6 +221,7 @@
 
 
 def deep_scan_output_path(scan: sqlite3.Row, value: str, label: str) -> str:
+    """Validate an absolute output path under the scan directory, allowing a new file under an existing parent."""
     supplied = Path(value).expanduser()
     if not supplied.is_absolute():
         raise SystemExit(f"{label} must be an absolute path inside the scan directory.")
@@ -262,6 +235,7 @@
 
 
 def promote_staged_file(staged_path: str, output_path: str) -> tuple[Path, Path, Path | None]:
+    """Publish the staged file and return the paths needed to finalize or undo the move."""
     staged = Path(staged_path)
     output = Path(output_path)
     if staged == output:
@@ -279,6 +253,7 @@
 
 
 def rollback_staged_file(promotion: tuple[Path, Path, Path | None]) -> None:
+    """Move the published file back to staging and restore the previous output if present."""
     staged, output, backup = promotion
     if output.exists():
         os.replace(output, staged)
@@ -287,19 +262,14 @@
 
 
 def finish_staged_file(promotion: tuple[Path, Path, Path | None]) -> None:
+    """Remove the previous output saved during promotion."""
     backup = promotion[2]
     if backup is not None:
         backup.unlink(missing_ok=True)
 
 
-def create_publication_copy(source: str | Path, destination: str | Path) -> None:
-    try:
-        os.link(source, destination)
-    except OSError:
-        shutil.copy2(source, destination)
-
-
 def publication_matches_snapshot(publication: Path, snapshot: Path) -> bool:
+    """Return whether the publication and snapshot identify the same file or contain identical bytes."""
     try:
         if publication.samefile(snapshot):
             return True
@@ -329,17 +299,14 @@
 
 
 def deep_scan_state(connection: sqlite3.Connection, scan_id: str) -> dict[str, Any]:
+    """Return persisted orchestration state including settings, workers, artifacts, and deduplication inputs.
+
+    Order workers by creation time and ID. Retain the recorded order of each
+    deduplication worker’s discovery inputs.
+    """
     run = require_deep_scan_run(connection, scan_id)
     scan = dependencies().require_scan(connection, run["scan_id"])
-    worker_rows = connection.execute(
-        """
-        SELECT *
-        FROM deep_scan_workers
-        WHERE scan_id = ?
-        ORDER BY created_at, id
-        """,
-        (run["scan_id"],),
-    )
+    worker_rows = saved_deep_workers(connection, scan)
     input_rows = connection.execute(
         """
         SELECT dedup_worker_id, discovery_worker_id, input_order
@@ -349,12 +316,13 @@
         """,
         (run["scan_id"],),
     )
+    manifest_path = archived_deep_path(Path(scan["scan_dir"]), run["manifest_path"])
     canonical_artifacts = None
     if (
         run["canonical_inventory_path"] is None
         and run["status"] == "succeeded"
-        and run["manifest_path"] is not None
-        and run["manifest_path"] != str(Path(scan["scan_dir"]) / "scan-manifest.json")
+        and manifest_path is not None
+        and manifest_path != str(Path(scan["scan_dir"]) / "scan-manifest.json")
         and (Path(scan["scan_dir"]) / "artifacts" / "02_discovery" / "in_scope_files.txt").exists()
     ):
         canonical_artifacts = canonical_discovery_artifacts(scan)
@@ -368,17 +336,33 @@
                 "A capped Deep Scan without completed discoveries requires an empty "
                 "candidate ledger."
             )
+    recipe = json.loads(scan["recipe_json"]) if scan["recipe_json"] is not None else {}
     return {
         "scanId": run["scan_id"],
+        "sdkOwnsCompletion": scan["recipe_json"] is not None,
+        "serviceTier": run["service_tier"],
+        **({"severityRubric": recipe["severityRubric"]} if "severityRubric" in recipe else {}),
         "targetPath": scan["target_path"],
         "scope": scan["scope"],
-        "userContext": scan["user_context"],
+        "includePaths": dependencies().requested_scan_paths(scan),
+        "filePaths": dependencies().requested_scan_file_paths(scan),
+        "userContext": (
+            json.loads(run["discovery_user_context_json"])
+            if run["discovery_user_context_json"] is not None
+            else scan["user_context"]
+        ),
         "scanDir": scan["scan_dir"],
+        "workerUsageDirectory": str(worker_usage_directory(run["scan_id"])),
         "schemaVersion": run["schema_version"],
         "workflowVersion": run["workflow_version"],
         "coordinatorGeneration": run["coordinator_generation"],
         "status": run["status"],
         "phase": run["phase"],
+        # Older coordinators could persist discovery on the parent before dispatching.
+        "discoveryStarted": (
+            PHASES.index(scan["phase"]) >= PHASES.index("discovery")
+            or run["phase"] in {"discovery", "reducing"}
+        ),
         "config": {
             "workers": run["workers"],
             "subagents": run["subagents"],
@@ -393,7 +377,7 @@
         "consecutiveErrors": run["consecutive_errors"],
         "cancelRequested": bool(run["cancel_requested"]),
         "canonicalArtifacts": canonical_artifacts,
-        "manifestPath": run["manifest_path"],
+        "manifestPath": manifest_path,
         "terminalReason": run["terminal_reason"],
         "error": deep_scan_error(run),
         "createdAt": run["created_at"],
@@ -412,8 +396,9 @@
 
 
 def independent_review_progress(
-    connection: sqlite3.Connection, scan_id: str
+    connection: sqlite3.Connection, scan_id: str, *, parent_running: bool
 ) -> dict[str, int | str] | None:
+    """Return completed and allowed review counts and the consolidation state, or None for a missing run."""
     run = connection.execute(
         """
         SELECT completion_sequence, phase, updated_at, max_discovery_runs
@@ -424,21 +409,21 @@
     ).fetchone()
     if run is None:
         return None
-    active = connection.execute(
+    active, buffered = connection.execute(
         """
-        SELECT COUNT(*)
+        SELECT COUNT(*) FILTER (WHERE status IN ('queued', 'running')),
+               COUNT(*) FILTER (WHERE status = 'succeeded' AND merge_state = 'buffered')
         FROM deep_scan_workers
-        WHERE scan_id = ?
-            AND kind = 'discovery'
-            AND status IN ('queued', 'running')
+        WHERE scan_id = ? AND kind = 'discovery'
         """,
         (scan_id,),
-    ).fetchone()[0]
+    ).fetchone()
+    consolidating = run["phase"] in {"reducing", "terminal"} or (active == 0 and buffered > 0)
     return {
         "active": int(active),
         "completed": int(run["completion_sequence"]),
         "maximum": int(run["max_discovery_runs"]),
-        "consolidating": run["phase"] == "reducing",
+        "consolidating": parent_running and consolidating,
         "updatedAt": str(run["updated_at"]),
     }
 
@@ -475,9 +460,13 @@
     return result
 
 
-def effective_deep_scan_config(args: argparse.Namespace) -> dict[str, int | float]:
-    available_parallelism = args.available_parallelism or os.cpu_count() or 1
-    return resolve_deep_scan_config(available_parallelism)
+def effective_deep_scan_config(
+    args: argparse.Namespace, workspace: sqlite3.Row | None = None
+) -> dict[str, Any]:
+    """Use persisted workspace settings when available, otherwise resolve the current launch configuration."""
+    if workspace is not None and workspace["deep_scan_config_json"] is not None:
+        return json.loads(workspace["deep_scan_config_json"])
+    return resolve_deep_scan_setup(project_json=args.deep_scan_project_json)
 
 
 def ensure_deep_scan_run(
@@ -486,7 +475,11 @@
     config: dict[str, int | float],
     workflow_version: str,
     timestamp: str,
+    *,
+    service_tier: str | None,
+    pending_target_project_path: str | None = None,
 ) -> sqlite3.Row:
+    """Return the existing orchestration row or initialize one for a running Deep Scan with the supplied settings."""
     existing = connection.execute(
         "SELECT * FROM deep_scan_runs WHERE scan_id = ?", (scan["id"],)
     ).fetchone()
@@ -501,9 +494,9 @@
         INSERT INTO deep_scan_runs (
             scan_id, schema_version, workflow_version, status, phase,
             workers, subagents, stop_after_no_new, stop_after_consecutive_errors,
-            max_discovery_runs, max_time_hours,
-            created_at, updated_at
-        ) VALUES (?, 1, ?, 'running', 'setup', ?, ?, ?, ?, ?, ?, ?, ?)
+            max_discovery_runs, max_time_hours, discovery_user_context_json,
+            created_at, updated_at, service_tier, pending_target_project_path
+        ) VALUES (?, 1, ?, 'running', 'setup', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             scan["id"],
@@ -514,8 +507,11 @@
             config["stopAfterConsecutiveErrors"],
             config["maxDiscoveryRuns"],
             config["maxTimeHours"],
+            json.dumps(scan["user_context"]),
             timestamp,
             timestamp,
+            service_tier,
+            pending_target_project_path,
         ),
     )
     return require_deep_scan_run(connection, scan["id"])
@@ -529,7 +525,7 @@
         SELECT scans.*
         FROM scans
         JOIN workspaces ON workspaces.id = scans.workspace_id
-        WHERE workspaces.thread_id = ?
+        WHERE (workspaces.thread_id = ? OR workspaces.thread_id IS NULL)
             AND COALESCE(scans.deep_scan_owner_thread_id, workspaces.thread_id) = ?
             AND scans.target_path = ?
             AND scans.scope = ?
@@ -547,17 +543,14 @@
     thread_id: str,
     target_path: str,
     scope: str,
+    user_context: str | None,
+    project_path: str,
     revision: str,
     snapshot_digest: str,
     target_device: int | str,
     target_inode: int | str,
 ) -> sqlite3.Row | None:
-    """Find discovery completed before a headless continuation changed thread IDs.
-
-    A continuation may safely consume a finished coordinator manifest while the
-    parent scan is still open. It must not adopt live orchestration owned by a
-    different thread, or reuse results after the repository snapshot changed.
-    """
+    """Recover a matching terminal headless result, including after the parent was sealed."""
     return connection.execute(
         """
         SELECT scans.*
@@ -566,16 +559,25 @@
         JOIN workspaces ON workspaces.id = scans.workspace_id
         WHERE scans.target_path = ?
             AND scans.scope = ?
+            AND deep_scan_runs.discovery_user_context_json = ?
             AND scans.mode = 'deep'
-            AND scans.status = 'running'
+            AND (
+                (scans.status = 'running'
+                    AND COALESCE(scans.deep_scan_owner_thread_id, workspaces.thread_id) <> ?)
+                OR (scans.status = 'complete'
+                    AND deep_scan_runs.pending_target_project_path IS NOT NULL)
+            )
+            AND (deep_scan_runs.pending_target_project_path IS NULL
+                OR deep_scan_runs.pending_target_project_path = ?)
             AND scans.canceled_at IS NULL
+            AND scans.recipe_json IS NULL
             AND scans.target_revision = ?
             AND scans.target_snapshot_digest = ?
             AND scans.target_device = ?
             AND scans.target_inode = ?
             AND scans.handoff_status = 'delivered'
             AND scans.handoff_claim_token IS NULL
-            AND COALESCE(scans.deep_scan_owner_thread_id, workspaces.thread_id) <> ?
+            AND scans.continuation_thread_id IS NULL
             AND workspaces.active_scan_id = scans.id
             AND deep_scan_runs.status = 'succeeded'
             AND deep_scan_runs.phase = 'terminal'
@@ -583,12 +585,16 @@
             AND deep_scan_runs.terminal_reason IN ('saturated', 'capped')
             AND deep_scan_runs.manifest_path IS NOT NULL
             AND deep_scan_runs.completed_at IS NOT NULL
-        ORDER BY deep_scan_runs.completed_at DESC, scans.updated_at DESC, scans.id
+        ORDER BY (COALESCE(scans.deep_scan_owner_thread_id, workspaces.thread_id) = ?) DESC,
+            deep_scan_runs.completed_at DESC, scans.updated_at DESC, scans.id
         LIMIT 1
         """,
         (
             target_path,
             scope,
+            json.dumps(user_context),
+            thread_id,
+            project_path,
             revision,
             snapshot_digest,
             target_device,
@@ -606,11 +612,16 @@
 ) -> dict[str, Any]:
     scan_id = require_uuid(scan_id, "scan-id")
     candidate = dependencies().require_scan(connection, scan_id)
+    require_scan_checkout_owner(connection, candidate)
+    model_thread_id = getattr(args, "model_thread_id", None)
+    require_tokenless_scan_owner(connection, candidate, model_thread_id)
     workspace = dependencies().require_workspace(connection, candidate["workspace_id"])
     if (
         candidate["mode"] == "deep"
         and candidate["status"] == "running"
-        and candidate["recipe_json"] is not None
+        and (
+            candidate["recipe_json"] is not None or candidate["continuation_thread_id"] == thread_id
+        )
         and candidate["handoff_status"] == "delivered"
         and candidate["deep_scan_owner_thread_id"] is None
         and workspace["thread_id"] is None
@@ -622,18 +633,33 @@
         )
         timestamp = dependencies().now()
         with connection:
-            claimed_workspace = connection.execute(
-                "UPDATE workspaces SET thread_id = ?, updated_at = ? "
-                "WHERE id = ? AND thread_id IS NULL",
-                (thread_id, timestamp, workspace["id"]),
-            )
+            # Legacy scans can share a workspace. Only registered scans claim the workspace.
+            if candidate["recipe_json"] is not None:
+                claimed_workspace = connection.execute(
+                    "UPDATE workspaces SET thread_id = ?, updated_at = ? "
+                    "WHERE id = ? AND thread_id IS NULL",
+                    (thread_id, timestamp, workspace["id"]),
+                )
+                if claimed_workspace.rowcount != 1:
+                    raise SystemExit(
+                        "A scan can only be orchestrated from its owning Codex thread."
+                    )
             claimed_scan = connection.execute(
                 "UPDATE scans SET deep_scan_owner_thread_id = ?, updated_at = ? "
                 "WHERE id = ? AND deep_scan_owner_thread_id IS NULL "
-                "AND handoff_status = 'delivered' AND handoff_claim_token IS ?",
-                (thread_id, timestamp, scan_id, candidate["handoff_claim_token"]),
+                "AND handoff_status = 'delivered' AND handoff_claim_token IS ? "
+                "AND (continuation_thread_id = ? OR (recipe_json IS NOT NULL AND "
+                "(handoff_claim_token IS NOT NULL OR (? IS NULL AND continuation_thread_id IS NULL))))",
+                (
+                    thread_id,
+                    timestamp,
+                    scan_id,
+                    candidate["handoff_claim_token"],
+                    thread_id,
+                    model_thread_id,
+                ),
             )
-            if claimed_workspace.rowcount != 1 or claimed_scan.rowcount != 1:
+            if claimed_scan.rowcount != 1:
                 raise SystemExit("A scan can only be orchestrated from its owning Codex thread.")
     scan, _ = require_owned_scan(connection, scan_id, thread_id)
     require_current_continuation(
@@ -643,6 +669,11 @@
     )
     if scan["mode"] != "deep":
         raise SystemExit("Deep Scan orchestration requires a scan in deep mode.")
+    existing = connection.execute(
+        "SELECT scan_id FROM deep_scan_runs WHERE scan_id = ?", (scan_id,)
+    ).fetchone()
+    if args.join_only and existing is None and workspace["deep_scan_config_json"] is None:
+        return {"newScanTarget": scan["target_path"]}
     model = optional_text(args.model, maximum=200)
     reasoning_effort = optional_text(args.reasoning_effort, maximum=32)
     if model is not None or reasoning_effort is not None:
@@ -655,24 +686,35 @@
             (model, reasoning_effort, scan_id),
         )
         connection.commit()
-    existing = connection.execute(
-        "SELECT scan_id FROM deep_scan_runs WHERE scan_id = ?", (scan_id,)
-    ).fetchone()
     if existing is not None:
         return deep_scan_result(connection, scan_id, start_disposition="joined")
-    config = effective_deep_scan_config(args)
+    workspace = dependencies().require_workspace(connection, scan["workspace_id"])
+    configuration = effective_deep_scan_config(args, workspace)
+    config = configuration["settings"]
     workflow_version = optional_text(args.workflow_version, maximum=256)
     if workflow_version is None:
         raise SystemExit("workflow-version is required.")
     connection.execute("BEGIN IMMEDIATE")
     with connection:
         scan, _ = require_owned_scan(connection, scan_id, thread_id)
+        require_scan_checkout_owner(connection, scan)
         require_current_continuation(
             scan,
             args.claim_token,
             error_message="Deep Scan orchestration is owned by another continuation.",
         )
-        ensure_deep_scan_run(connection, scan, config, workflow_version, dependencies().now())
+        connection.execute(
+            "UPDATE workspaces SET deep_scan_config_json = ? WHERE id = ? AND deep_scan_config_json IS NULL",
+            (json.dumps(configuration), workspace["id"]),
+        )
+        ensure_deep_scan_run(
+            connection,
+            scan,
+            config,
+            workflow_version,
+            dependencies().now(),
+            service_tier=args.service_tier,
+        )
     return deep_scan_result(connection, scan_id, start_disposition="created")
 
 
@@ -686,6 +728,32 @@
     existing = existing_deep_scan_for_target(connection, thread_id, target_path, scope)
     if existing is not None:
         return begin_deep_scan_for_scan(connection, existing["id"], thread_id, args)
+    user_context = user_context_argument(args)
+    # Keep the requested spelling so a continuation can match a removed file or symlink.
+    # NULL means no result is pending. The empty string denotes a launch with no project file.
+    project_path = args.project_config_path or ""
+    # Avoid hashing the checkout during this probe when a fresh scan needs its configuration.
+    if (
+        args.join_only
+        and not connection.execute(
+            """
+            SELECT 1 FROM scans JOIN deep_scan_runs ON deep_scan_runs.scan_id = scans.id
+            WHERE scans.target_path = ? AND scans.scope = ?
+                AND (scans.status = 'running'
+                    OR (scans.status = 'complete'
+                        AND deep_scan_runs.pending_target_project_path IS NOT NULL))
+                AND (deep_scan_runs.pending_target_project_path IS NULL
+                    OR deep_scan_runs.pending_target_project_path = ?)
+                AND scans.recipe_json IS NULL
+                AND scans.handoff_claim_token IS NULL AND scans.continuation_thread_id IS NULL
+                AND deep_scan_runs.status = 'succeeded'
+                AND deep_scan_runs.discovery_user_context_json = ?
+            LIMIT 1
+            """,
+            (target_path, scope, project_path, json.dumps(user_context)),
+        ).fetchone()
+    ):
+        return {"newScanTarget": target_path}
     target_metadata = target.stat()
     target_identity = dependencies().scan_target_identity(target, None, metadata=target_metadata)
     revision, target_snapshot_digest, target_device, target_inode = target_identity
@@ -696,23 +764,9 @@
     with connection:
         existing = existing_deep_scan_for_target(connection, thread_id, target_path, scope)
         if existing is not None:
-            existing_run = connection.execute(
-                "SELECT 1 FROM deep_scan_runs WHERE scan_id = ?", (existing["id"],)
-            ).fetchone()
-            if existing_run is None:
-                config = effective_deep_scan_config(args)
-                workflow_version = optional_text(args.workflow_version, maximum=256)
-                if workflow_version is None:
-                    raise SystemExit("workflow-version is required.")
-                ensure_deep_scan_run(
-                    connection, existing, config, workflow_version, dependencies().now()
-                )
+            require_scan_checkout_owner(connection, existing)
             connection.commit()
-            return deep_scan_result(
-                connection,
-                existing["id"],
-                start_disposition="joined" if existing_run is not None else "created",
-            )
+            return begin_deep_scan_for_scan(connection, existing["id"], thread_id, args)
         current_target = dependencies().require_remediation_target(target_path)
         current_metadata = current_target.stat()
         if (current_metadata.st_dev, current_metadata.st_ino) != (
@@ -727,46 +781,48 @@
             thread_id,
             target_path,
             scope,
+            user_context,
+            project_path,
             revision,
             target_snapshot_digest,
             target_device,
             target_inode,
         )
         if terminal is not None:
+            require_scan_checkout_owner(connection, terminal)
             connection.commit()
             return deep_scan_result(
                 connection,
                 terminal["id"],
                 start_disposition="joined",
             )
-        config = effective_deep_scan_config(args)
+        if args.join_only:
+            return {"newScanTarget": target_path}
+        source_scopes = capture_source_scopes(
+            target,
+            (revision, target_snapshot_digest, target_device, target_inode),
+            [scope],
+        )
+        configuration = effective_deep_scan_config(args)
+        config = configuration["settings"]
         workflow_version = optional_text(args.workflow_version, maximum=256)
         if workflow_version is None:
             raise SystemExit("workflow-version is required.")
-        root = dependencies().resolve_scan_root(args.scan_root)
-        target_root = (root / dependencies().safe_segment(target.name)).resolve()
-        if target_root == target or target in target_root.parents:
-            raise SystemExit("The scan artifact directory must be outside the selected target.")
-        create_private_directory(target_root)
-        user_context = user_context_argument(args)
+        target_root = dependencies().scan_target_root(args.scan_root, target)
+        create_private_directory(target_root, scan_output=True)
         model = optional_text(args.model, maximum=200)
         reasoning_effort = optional_text(args.reasoning_effort, maximum=32)
         workspace_id = str(uuid.uuid4())
         scan_id = str(uuid.uuid4())
         timestamp = dependencies().now()
-        target_id = dependencies().ensure_security_target(connection, target_path)
-        scan_dir = Path(
-            tempfile.mkdtemp(
-                prefix=f"{dependencies().safe_segment(revision)}_{dependencies().compact_timestamp()}_",
-                dir=target_root,
-            )
-        ).resolve()
+        registration = dependencies().register_security_target(connection, target_path)
+        target_id = registration.target_id
         connection.execute(
             """
             INSERT INTO workspaces (
                 id, thread_id, target_id, target_path, target_title, default_scope, default_mode,
-                user_context, submitted, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, 'deep', ?, 1, ?, ?)
+                user_context, submitted, created_at, updated_at, deep_scan_config_json
+            ) VALUES (?, ?, ?, ?, ?, ?, 'deep', ?, 1, ?, ?, ?)
             """,
             (
                 workspace_id,
@@ -778,6 +834,7 @@
                 user_context,
                 timestamp,
                 timestamp,
+                json.dumps(configuration),
             ),
         )
         workspace = connection.execute(
@@ -791,6 +848,8 @@
             scope=scope,
             diff_target=None,
             target_identity=target_identity,
+            repository_generation=registration.repository_generation,
+            source_scopes=source_scopes,
             target_root=target_root,
             target_summary=None,
             scope_file_count=scope_file_count,
@@ -798,14 +857,22 @@
             handoff_status="delivered",
             model=model,
             reasoning_effort=reasoning_effort,
-            scan_dir=scan_dir,
         )
         scan = dependencies().require_scan(connection, scan_id)
-        ensure_deep_scan_run(connection, scan, config, workflow_version, timestamp)
+        ensure_deep_scan_run(
+            connection,
+            scan,
+            config,
+            workflow_version,
+            timestamp,
+            service_tier=args.service_tier,
+            pending_target_project_path=project_path,
+        )
     return deep_scan_result(connection, scan_id, start_disposition="created")
 
 
 def begin_deep_scan(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
+    """Begin orchestration for a registered scan or a target, returning the scan state and its start disposition."""
     thread_id = optional_text(args.thread_id, maximum=512)
     if thread_id is None:
         raise SystemExit("thread-id is required.")
@@ -819,16 +886,36 @@
 
 
 def get_deep_scan(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
+    """Return the persisted orchestration result to the thread that owns the scan."""
     scan, _ = require_owned_scan(connection, args.scan_id, args.thread_id)
     return deep_scan_result(connection, scan["id"])
 
 
+def acknowledge_deep_scan_result(
+    connection: sqlite3.Connection, args: argparse.Namespace
+) -> dict[str, Any]:
+    with connection:
+        connection.execute(
+            """
+            UPDATE deep_scan_runs SET pending_target_project_path = NULL
+            WHERE scan_id = ? AND pending_target_project_path IS NOT NULL
+                AND status = 'succeeded'
+                AND EXISTS (
+                    SELECT 1 FROM scans WHERE id = deep_scan_runs.scan_id AND status = 'complete'
+                )
+            """,
+            (require_uuid(args.scan_id, "scan-id"),),
+        )
+    return {}
+
+
 def coordinator_lease_is_live(
     connection: sqlite3.Connection,
     run: sqlite3.Row,
     scan: sqlite3.Row,
     timestamp: str,
 ) -> bool:
+    """Check coordinator freshness using the lease generation and its applicable activity timestamps."""
     if run["coordinator_generation"] == 1:
         active_worker = connection.execute(
             """
@@ -855,6 +942,7 @@
         if heartbeat["coordinatorGeneration"] == run["coordinator_generation"]:
             heartbeat_time = max(heartbeat_time, _parse_timestamp(heartbeat["updatedAt"]))
     except (OSError, KeyError, TypeError, ValueError):
+        # Missing or invalid heartbeat files leave the persisted lease timestamp in effect.
         pass
     current_time = _parse_timestamp(timestamp)
     return heartbeat_time > current_time - timedelta(seconds=DEEP_SCAN_COORDINATOR_LEASE_SECONDS)
@@ -891,7 +979,8 @@
             args.claim_token,
             error_message="Deep Scan orchestration is owned by another continuation.",
         )
-        run, _ = require_running_deep_scan(connection, scan_id)
+        run = require_deep_scan_run(connection, scan_id)
+        require_running_deep_scan(run, scan)
         timestamp = dependencies().now()
         if args.coordinator_generation is not None:
             require_current_coordinator(run, args)
@@ -925,6 +1014,7 @@
 def recover_expired_coordinator(
     connection: sqlite3.Connection, run: sqlite3.Row, timestamp: str
 ) -> None:
+    """Recover interrupted publications and reset active work so a replacement coordinator can resume."""
     scan_id = run["scan_id"]
     recover_candidate_ledger_publication(connection, scan_id)
     legacy_generation = int(run["coordinator_generation"] == 1)
@@ -1000,6 +1090,7 @@
 
 
 def recover_candidate_ledger_publication(connection: sqlite3.Connection, scan_id: str) -> None:
+    """Reconcile ledger backups with reducer snapshots after an interrupted publication."""
     scan = dependencies().require_scan(connection, scan_id)
     ledger = Path(scan["scan_dir"]) / "artifacts" / "02_discovery" / "candidate_ledger.jsonl"
     backups = sorted(
@@ -1037,26 +1128,11 @@
         return
 
 
-def require_deep_scan_worker(connection: sqlite3.Connection, worker_id: str) -> sqlite3.Row:
-    worker_id = require_uuid(worker_id, "worker-id")
-    row = connection.execute(
-        "SELECT * FROM deep_scan_workers WHERE id = ?", (worker_id,)
-    ).fetchone()
-    if row is None:
-        raise SystemExit("Codex Security Deep Scan worker not found.")
-    return row
-
-
-def require_running_deep_scan(
-    connection: sqlite3.Connection, scan_id: str
-) -> tuple[sqlite3.Row, sqlite3.Row]:
-    run = require_deep_scan_run(connection, scan_id)
-    scan = dependencies().require_scan(connection, run["scan_id"])
+def require_running_deep_scan(run: sqlite3.Row, scan: sqlite3.Row) -> None:
     if run["status"] != "running" or run["cancel_requested"]:
         raise SystemExit("Only a running Deep Scan can update orchestration state.")
     if scan["status"] != "running" or scan["canceled_at"] is not None:
         raise SystemExit("Only a running scan can update Deep Scan orchestration state.")
-    return run, scan
 
 
 def require_worker_transition(current: str, requested: str) -> None:
@@ -1084,13 +1160,19 @@
         existing = connection.execute(
             "SELECT * FROM deep_scan_workers WHERE id = ?", (worker_id,)
         ).fetchone()
+        if args.terminal_failure and (
+            args.status != "failed" or not optional_text(args.error_message)
+        ):
+            raise SystemExit(
+                "A terminal worker failure requires failed status and an error message."
+            )
         replaceable_failure_kind = args.replaceable_failure_kind
         if replaceable_failure_kind is not None and (
             args.kind != "discovery"
             or args.status != "canceled"
             or existing is None
             or existing["status"] not in {"running", "canceled"}
-            or optional_text(args.error_message, maximum=2400) is None
+            or optional_text(args.error_message) is None
         ):
             raise SystemExit(
                 "A replaceable Deep Scan failure requires a running discovery worker, "
@@ -1108,7 +1190,7 @@
             and args.status in {"succeeded", "failed", "canceled"}
         )
         if not cleanup_update and not terminal_repeat:
-            require_running_deep_scan(connection, scan_id)
+            require_running_deep_scan(run, scan)
         prompt_path = deep_scan_path(scan, args.prompt_path, "Worker prompt path", kind="file")
         artifact_dir = deep_scan_path(
             scan, args.artifact_dir, "Worker artifact directory", kind="directory"
@@ -1126,7 +1208,9 @@
         timestamp = dependencies().now()
         if existing is None:
             if args.kind == "dedup":
-                raise SystemExit("Create dedup workers with claim-deep-scan-dedup.")
+                raise SystemExit(
+                    "Deep Scan checkpoints are recorded with record-deep-scan-iteration."
+                )
             if args.status not in {"queued", "running"}:
                 raise SystemExit("A new Deep Scan worker must be queued or running.")
             if (
@@ -1171,7 +1255,7 @@
                     artifact_dir,
                     attempt,
                     optional_text(args.sdk_thread_id, maximum=512),
-                    optional_text(args.error_message, maximum=2400),
+                    optional_text(args.error_message),
                     timestamp,
                     timestamp if args.status == "running" else None,
                     timestamp,
@@ -1188,7 +1272,7 @@
         if terminal_repeat:
             repeated_attempt = args.attempt if args.attempt is not None else existing["attempt"]
             repeated_thread_id = optional_text(args.sdk_thread_id, maximum=512)
-            repeated_error = optional_text(args.error_message, maximum=2400)
+            repeated_error = optional_text(args.error_message)
             repeated_result_path = result_manifest_path or existing["result_manifest_path"]
             if (
                 repeated_attempt != existing["attempt"]
@@ -1209,7 +1293,7 @@
         if args.status == "running" and attempt < 1:
             raise SystemExit("A running Deep Scan worker attempt must be at least one.")
         if args.kind == "dedup" and args.status == "succeeded":
-            raise SystemExit("Commit a successful dedup worker with commit-deep-scan-dedup.")
+            raise SystemExit("Deep Scan checkpoints are recorded with record-deep-scan-iteration.")
         if args.kind == "discovery" and args.status == "succeeded" and result_manifest_path is None:
             result_manifest_path = existing["result_manifest_path"]
             if result_manifest_path is None:
@@ -1270,15 +1354,18 @@
             if args.status in {"succeeded", "failed", "canceled"}
             else existing["completed_at"]
         )
-        error_message = optional_text(args.error_message, maximum=2400)
+        error_message = optional_text(args.error_message)
         if error_message is None and args.status != "succeeded":
             error_message = existing["error_message"]
         started_at = existing["started_at"] or (timestamp if args.status == "running" else None)
+        thread_id = optional_text(args.sdk_thread_id, maximum=512)
+        if thread_id is None and attempt == existing["attempt"]:
+            thread_id = existing["sdk_thread_id"]
         connection.execute(
             """
             UPDATE deep_scan_workers
             SET status = ?, result_manifest_path = ?, attempt = ?,
-                sdk_thread_id = COALESCE(?, sdk_thread_id),
+                sdk_thread_id = ?,
                 completion_sequence = ?, merge_state = ?,
                 error_message = ?,
                 started_at = ?, completed_at = ?, updated_at = ?
@@ -1288,7 +1375,7 @@
                 args.status,
                 result_manifest_path or existing["result_manifest_path"],
                 attempt,
-                optional_text(args.sdk_thread_id, maximum=512),
+                thread_id,
                 completion_sequence,
                 merge_state,
                 error_message,
@@ -1298,275 +1385,81 @@
                 worker_id,
             ),
         )
+        if args.terminal_failure:
+            # Persist the first terminal cause with its worker. An adopting coordinator
+            # completes the normal failure path after active workers have settled.
+            connection.execute(
+                "UPDATE deep_scan_runs SET error_message = ? WHERE scan_id = ? AND error_message IS NULL",
+                (error_message, scan_id),
+            )
     return deep_scan_result(connection, scan_id)
 
 
-def claim_deep_scan_dedup(
+def record_deep_scan_iteration(
     connection: sqlite3.Connection, args: argparse.Namespace
 ) -> dict[str, Any]:
+    """Commit the checkpoint and its input workers in one transaction, then return deep scan state.
+
+    Repeating the same iteration and inputs replays the saved result. Conflicting
+    checkpoint or input-worker IDs raise SystemExit.
+    """
     scan_id = require_uuid(args.scan_id, "scan-id")
-    worker_id = require_uuid(args.worker_id, "worker-id")
+    checkpoint_id = require_uuid(args.worker_id, "worker-id")
     input_ids = [require_uuid(value, "input-worker-id") for value in args.input_worker_id]
-    if len(set(input_ids)) != len(input_ids):
-        raise SystemExit("Dedup input worker IDs must be unique.")
     connection.execute("BEGIN IMMEDIATE")
     with connection:
-        run, scan = require_running_deep_scan(connection, scan_id)
+        run = require_deep_scan_run(connection, scan_id)
+        scan = dependencies().require_scan(connection, scan_id)
+        require_running_deep_scan(run, scan)
         require_current_coordinator(run, args)
-        prompt_path = deep_scan_path(scan, args.prompt_path, "Dedup prompt path", kind="file")
-        artifact_dir = deep_scan_path(
-            scan, args.artifact_dir, "Dedup artifact directory", kind="directory"
-        )
+        result = deep_scan_path(scan, args.result_manifest_path, "Iteration result", kind="file")
         existing = connection.execute(
-            "SELECT * FROM deep_scan_workers WHERE id = ?", (worker_id,)
+            "SELECT scan_id, result_manifest_path FROM deep_scan_workers WHERE id = ?",
+            (checkpoint_id,),
         ).fetchone()
         if existing is not None:
-            persisted_inputs = [
-                row["discovery_worker_id"]
+            if existing["scan_id"] != scan_id or existing["result_manifest_path"] != result:
+                raise SystemExit("Iteration already belongs to another result.")
+            recorded_ids = [
+                row[0]
                 for row in connection.execute(
-                    """
-                    SELECT discovery_worker_id
-                    FROM deep_scan_dedup_inputs
-                    WHERE dedup_worker_id = ?
-                    ORDER BY input_order
-                    """,
-                    (worker_id,),
+                    "SELECT discovery_worker_id FROM deep_scan_dedup_inputs WHERE dedup_worker_id = ? ORDER BY input_order",
+                    (checkpoint_id,),
                 )
             ]
-            if (
-                existing["scan_id"] == scan_id
-                and existing["kind"] == "dedup"
-                and existing["prompt_path"] == prompt_path
-                and existing["artifact_dir"] == artifact_dir
-                and persisted_inputs == input_ids
-            ):
-                connection.commit()
-                return deep_scan_result(connection, scan_id)
-            raise SystemExit("Dedup worker ID is already used by a different reducer claim.")
-        active_reducer = connection.execute(
-            """
-            SELECT 1 FROM deep_scan_workers
-            WHERE scan_id = ? AND kind = 'dedup' AND status IN ('queued', 'running')
-            """,
-            (scan_id,),
-        ).fetchone()
-        if active_reducer is not None:
-            raise SystemExit("Only one Deep Scan dedup worker can run at a time.")
-        buffered_ids = [
-            row["id"]
-            for row in connection.execute(
-                """
-                SELECT id FROM deep_scan_workers
-                WHERE scan_id = ? AND kind = 'discovery'
-                    AND status = 'succeeded' AND merge_state = 'buffered'
-                ORDER BY completion_sequence
-                """,
-                (scan_id,),
-            )
-        ]
-        if input_ids != buffered_ids[: len(input_ids)]:
-            raise SystemExit(
-                "A Deep Scan dedup worker must claim an ordered prefix of buffered discovery "
-                "results in completion order."
-            )
-        capped_singleton = (
-            len(input_ids) == 1
-            and (
-                run["discovery_runs_dispatched"] >= run["max_discovery_runs"]
-                or deep_scan_deadline_reached(run)
-            )
-            and connection.execute(
-                """
-                SELECT 1 FROM deep_scan_workers
-                WHERE scan_id = ? AND kind = 'discovery' AND status IN ('queued', 'running')
-                LIMIT 1
-                """,
-                (scan_id,),
-            ).fetchone()
-            is None
-        )
-        successful_reducer = connection.execute(
-            """
-            SELECT 1 FROM deep_scan_workers
-            WHERE scan_id = ? AND kind = 'dedup' AND status = 'succeeded'
-            LIMIT 1
-            """,
-            (scan_id,),
-        ).fetchone()
-        minimum_inputs = 1 if successful_reducer is not None or capped_singleton else 2
-        if len(input_ids) < minimum_inputs:
-            raise SystemExit(
-                "The first Deep Scan dedup requires two buffered discovery results."
-                if minimum_inputs == 2
-                else "A Deep Scan dedup requires at least one buffered discovery result."
-            )
-        timestamp = dependencies().now()
-        connection.execute(
-            """
-            INSERT INTO deep_scan_workers (
-                id, scan_id, kind, status, prompt_path, artifact_dir,
-                created_at, updated_at
-            ) VALUES (?, ?, 'dedup', 'queued', ?, ?, ?, ?)
-            """,
-            (worker_id, scan_id, prompt_path, artifact_dir, timestamp, timestamp),
-        )
-        for input_order, input_id in enumerate(input_ids):
-            connection.execute(
-                """
-                INSERT INTO deep_scan_dedup_inputs (
-                    scan_id, dedup_worker_id, discovery_worker_id, input_order
-                ) VALUES (?, ?, ?, ?)
-                """,
-                (scan_id, worker_id, input_id, input_order),
-            )
-        connection.execute(
-            f"""
-            UPDATE deep_scan_workers
-            SET merge_state = 'merging', updated_at = ?
-            WHERE scan_id = ? AND id IN ({",".join("?" for _ in input_ids)})
-            """,
-            (timestamp, scan_id, *input_ids),
-        )
-        connection.execute(
-            "UPDATE deep_scan_runs SET phase = 'reducing', updated_at = ? WHERE scan_id = ?",
-            (timestamp, scan_id),
-        )
-        connection.execute(
-            """
-            UPDATE scan_progress
-            SET deep_review_pass = COALESCE(deep_review_pass, 0) + 1, updated_at = ?
-            WHERE scan_id = ?
-            """,
-            (timestamp, scan_id),
-        )
-    return deep_scan_result(connection, scan_id)
-
-
-def commit_deep_scan_dedup(
-    connection: sqlite3.Connection, args: argparse.Namespace
-) -> dict[str, Any]:
-    scan_id = require_uuid(args.scan_id, "scan-id")
-    with dependencies().scan_completion_lock(scan_id):
-        return commit_deep_scan_dedup_locked(connection, args, scan_id)
-
-
-def commit_deep_scan_dedup_locked(
-    connection: sqlite3.Connection, args: argparse.Namespace, scan_id: str
-) -> dict[str, Any]:
-    worker_id = require_uuid(args.worker_id, "worker-id")
-    promotion: tuple[Path, Path, Path | None] | None = None
-    publication_copy: Path | None = None
-    connection.execute("BEGIN IMMEDIATE")
-    try:
-        run = require_deep_scan_run(connection, scan_id)
-        require_current_coordinator(run, args)
-        scan = dependencies().require_scan(connection, scan_id)
-        worker = require_deep_scan_worker(connection, worker_id)
-        if worker["scan_id"] != scan_id or worker["kind"] != "dedup":
-            raise SystemExit("Dedup worker does not belong to this Deep Scan.")
-        if worker["status"] == "succeeded":
-            connection.commit()
+            if recorded_ids != input_ids:
+                raise SystemExit("Iteration already belongs to other completed scans.")
             return deep_scan_result(connection, scan_id)
-        require_running_deep_scan(connection, scan_id)
-        if worker["status"] not in {"queued", "running"}:
-            raise SystemExit("Only an active dedup worker can commit a result.")
-        if args.candidate_ledger_path:
-            candidate_ledger_path = deep_scan_path(
-                scan,
-                args.candidate_ledger_path,
-                "Staged candidate ledger path",
-                kind="file",
-            )
-            discovery_dir = Path(scan["scan_dir"]) / "artifacts" / "02_discovery"
-            deep_scan_path(
-                scan,
-                str(discovery_dir / "in_scope_files.txt"),
-                "Canonical in-scope inventory path",
-                kind="file",
-            )
-            canonical_candidate_ledger_path = deep_scan_output_path(
-                scan,
-                str(discovery_dir / "candidate_ledger.jsonl"),
-                "Canonical candidate ledger path",
+        now = dependencies().now()
+        # Historical scans use the same rows to bind the selected aggregate at publication.
+        connection.execute(
+            """INSERT INTO deep_scan_workers
+               (id, scan_id, kind, status, prompt_path, artifact_dir, result_manifest_path,
+                created_at, completed_at, updated_at)
+               VALUES (?, ?, 'dedup', 'succeeded', ?, ?, ?, ?, ?, ?)""",
+            (checkpoint_id, scan_id, result, str(Path(result).parent), result, now, now, now),
+        )
+        for index, worker_id in enumerate(input_ids):
+            updated = connection.execute(
+                """UPDATE deep_scan_workers SET merge_state = 'merged', updated_at = ?
+                   WHERE scan_id = ? AND id = ? AND kind = 'discovery'
+                   AND status = 'succeeded' AND merge_state = 'buffered'""",
+                (now, scan_id, worker_id),
             )
-        else:
-            candidate_ledger_path = None
-            canonical_candidate_ledger_path = None
-        result_manifest_path = deep_scan_path(
-            scan,
-            args.result_manifest_path,
-            "Dedup result manifest path",
-            kind="file",
-        )
-        inputs = list(
+            if updated.rowcount != 1:
+                raise SystemExit("Iteration input is not an unmerged completed scan.")
             connection.execute(
-                """
-                SELECT workers.*
-                FROM deep_scan_dedup_inputs AS inputs
-                JOIN deep_scan_workers AS workers ON workers.id = inputs.discovery_worker_id
-                WHERE inputs.dedup_worker_id = ?
-                ORDER BY inputs.input_order
-                """,
-                (worker_id,),
+                "INSERT INTO deep_scan_dedup_inputs VALUES (?, ?, ?, ?)",
+                (scan_id, checkpoint_id, worker_id, index),
             )
-        )
-        if not inputs or any(row["merge_state"] != "merging" for row in inputs):
-            raise SystemExit("Dedup inputs are not in the claimed merging state.")
-        if candidate_ledger_path and canonical_candidate_ledger_path:
-            canonical_path = Path(canonical_candidate_ledger_path)
-            publication_copy = canonical_path.with_name(
-                f".{canonical_path.name}.{uuid.uuid4()}.publish"
-            )
-            create_publication_copy(candidate_ledger_path, publication_copy)
-            promotion = promote_staged_file(
-                str(publication_copy),
-                canonical_candidate_ledger_path,
-            )
-        timestamp = dependencies().now()
-        connection.execute(
-            """
-            UPDATE deep_scan_workers
-            SET merge_state = 'merged', updated_at = ?
-            WHERE id IN (
-                SELECT discovery_worker_id FROM deep_scan_dedup_inputs
-                WHERE dedup_worker_id = ?
-            )
-            """,
-            (timestamp, worker_id),
-        )
         connection.execute(
-            """
-            UPDATE deep_scan_workers
-            SET status = 'succeeded', result_manifest_path = ?,
-                error_message = NULL, started_at = COALESCE(started_at, ?),
-                completed_at = ?, updated_at = ?
-            WHERE id = ?
-            """,
-            (result_manifest_path, timestamp, timestamp, timestamp, worker_id),
-        )
-        no_new_streak = (
-            0 if args.new_findings_count > 0 else run["consecutive_no_new"] + len(inputs)
+            "UPDATE deep_scan_runs SET phase = 'discovery', consecutive_no_new = ?, consecutive_errors = ?, updated_at = ? WHERE scan_id = ?",
+            (args.no_new_streak, args.consecutive_errors, now, scan_id),
         )
         connection.execute(
-            """
-            UPDATE deep_scan_runs
-            SET phase = 'discovery', consecutive_no_new = ?, updated_at = ?
-            WHERE scan_id = ?
-            """,
-            (no_new_streak, timestamp, scan_id),
+            "UPDATE scan_progress SET deep_review_pass = COALESCE(deep_review_pass, 0) + 1, updated_at = ? WHERE scan_id = ?",
+            (now, scan_id),
         )
-        connection.commit()
-    except BaseException:
-        connection.rollback()
-        if promotion is not None:
-            rollback_staged_file(promotion)
-        if publication_copy is not None:
-            publication_copy.unlink(missing_ok=True)
-        raise
-    if promotion is not None:
-        finish_staged_file(promotion)
-    if publication_copy is not None:
-        publication_copy.unlink(missing_ok=True)
     return deep_scan_result(connection, scan_id)
 
 
@@ -1579,12 +1472,15 @@
 def finish_deep_scan_locked(
     connection: sqlite3.Connection, args: argparse.Namespace, scan_id: str
 ) -> dict[str, Any]:
-    omitted_worker_ids = [
+    omitted_worker_ids = {
         require_uuid(value, "omitted-worker-id") for value in args.omitted_worker_id
-    ]
-    if len(set(omitted_worker_ids)) != len(omitted_worker_ids):
+    }
+    if len(omitted_worker_ids) != len(args.omitted_worker_id):
         raise SystemExit("Omitted Deep Scan worker IDs must be unique.")
     promotion: tuple[Path, Path, Path | None] | None = None
+    deadline_publication: (
+        tuple[Path, dict[str, tuple[bytes, os.stat_result] | None], set[str]] | None
+    ) = None
     connection.execute("BEGIN IMMEDIATE")
     try:
         run = require_deep_scan_run(connection, scan_id)
@@ -1599,85 +1495,23 @@
         )
         standard_scan_manifest = manifest_path == str(Path(scan["scan_dir"]) / "scan-manifest.json")
 
-        failure_capped = False
-        if (
-            standard_scan_manifest
-            and args.terminal_reason == "capped"
-            and (run["status"] == "running" or omitted_worker_ids)
-        ):
-            for artifact_name in ("scan-manifest.json", "findings.json", "coverage.json"):
-                deep_scan_path(
-                    scan,
-                    str(Path(scan["scan_dir"]) / artifact_name),
-                    f"Canonical parent {artifact_name}",
-                    kind="file",
-                )
-            coverage = _read_scan_local_json(
-                Path(scan["scan_dir"]), "coverage.json", "Canonical parent coverage.json"
-            )
-            deferred = coverage.get("deferred")
-            failure_capped = (
-                coverage.get("completeness") == "partial"
-                and isinstance(deferred, list)
-                and any(
-                    isinstance(item, dict)
-                    and isinstance(item.get("reason"), str)
-                    and item["reason"].startswith("Deep Scan stopped before completion: ")
-                    for item in deferred
-                )
-                and connection.execute(
-                    """
-                    SELECT 1 FROM deep_scan_workers
-                    WHERE scan_id = ? AND kind = 'dedup' AND status = 'succeeded'
-                    LIMIT 1
-                    """,
-                    (scan_id,),
-                ).fetchone()
-                is not None
-            )
-            if failure_capped and run["status"] == "running":
-                require_running_deep_scan(connection, scan_id)
-                connection.execute(
-                    """
-                    UPDATE deep_scan_workers
-                    SET merge_state = 'buffered', updated_at = ?
-                    WHERE scan_id = ? AND kind = 'discovery' AND status = 'succeeded'
-                        AND merge_state = 'merging'
-                        AND id IN (
-                            SELECT inputs.discovery_worker_id
-                            FROM deep_scan_dedup_inputs AS inputs
-                            JOIN deep_scan_workers AS reducers
-                                ON reducers.id = inputs.dedup_worker_id
-                                AND reducers.scan_id = inputs.scan_id
-                            WHERE inputs.scan_id = ?
-                                AND reducers.kind = 'dedup'
-                                AND reducers.status IN ('failed', 'canceled')
-                        )
-                    """,
-                    (dependencies().now(), scan_id, scan_id),
-                )
-        buffered_worker_ids = [
+        buffered_worker_ids = {
             row["id"]
             for row in connection.execute(
                 """
                 SELECT id
                 FROM deep_scan_workers
                 WHERE scan_id = ? AND kind = 'discovery' AND merge_state = 'buffered'
-                ORDER BY completion_sequence, id
                 """,
                 (scan_id,),
             )
-        ]
-        omissions_match = (
-            set(omitted_worker_ids) == set(buffered_worker_ids)
-            if args.terminal_reason == "saturated" or failure_capped
-            else not omitted_worker_ids and not buffered_worker_ids
-        )
+        }
         if run["status"] == "succeeded":
             if (
                 run["terminal_reason"] != args.terminal_reason
-                or run["manifest_path"] not in {None, manifest_path}
-                or not omissions_match
+                or archived_deep_path(Path(scan["scan_dir"]), run["manifest_path"])
+                not in {None, manifest_path}
+                or omitted_worker_ids != buffered_worker_ids
             ):
                 raise SystemExit(
                     "Deep Scan terminal state is immutable; finish must exactly replay its "
@@ -1690,7 +1524,9 @@
                 )
             connection.commit()
             return deep_scan_result(connection, scan_id)
-        require_running_deep_scan(connection, scan_id)
+        require_running_deep_scan(run, scan)
+        if run["error_message"] is not None:
+            raise SystemExit(run["error_message"])
         if (
             args.terminal_reason == "saturated"
             and run["consecutive_no_new"] < run["stop_after_no_new"]
@@ -1702,14 +1538,13 @@
             args.terminal_reason == "capped"
             and run["discovery_runs_dispatched"] < run["max_discovery_runs"]
             and not deep_scan_deadline_reached(run)
-            and not failure_capped
         ):
             raise SystemExit(
                 "Deep Scan cannot finish capped before reaching its configured maximum."
             )
         canonical_artifacts = None
         if standard_scan_manifest:
-            for artifact_name in ("scan-manifest.json", "findings.json", "coverage.json"):
+            for artifact_name in ("scan-manifest.json", "findings.json"):
                 deep_scan_path(
                     scan,
                     str(Path(scan["scan_dir"]) / artifact_name),
@@ -1723,7 +1558,7 @@
                 raise SystemExit(
                     f"Deep Scan cannot finish without canonical discovery artifacts: {exc}"
                 ) from exc
-        successful_reducer = connection.execute(
+        saved_iteration = connection.execute(
             """
             SELECT 1 FROM deep_scan_workers
             WHERE scan_id = ? AND kind = 'dedup' AND status = 'succeeded'
@@ -1731,9 +1566,9 @@
             """,
             (scan_id,),
         ).fetchone()
+        discovery_deadline = args.terminal_reason == "capped" and deep_scan_deadline_reached(run)
         zero_discovery_deadline = (
-            args.terminal_reason == "capped"
-            and deep_scan_deadline_reached(run)
+            discovery_deadline
             and run["completion_sequence"] == 0
             and (
                 standard_scan_manifest
@@ -1741,73 +1576,18 @@
                 and Path(canonical_artifacts["candidateLedgerPath"]).stat().st_size == 0
             )
         )
-        if successful_reducer is None and not zero_discovery_deadline:
-            raise SystemExit("Deep Scan cannot finish without a successful dedup worker.")
-        failed_worker = connection.execute(
-            """
-            SELECT 1 FROM deep_scan_workers AS failed
-            WHERE failed.scan_id = ? AND failed.status = 'failed'
-                AND (? != 'saturated' OR failed.kind != 'discovery')
-                AND (
-                    failed.kind != 'dedup'
-                    OR NOT EXISTS (
-                        SELECT 1 FROM deep_scan_dedup_inputs AS failed_inputs
-                        WHERE failed_inputs.dedup_worker_id = failed.id
-                    )
-                    OR EXISTS (
-                        SELECT 1 FROM deep_scan_dedup_inputs AS failed_inputs
-                        WHERE failed_inputs.dedup_worker_id = failed.id
-                            AND NOT EXISTS (
-                                SELECT 1
-                                FROM deep_scan_dedup_inputs AS replacement_inputs
-                                JOIN deep_scan_workers AS replacement
-                                    ON replacement.scan_id = replacement_inputs.scan_id
-                                    AND replacement.id = replacement_inputs.dedup_worker_id
-                                WHERE replacement_inputs.scan_id = failed.scan_id
-                                    AND replacement_inputs.discovery_worker_id =
-                                        failed_inputs.discovery_worker_id
-                                    AND replacement.kind = 'dedup'
-                                    AND replacement.status = 'succeeded'
-                            )
-                    )
-                )
-            LIMIT 1
-            """,
-            (scan_id, args.terminal_reason),
-        ).fetchone()
-        if failed_worker is not None and not failure_capped:
-            raise SystemExit("Deep Scan cannot finish after a worker has failed.")
+        if saved_iteration is None and not zero_discovery_deadline:
+            raise SystemExit("Deep Scan cannot finish without a saved iteration.")
         if args.terminal_reason == "saturated":
-            # Mark any remaining workers canceled, including those whose own
-            # cancellation writes failed, so they cannot block completion.
+            # Saturation cancels surplus workers, including failed cancellation writes.
             cancel_active_workers(connection, scan_id, dependencies().now())
-        active_worker = connection.execute(
-            """
-            SELECT 1 FROM deep_scan_workers
-            WHERE scan_id = ? AND status IN ('queued', 'running')
-            LIMIT 1
-            """,
-            (scan_id,),
-        ).fetchone()
-        if active_worker is not None:
-            raise SystemExit("Deep Scan cannot finish while workers are active.")
-        merging_worker = connection.execute(
-            """
-            SELECT 1 FROM deep_scan_workers
-            WHERE scan_id = ? AND merge_state = 'merging'
-            LIMIT 1
-            """,
-            (scan_id,),
-        ).fetchone()
-        if merging_worker is not None:
-            raise SystemExit("Deep Scan cannot finish while discovery output is merging.")
-        if args.terminal_reason == "capped" and omitted_worker_ids and not failure_capped:
-            raise SystemExit("Deep Scan capped completion cannot declare omitted buffered workers.")
-        if args.terminal_reason == "capped" and buffered_worker_ids and not failure_capped:
-            raise SystemExit(
-                "Deep Scan cannot finish capped while discovery output remains buffered."
-            )
-        if (args.terminal_reason == "saturated" or failure_capped) and not omissions_match:
+        require_deep_scan_workers_finished(
+            connection,
+            scan_id,
+            args.terminal_reason,
+            has_omitted_workers=bool(omitted_worker_ids),
+        )
+        if args.terminal_reason == "saturated" and omitted_worker_ids != buffered_worker_ids:
             raise SystemExit(
                 f"Deep Scan {args.terminal_reason} completion must exactly identify all buffered discovery "
                 "workers with --omitted-worker-id."
@@ -1820,6 +1600,14 @@
                 kind="file",
             )
             promotion = promote_staged_file(staged_manifest_path, manifest_path)
+        if zero_discovery_deadline or (discovery_deadline and standard_scan_manifest):
+            deadline_publication = saved_results.preserve_deep_deadline_draft(
+                dependencies(),
+                connection,
+                scan,
+                preserve_reduction=not zero_discovery_deadline,
+                allow_empty=not standard_scan_manifest,
+            )
         timestamp = dependencies().now()
         connection.execute(
             """
@@ -1830,10 +1618,18 @@
             """,
             (args.terminal_reason, manifest_path, timestamp, timestamp, scan_id),
         )
-        cancel_active_workers(connection, scan_id, timestamp)
         connection.commit()
     except BaseException:
         connection.rollback()
+        if deadline_publication is not None or promotion is not None:
+            # A signal can arrive after SQLite commits but before commit returns.
+            # The completion lock makes persisted success authoritative here.
+            if require_deep_scan_run(connection, scan_id)["status"] == "succeeded":
+                if promotion is not None:
+                    finish_staged_file(promotion)
+                raise
+        if deadline_publication is not None:
+            saved_results._restore_published_outputs(*deadline_publication)
         if promotion is not None:
             rollback_staged_file(promotion)
         raise
@@ -1851,7 +1647,7 @@
 def fail_deep_scan_locked(
     connection: sqlite3.Connection, args: argparse.Namespace, scan_id: str
 ) -> dict[str, Any]:
-    message = optional_text(args.message, maximum=2400)
+    message = optional_text(args.message)
     if message is None:
         raise SystemExit("message is required.")
     promotion: tuple[Path, Path, Path | None] | None = None
@@ -1860,6 +1656,7 @@
         run = require_deep_scan_run(connection, scan_id)
         require_current_coordinator(run, args)
         scan = dependencies().require_scan(connection, scan_id)
+        recorded_manifest = archived_deep_path(Path(scan["scan_dir"]), run["manifest_path"])
         manifest_path = None
         if args.manifest_path:
             manifest_path = (
@@ -1872,12 +1669,14 @@
                     kind="file",
                 )
             )
+        elif recorded_manifest == str(Path(scan["scan_dir"]) / "scan-manifest.json"):
+            manifest_path = recorded_manifest
         if run["status"] in {"failed", "interrupted"} or scan["status"] == "failed":
             if (
                 run["status"] == args.deep_status
                 and scan["status"] == "failed"
                 and run["error_message"] == message
-                and run["manifest_path"] == manifest_path
+                and recorded_manifest == manifest_path
                 and scan["failure_message"] == message
             ):
                 connection.commit()
@@ -1896,6 +1695,9 @@
             "status"
         ] != "running":
             raise SystemExit("Only a running Deep Scan can be failed or interrupted.")
+        # Cleanup can report a later error after a worker committed the terminal cause.
+        if run["status"] == "running" and run["error_message"] is not None:
+            message = run["error_message"]
         if run["manifest_path"] not in {None, manifest_path}:
             raise SystemExit("Deep Scan coordinator manifest path is immutable.")
         if args.staged_manifest_path and manifest_path:
@@ -1917,20 +1719,9 @@
             (args.deep_status, message, manifest_path, timestamp, timestamp, scan_id),
         )
         cancel_active_workers(connection, scan_id, timestamp)
-        parent_update = connection.execute(
-            """
-            UPDATE scans
-            SET status = 'failed', failure_message = ?, completed_at = ?, updated_at = ?
-            WHERE id = ? AND status = 'running'
-            """,
-            (message, timestamp, timestamp, scan_id),
-        )
-        if parent_update.rowcount != 1:
+        if not saved_results.mark_running_scan_failed(connection, scan_id, message, timestamp):
             raise SystemExit("Deep Scan failure could not be persisted to its parent scan.")
-        connection.execute(
-            "UPDATE scan_progress SET updated_at = ? WHERE scan_id = ?",
-            (timestamp, scan_id),
-        )
+        saved_results.touch_scan_progress(connection, scan_id, timestamp)
         connection.commit()
     except BaseException:
         connection.rollback()
@@ -1947,7 +1738,7 @@
     connection: sqlite3.Connection, args: argparse.Namespace
 ) -> dict[str, Any]:
     scan_id = require_uuid(args.scan_id, "scan-id")
-    message = optional_text(args.message, maximum=2400)
+    message = optional_text(args.message)
     if message is None:
         raise SystemExit("message is required.")
     with dependencies().scan_completion_lock(scan_id):
@@ -1994,6 +1785,11 @@
     message: str | None,
     timestamp: str,
 ) -> None:
+    # Parent failure may supersede a prepared seal even after the coordinator succeeded.
+    connection.execute(
+        "UPDATE deep_scan_runs SET terminal_reviewed_surface_count = NULL WHERE scan_id = ?",
+        (scan_id,),
+    )
     connection.execute(
         """
         UPDATE deep_scan_runs
@@ -2010,8 +1806,8 @@
     connection.execute(
         """
         UPDATE deep_scan_runs
-        SET status = 'canceled', phase = 'terminal', cancel_requested = 1,
-            completed_at = ?, updated_at = ?
+        SET status = 'canceled', phase = 'terminal', cancel_requested = 1, error_message = NULL,
+            terminal_reviewed_surface_count = NULL, completed_at = ?, updated_at = ?
         WHERE scan_id = ? AND status IN ('running', 'succeeded')
         """,
         (timestamp, timestamp, scan_id),
@@ -2033,6 +1829,7 @@
 def other_running_deep_scans(
     connection: sqlite3.Connection, current_scan_id: str
 ) -> list[dict[str, str]]:
+    """List other running Deep Scans ordered by most recent update, with target paths and phases."""
     rows = connection.execute(
         """
         SELECT id, target_path, phase, started_at, updated_at
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