← Codex SecurityCONTENT HISTORY

Update to Codex Security

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

WHAT CHANGED

Package or technical metadata updated

Package or technical metadata updated

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

Save Codex Security and check future changes in Following.

Up to 3 plugins free · no card required.

All fields and original values.

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

Package file

Before

Oct 7, 2026 · 06:02 UTC

527d1a0db286884729572d400b0ad9b0ff852d4a12b36228ff5fbef180f7de9d

After

Nov 18, 2026 · 06:12 UTC

3766646eafb09a5e691657999f4f423c9652bbac286c0e0f55e179169aa97e99

Package file

Before

Oct 7, 2026 · 06:02 UTC

1582

After

Nov 18, 2026 · 06:12 UTC

1846

Package file

Before

Oct 7, 2026 · 06:02 UTC

7c5968060f6e848859ce02450d6e02e67029d8d39011bbda1059b19de6309ebf

After

Nov 18, 2026 · 06:12 UTC

69bbc0f86c92397eb7540ff09c17d69d429b0dc45dc1de3e02b16d101adfe7c0

Package file

Before

Oct 7, 2026 · 06:02 UTC

1679

After

Nov 18, 2026 · 06:12 UTC

2078

Compare saved observations

Download comparison JSON

Changed files

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

.codex-plugin/plugin.json →

.mcp.json →

examples/completed-scan/coverage.json →

examples/completed-scan/findings.json →

examples/completed-scan/report.md →

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

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

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

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

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

integrity.json →

mcp/fzstd-LICENSE.txt →

mcp/helpers.mjs →

mcp/helpers.mjs.br →

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

mcp/native/THIRD_PARTY_NOTICES.txt →

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

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

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

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

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

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

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

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

mcp/package.json →

mcp/permission-profile-preflight.mjs →

mcp/server.mjs →

mcp/server.mjs.br →

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

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

mcp/session-decompression.mjs →

preflight/capability-profiles.toml →

references/access-advisory.md →

references/artifact-storage.md →

references/baseline-auditor.md →

references/config-preflight.md →

references/core-scan.md →

references/default-severity-rubric.md →

references/desktop-config-preflight.md →

references/final-report.md →

references/finding-detail-fields.md →

references/focused-investigator.md →

references/investigation-time-budget.md →

references/sarif-adapter.md →

references/scan-artifacts.md →

references/scan-contract.md →

references/scan-prologue.md →

references/scan-runtime.md →

references/security-guidance.md →

references/standalone-validation.md →

references/threat-model.md →

references/validate-scan-findings.md →

schemas/coverage.schema.json →

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

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

schemas/findings.schema.json →

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

schemas/scan-manifest.schema.json →

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

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

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

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

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

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

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

scripts/check_deep_scan_target.py →

scripts/codex_profile.mjs →

scripts/codex_session.mjs →

scripts/config_preflight.py →

scripts/deep_scan_config.py →

scripts/deep_scan_workbench.py →

scripts/dispatch_inventory_tool →

scripts/filesystem_identity.py →

scripts/finalize_scan_contract.py →

scripts/finding_preview.py →

scripts/generate_in_scope_files.py →

scripts/generate_rank_input.py →

scripts/launch_codex_security_mcp →

scripts/launch_codex_security_mcp.cmd →

scripts/legacy_findings.py →

scripts/posix_scan_local_files.py →

scripts/rank_preview.py →

scripts/read_codex_session.mjs →

scripts/report_projection.py →

scripts/review_state.py →

scripts/servicenow_avit.py →

scripts/snapshot_sqlite.py →

scripts/threat_model_projection.py →

scripts/validate_scan_contract.py →

scripts/validate_tracking_source.py →

scripts/windows_scan_local_files.py →

scripts/workbench/__init__.py →

scripts/workbench/handoff.py →

scripts/workbench/retained_coverage.py →

scripts/workbench/retained_records.py →

scripts/workbench/runtime_toml.py →

scripts/workbench/saved_coverage.py →

scripts/workbench/saved_outputs.py →

scripts/workbench/saved_sources.py →

scripts/workbench/storage.py →

scripts/workbench_cli.py →

scripts/workbench_constants.py →

scripts/workbench_coverage_receipts.py →

scripts/workbench_dashboard.py →

scripts/workbench_db.py →

scripts/workbench_feedback.py →

scripts/workbench_finding_index.py →

scripts/workbench_finding_workflows.py →

scripts/workbench_findings.py →

scripts/workbench_native_indexes.py →

scripts/workbench_progress.py →

scripts/workbench_publication.py →

scripts/workbench_remediation.py →

scripts/workbench_saved_results.py →

scripts/workbench_scan_history.py →

scripts/workbench_scan_start.py →

scripts/workbench_scan_usage.py →

scripts/workbench_schema.py →

scripts/workbench_setup.py →

scripts/workbench_severity.py →

scripts/workbench_source_excerpt.py →

scripts/workbench_source_scopes.py →

scripts/workbench_target.py →

scripts/workbench_target_state.py →

scripts/workbench_validation.py →

shared/workbench-history-repairs.json →

shared/workbench-migrations.json →

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

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

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

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

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

skills/check-skills/SKILL.md →

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

skills/cloud-findings/SKILL.md →

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

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

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

skills/finding-discovery/SKILL.md →

skills/fix-finding/SKILL.md →

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

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

skills/publish-findings/SKILL.md →

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

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

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

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

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

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

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

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

skills/security-scan/SKILL.md →

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

skills/threat-model/SKILL.md →

skills/track-findings/SKILL.md →

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

skills/triage-finding/SKILL.md →

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

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

skills/validation/SKILL.md →

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

skills/verify-fix/SKILL.md →

skills/vulnerability-writeup/SKILL.md →

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

scripts/workbench_db.py

− removed · + added

--- before
+++ after
@@ -16,8 +16,10 @@
 import tempfile
 import time
 import uuid
-from contextlib import closing, contextmanager, nullcontext
+from collections.abc import Callable
+from contextlib import ExitStack, closing, contextmanager, nullcontext
 from datetime import datetime, timedelta, timezone
+from functools import partial
 from pathlib import Path, PurePosixPath
 from types import SimpleNamespace
 from typing import Any
@@ -37,17 +39,10 @@
 import workbench_native_indexes as native_indexes
 import workbench_progress as progress
 import workbench_publication as publication
-import workbench_remediation as remediation
+import workbench_remediation as remediation_state
 import workbench_saved_results as saved_results
 import workbench_scan_history as scan_history
 import workbench_scan_usage as scan_usage
-import workbench_severity as severity
-from filesystem_identity import (
-    serialize_filesystem_identity as serialize_filesystem_identity,
-)
-from filesystem_identity import (
-    stored_filesystem_identity_matches as stored_filesystem_identity_matches,
-)
 from finalize_scan_contract import (
     PRODUCER_NAME,
     ContractError,
@@ -55,94 +50,117 @@
     _prepare_scan_finalization,
     _write_prepared_scan_finalization,
     finalize_scan,
-    finding_candidate_id,
+    manifest_is_sealed,
     open_scan_local_file_descriptor,
-    write_scan_local_bytes,
 )
 from finding_preview import bounded_finding_details
+from windows_scan_local_files import pin_replay_metadata
 from workbench import handoff
-from workbench.storage import create_private_directory, resolve_scan_root, state_dir
+from workbench.storage import (
+    create_private_directory,
+    resolve_scan_root,
+    saved_deep_workers,
+    state_dir,
+)
 from workbench_cli import parse_args
 from workbench_constants import (
     ARTIFACTS,
     CLAIM_LEASE_SECONDS,
     DELIVERED_ACTION_LEASE_SECONDS,
-    DIFF_TARGET_KINDS,
-    EMPTY_GIT_TREE,
     FINDING_ABSOLUTE_PATH_BYTES,
     FINDING_LEVEL_BYTES,
+    FINDING_LOCATION_ORDER_SQL,
     FINDING_LOCATION_PATH_BYTES,
     FINDING_LOCATION_ROLE_BYTES,
     FINDING_LOCATIONS_LIMIT,
     FINDING_REMEDIATION_BYTES,
     FINDING_SUMMARY_BYTES,
     FINDING_TITLE_BYTES,
-    FINDINGS_PAGE_MAX,
     FINDINGS_RESULT_LIMIT,
-    PATCH_PREVIEW_BYTES,
     SQLITE_RETRY_ATTEMPTS,
 )
-from workbench_dashboard import dashboard
 from workbench_feedback import get_scan_feedback
 from workbench_finding_index import index_findings
 from workbench_finding_workflows import finding_workflow, register_workflow_scan
-from workbench_findings import (
-    find_potential_duplicates,
-    list_dedupe_groups,
-    list_stored_findings,
-    store_dedupe_groups,
-    store_findings,
-)
-from workbench_remediation import remediation_claim_is_active
 from workbench_scan_start import (
     archive_scan,
     insert_running_scan,
+    loaded_plugin_version,
+    prepare_cli_scan_target,
+    register_windows_resume_output,
+    restore_cli_scan_archive,
     safe_segment,
     scan_diff_identity,
     scan_target_identity,
     stored_diff_target,
 )
-from workbench_scan_start import (
-    compact_timestamp as compact_timestamp,
-)
 from workbench_schema import (
     MIGRATIONS,
+    migration_target_paths,
+    recorded_git_checkout_roots,
 )
 from workbench_schema import (
     apply_migrations as apply_schema_migrations,
 )
-from workbench_schema import (
-    sql_statements as sql_statements,
+from workbench_setup import (
+    inspect_command,
+    inspect_selected_setup,
+    inspect_setup_values,
+    require_diff_target,
+    require_review_changes_target,
+    require_scannable_target,
+    require_scope,
+    require_target,
+    resolve_git_commit,
+)
+from workbench_source_excerpt import finding_source_excerpt
+from workbench_source_scopes import (
+    capture_source_scopes,
+    expected_target_kinds,
+    public_scan_recipe,
+    requested_scan_paths,
+    safe_source_path,
 )
-from workbench_source_excerpt import finding_source_excerpt, safe_source_path
 from workbench_target import (
+    checked_scan_target,
     clean_worktree_content_digest,
     copy_directory_excluding,
     copy_git_worktree_files,
+    diff_scope_file_count,
     diff_snapshot_digest,
     directory_content_digest,
     directory_snapshot_regular_file_count,
-    git_bytes,
     git_command,
     git_output,
     git_revision,
     git_submodule_entries,
     git_target_metadata,
     git_worktree_context,
+    rejected_checkout_roots,
     remediation_checkout_snapshot,
-    require_git_worktree_head,
     require_remediation_target,
     require_scan_target_identity,
+    require_scan_target_unchanged,
+    restore_directory_junctions,
     scan_target_warning,
+    scoped_git_discovery,
+    scoped_regular_file_count,
     worktree_content_digest,
     worktree_content_digest_for_context,
 )
-from workbench_target_state import backfill_security_targets, ensure_security_target
+from workbench_target_state import (
+    RepositoryScanScope,
+    backfill_security_targets,
+    ensure_security_target,
+    register_security_target,
+    require_scan_checkout_owner,
+)
 from workbench_validation import (
     bounded_output_text,
     optional_text,
     parse_scan_cost,
     path_within_scope,
+    read_json_object,
     reject_non_finite_json,
     require_close_note,
     require_occurrence,
@@ -172,6 +190,7 @@
 
 @contextmanager
 def scan_completion_lock(scan_id: str) -> Any:
+    """Hold the cross-process lock for a scan ID until the context exits."""
     lock_dir = state_dir() / "completion-locks"
     create_private_directory(lock_dir)
     lock_path = lock_dir / f"{require_uuid(scan_id, 'scan-id')}.lock"
@@ -234,214 +253,112 @@
     windows_file_lock.locking(descriptor, windows_file_lock.LK_UNLCK, 1)
 
 
-def connect(*, deferred: bool = False) -> sqlite3.Connection:
+def connect(
+    *,
+    deferred: bool = False,
+    discovery_roots: tuple[Path, ...] = (),
+    in_memory: bool = False,
+) -> sqlite3.Connection:
+    """Open the workbench SQLite database and bring its schema up to date.
+
+    Args:
+        deferred (bool): Let the first migration attempt defer its write lock.
+            Retries after lock contention use an immediate transaction.
+
+        discovery_roots: Additional local paths for bounded target discovery.
+        in_memory: Keep a fresh profile read entirely in memory.
+
+    Returns:
+        sqlite3.Connection: A caller-owned connection with named rows, foreign
+            keys enabled, and write-ahead logging.
+
+    Raises:
+        sqlite3.OperationalError: Opening or configuring the database fails, or
+            lock contention persists after retries.
+    """
     path = database_path()
-    create_private_directory(path.parent)
+    guidance = (
+        f"Workbench database: {path}. Ensure the state directory and SQLite journal files "
+        "are writable, or set CODEX_SECURITY_STATE_DIR to a writable directory outside "
+        "the scanned repository."
+    )
+    try:
+        if not in_memory:
+            create_private_directory(path.parent)
+    except OSError:
+        print(guidance, file=sys.stderr)
+        raise
     for attempt in range(SQLITE_RETRY_ATTEMPTS):
-        connection = sqlite3.connect(path, timeout=5)
+        try:
+            connection = sqlite3.connect(":memory:" if in_memory else path, timeout=5)
+        except sqlite3.OperationalError:
+            print(guidance, file=sys.stderr)
+            raise
         try:
             connection.row_factory = sqlite3.Row
             connection.execute("PRAGMA foreign_keys = ON")
             connection.execute("PRAGMA busy_timeout = 5000")
             # Keep writer admission retries; readers only wait when a repair needs to write.
-            apply_migrations(connection, immediate=not deferred or attempt > 0)
+            apply_migrations(
+                connection, immediate=not deferred or attempt > 0, discovery_roots=discovery_roots
+            )
             connection.execute("PRAGMA journal_mode = WAL")
-            path.chmod(0o600)
+            if not in_memory:
+                path.chmod(0o600)
             return connection
         except sqlite3.OperationalError as exc:
             connection.close()
             if attempt == SQLITE_RETRY_ATTEMPTS - 1 or not sqlite_busy(exc):
+                print(guidance, file=sys.stderr)
                 raise
             time.sleep(0.05 * (2**attempt))
     raise AssertionError("SQLite retry loop exhausted unexpectedly.")
 
 
-def apply_migrations(connection: sqlite3.Connection, *, immediate: bool = False) -> None:
-    apply_schema_migrations(
-        connection, MIGRATIONS, now, backfill_security_targets, immediate=immediate
-    )
-
-
-def require_target(value: str) -> Path:
-    expanded = Path(value).expanduser()
-    if not expanded.is_absolute():
-        raise SystemExit("Scan target must be an absolute local directory path.")
-    target = expanded.resolve()
-    if not target.is_dir():
-        raise SystemExit(f"Scan target is not a readable local directory: {target}")
-    return target
-
-
-def inspect_target(target_path: str) -> dict[str, Any]:
-    target = require_target(target_path)
-    return {
-        "displayName": target.name,
-        "targetMetadata": git_target_metadata(target),
-        "targetPath": str(target),
-    }
-
-
-def resolve_git_commit(target: Path, revision: str, label: str) -> str:
-    value = optional_text(revision, maximum=512)
-    if not value:
-        raise SystemExit(f"{label} is required.")
-    resolved = git_output(
-        target,
-        "rev-parse",
-        "--verify",
-        "--end-of-options",
-        f"{value}^{{commit}}",
-    )
-    if resolved is None:
-        raise SystemExit(f"{label} does not resolve to a local Git commit: {value}")
-    return resolved
+def begin_immediate_with_retry(connection: sqlite3.Connection) -> None:
+    for attempt in range(SQLITE_RETRY_ATTEMPTS):
+        try:
+            connection.execute("BEGIN IMMEDIATE")
+            return
+        except sqlite3.OperationalError as exc:
+            if attempt == SQLITE_RETRY_ATTEMPTS - 1 or not sqlite_busy(exc):
+                raise
+            time.sleep(0.05 * (2**attempt))
 
 
-def require_diff_target(
-    target: Path,
-    kind: str | None,
-    base_revision: str | None,
-    head_revision: str | None,
-    content_digest: str | None,
-) -> dict[str, str]:
-    current_head = require_review_changes_target(target)
-    if kind not in DIFF_TARGET_KINDS:
-        raise SystemExit("Choose which Git changes to review before starting a diff scan.")
-    if kind == "working_tree":
-        base = resolve_git_commit(target, base_revision or "HEAD", "Working-tree base")
-        head = resolve_git_commit(target, head_revision or current_head, "Working-tree HEAD")
-        current_digest = worktree_content_digest(target)
-        if base != current_head or head != current_head:
-            raise SystemExit(
-                "Repository HEAD changed after these working-tree changes were selected. "
-                "Select Uncommitted changes again."
-            )
-        if content_digest and content_digest != current_digest:
-            raise SystemExit(
-                "Working-tree contents changed after they were selected. "
-                "Select Uncommitted changes again."
-            )
-        return {
-            "kind": kind,
-            "baseRevision": current_head,
-            "headRevision": current_head,
-            "contentDigest": current_digest,
-        }
-    if kind == "commit":
-        head = resolve_git_commit(target, head_revision or "", "Commit")
-        commit = git_bytes(target, "cat-file", "-p", head)
-        if commit is None:
-            raise SystemExit(f"Commit is not available in the local checkout: {head}")
-        parent_line = next(
-            (line for line in commit.splitlines() if line.startswith(b"parent ")),
-            None,
-        )
-        if parent_line is None:
-            parent = EMPTY_GIT_TREE
-        else:
-            parent = resolve_git_commit(
-                target,
-                parent_line.removeprefix(b"parent ").decode("ascii").strip(),
-                "Commit parent",
-            )
-        if base_revision and base_revision != parent:
-            supplied_base = (
-                base_revision
-                if base_revision == EMPTY_GIT_TREE
-                else resolve_git_commit(target, base_revision, "Commit base")
-            )
-            if supplied_base != parent:
-                raise SystemExit("Commit base revision must match the selected commit's parent.")
-        return {"kind": kind, "baseRevision": parent, "headRevision": head}
-    base = resolve_git_commit(target, base_revision or "", "Base revision")
-    head = resolve_git_commit(target, head_revision or "", "Head revision")
-    if base == head:
-        raise SystemExit("Base and head revisions must identify different commits.")
-    return {"kind": kind, "baseRevision": base, "headRevision": head}
-
-
-def inspect_setup_values(
-    target_path: str,
-    scope: str,
-    mode: str,
-    diff_target_kind: str | None,
-    diff_base_revision: str | None,
-    diff_head_revision: str | None,
-    diff_content_digest: str | None,
-) -> dict[str, Any]:
-    target = require_target(target_path)
-    require_scannable_target(target)
-    normalized_scope = require_scope(scope, mode, target)
-    if mode == "diff" and normalized_scope != ".":
-        raise SystemExit("Review changes requires the whole target; use scope '.'.")
-    if mode != "diff" and any(
-        value is not None
-        for value in (
-            diff_target_kind,
-            diff_base_revision,
-            diff_head_revision,
-            diff_content_digest,
-        )
-    ):
-        raise SystemExit("A Git diff target requires Review changes mode.")
-    diff_target = (
-        require_diff_target(
-            target,
-            diff_target_kind,
-            diff_base_revision,
-            diff_head_revision,
-            diff_content_digest,
-        )
-        if mode == "diff"
-        else None
+def apply_migrations(
+    connection: sqlite3.Connection,
+    *,
+    immediate: bool = False,
+    discovery_roots: tuple[Path, ...] = (),
+) -> None:
+    apply_schema_migrations(
+        connection,
+        MIGRATIONS,
+        now,
+        backfill_security_targets,
+        immediate=immediate,
+        discovery_roots=discovery_roots,
     )
-    return {
-        "diffTarget": diff_target,
-        "scope": normalized_scope,
-        "target": inspect_target(str(target)),
-    }
-
-
-def require_review_changes_target(target: Path) -> str:
-    revision = require_git_worktree_head(target)
-    repository_root = git_output(target, "rev-parse", "--show-toplevel")
-    if repository_root is None or Path(repository_root).resolve() != target:
-        raise SystemExit(
-            "Review changes requires the checked-out Git repository root as the target."
-        )
-    return revision
-
 
-def require_scannable_target(target: Path) -> None:
-    metadata = git_target_metadata(target)
-    if metadata["isGit"] and not metadata["isWorktree"]:
-        raise SystemExit(
-            "Codex Security requires a checked-out worktree, not a bare Git repository."
-        )
 
+def requested_scan_file_paths(scan: sqlite3.Row) -> list[str]:
+    # Older scans did not record path kinds. Retain their lexical scope semantics
+    # rather than infer the original target from a possibly changed checkout.
+    if scan["recipe_json"] is None:
+        return []
+    recipe = json.loads(scan["recipe_json"], parse_constant=reject_non_finite_json)
+    return recipe.get("scopeFilePaths", [])
 
-def expected_target_kinds(scan: sqlite3.Row) -> list[str]:
-    if scan["mode"] == "diff":
-        return ["git_diff"]
-    if scan["target_revision"] == "unversioned":
-        return ["directory_snapshot"]
-    if scan["target_snapshot_digest"] is None:
-        return ["git_worktree", "git_revision"]
-    if scan["target_snapshot_digest"] == clean_worktree_content_digest():
-        return ["git_revision"]
-    return ["git_worktree"]
 
-
-def requested_scan_paths(scan: sqlite3.Row) -> list[str]:
-    if "recipe_json" in scan.keys() and scan["recipe_json"] is not None:
-        recipe = json.loads(scan["recipe_json"], parse_constant=reject_non_finite_json)
-        target = recipe["target"]
-        if target["kind"] == "paths":
-            return target["paths"]
-    return [scan["scope"]]
+def requested_finding_scope(scan: sqlite3.Row) -> list[tuple[str, bool]]:
+    """Return requested paths paired with whether the stored recipe identified each one as a file."""
+    files = {PurePosixPath(path) for path in requested_scan_file_paths(scan)}
+    return [(path, PurePosixPath(path) in files) for path in requested_scan_paths(scan)]
 
 
 def scan_contract(scan: sqlite3.Row) -> dict[str, Any]:
+    """Return the target identity, scope requirements, and diff target recorded for this scan."""
     target = Path(scan["target_path"])
     target_contract = {
         "allowedKinds": expected_target_kinds(scan),
@@ -462,6 +379,7 @@
         "scope": {
             "requiredExcludePaths": [],
             "requestedPath": scan["scope"],
+            "filePaths": requested_scan_file_paths(scan),
             **(
                 {"requiredIncludePaths": requested_scan_paths(scan)}
                 if scan["mode"] != "diff"
@@ -472,36 +390,16 @@
     }
 
 
-def expected_coverage_mode(scan: sqlite3.Row) -> str:
-    if scan["mode"] == "diff":
-        mode = {
-            "commit": "commit",
-            "range": "branch_diff",
-            "working_tree": "working_tree",
-        }.get(scan["diff_target_kind"])
-        if mode is None:
-            raise SystemExit("This migrated diff scan does not have a validated change set.")
-        return mode
-    if scan["scope"] != "." or (
-        "recipe_json" in scan.keys()
-        and scan["recipe_json"] is not None
-        and json.loads(scan["recipe_json"])["target"]["kind"] == "paths"
-    ):
-        return "scoped_path"
-    return "deep_repository" if scan["mode"] == "deep" else "repository"
+expected_coverage_mode = scan_history.expected_coverage_mode
 
 
 def workbench_completion_binding(
     scan: sqlite3.Row, completed_at: str, manifest: dict[str, Any] | None = None
 ) -> dict[str, Any]:
+    """Build the scan ID, timestamps, producer, target, and scope used to bind output artifacts at completion."""
     contract = scan_contract(scan)
     target_contract = contract["target"]
-    plugin_manifest = read_json_object(
-        Path(__file__).resolve().parent.parent / ".codex-plugin" / "plugin.json"
-    )
-    plugin_version = plugin_manifest.get("version")
-    if not isinstance(plugin_version, str) or not plugin_version:
-        raise SystemExit("plugin.json: expected a nonempty Codex Security plugin version.")
+    plugin_version = loaded_plugin_version()
     target: dict[str, Any] = {
         "targetId": target_contract["targetId"],
         "displayName": target_contract["displayName"],
@@ -536,6 +434,7 @@
 
 
 def verify_manifest_binding(scan: sqlite3.Row, manifest: dict[str, Any]) -> None:
+    """Raise SystemExit if the supplied manifest does not match the registered scan, target, or scope."""
     manifest_scan = manifest.get("scan")
     if not isinstance(manifest_scan, dict):
         raise SystemExit("scan-manifest.json scan must be an object.")
@@ -606,28 +505,6 @@
             raise SystemExit("scan-manifest.json scope must stay inside the workbench scan scope.")
 
 
-def require_scope(scope: str, mode: str, target: Path) -> str:
-    value = scope.strip() or "."
-    requested_scope = Path(value)
-    if "\\" in value and (os.name != "nt" or not requested_scope.is_absolute()):
-        raise SystemExit("Scan scope must use repository-relative POSIX paths.")
-    if ".." in requested_scope.parts:
-        raise SystemExit("Scan scope must stay inside the scanned target.")
-    try:
-        resolved_scope = (
-            requested_scope if requested_scope.is_absolute() else target / requested_scope
-        ).resolve()
-        relative_scope = resolved_scope.relative_to(target)
-    except (RuntimeError, ValueError) as exc:
-        raise SystemExit("Scan scope must stay inside the scanned target.") from exc
-    normalized = relative_scope.as_posix() or "."
-    if mode == "deep" and normalized != ".":
-        raise SystemExit("Deep Scan is repository-wide and cannot use a scoped path.")
-    if not resolved_scope.is_dir():
-        raise SystemExit("Scan scope must reference an existing directory inside the target.")
-    return normalized
-
-
 def require_workspace(connection: sqlite3.Connection, workspace_id: str) -> sqlite3.Row:
     workspace_id = require_uuid(workspace_id, "workspace-id")
     row = connection.execute("SELECT * FROM workspaces WHERE id = ?", (workspace_id,)).fetchone()
@@ -645,6 +522,10 @@
 
 
 def resolve_scan_id(connection: sqlite3.Connection, scan_id: str) -> str:
+    """Return a canonical UUID or resolve a unique scan ID prefix of at least eight characters.
+
+    Raise SystemExit for a prefix that is too short, ambiguous, or absent from the database.
+    """
     try:
         return str(uuid.UUID(scan_id))
     except ValueError:
@@ -666,8 +547,10 @@
 def create_workspace(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
     workspace_id = require_uuid(args.workspace_id, "workspace-id")
     timestamp = now()
-    target_path = optional_text(args.target_path, maximum=4096)
-    default_scope = optional_text(args.scope, maximum=4096) or "."
+    target_path = args.target_path if optional_text(args.target_path, maximum=4096) else None
+    default_scope = args.scope if optional_text(args.scope, maximum=4096) else "."
+    if any(len(value) > 4096 for value in (target_path, default_scope) if value is not None):
+        raise SystemExit("Text value must be no longer than 4096 characters.")
     diff_target_kind = args.diff_target_kind if args.mode == "diff" else None
     diff_base_revision = (
         optional_text(args.diff_base_revision, maximum=512) if args.mode == "diff" else None
@@ -678,6 +561,8 @@
     diff_content_digest = (
         optional_text(args.diff_content_digest, maximum=128) if args.mode == "diff" else None
     )
+    target_path_unvalidated = False
+    rejected_roots = None
     if target_path:
         try:
             inspected = inspect_setup_values(
@@ -697,10 +582,17 @@
                 diff_head_revision = inspected["diffTarget"]["headRevision"]
                 diff_content_digest = inspected["diffTarget"].get("contentDigest")
         except SystemExit:
-            pass
+            # Setup may fail on scope even when the target itself is valid.
+            try:
+                require_target(target_path)
+            except SystemExit:
+                target_path_unvalidated = True
+                rejected_roots = rejected_checkout_roots(target_path)
     with connection:
         target_id = (
-            ensure_security_target(connection, target_path) if target_path is not None else None
+            ensure_security_target(connection, target_path)
+            if target_path is not None and not target_path_unvalidated
+            else None
         )
         connection.execute(
             """
@@ -708,8 +600,8 @@
                 id, thread_id, target_id, target_path, target_title, target_summary,
                 default_scope, default_mode,
                 user_context, diff_target_kind, diff_base_revision, diff_head_revision,
-                diff_content_digest, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                diff_content_digest, created_at, updated_at, target_path_unvalidated, rejected_checkout_roots_json
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 workspace_id,
@@ -727,6 +619,8 @@
                 diff_content_digest,
                 timestamp,
                 timestamp,
+                target_path_unvalidated,
+                json.dumps(rejected_roots) if rejected_roots is not None else None,
             ),
         )
     return workspace_state(connection, workspace_id)
@@ -736,15 +630,7 @@
     workspace = require_workspace(connection, args.workspace_id)
     if workspace["active_scan_id"]:
         raise SystemExit("This workspace already has a scan. Open a new workspace to change setup.")
-    inspected = inspect_setup_values(
-        args.target_path,
-        args.scope,
-        args.mode,
-        args.diff_target_kind,
-        args.diff_base_revision,
-        args.diff_head_revision,
-        args.diff_content_digest,
-    )
+    inspected = inspect_selected_setup(args)
     target = Path(inspected["target"]["targetPath"])
     scope = inspected["scope"]
     target_path = str(target)
@@ -769,7 +655,10 @@
             SET target_id = ?, target_path = ?, target_title = ?, target_summary = ?, default_scope = ?,
                 default_mode = ?, user_context = ?, diff_target_kind = ?,
                 diff_base_revision = ?, diff_head_revision = ?, diff_content_digest = ?,
-                submitted = 1, updated_at = ?
+                deep_scan_config_json = ?, submitted = 1, updated_at = ?, target_path_unvalidated = 0,
+                -- JSON null keeps PATH discovery disabled after a legacy rejection.
+                rejected_checkout_roots_json = COALESCE(rejected_checkout_roots_json,
+                    CASE WHEN target_path_unvalidated = 1 AND target_id IS NULL THEN 'null' END)
             WHERE id = ? AND active_scan_id IS NULL
             """,
             (
@@ -780,10 +669,8 @@
                 scope,
                 args.mode,
                 user_context_argument(args),
-                diff_target["kind"] if diff_target else None,
-                diff_target["baseRevision"] if diff_target else None,
-                diff_target["headRevision"] if diff_target else None,
-                diff_target.get("contentDigest") if diff_target else None,
+                *scan_diff_identity(diff_target or None),
+                json.dumps(inspected["deepScanConfig"]) if "deepScanConfig" in inspected else None,
                 timestamp,
                 workspace["id"],
             ),
@@ -797,12 +684,38 @@
 
 def scan_target_root(scan_root: str | None, target: Path) -> Path:
     root = resolve_scan_root(scan_root)
-    target_root = (root / safe_segment(target.name)).resolve()
+    target_root = root / safe_segment(target.name)
+    if os.name != "nt":
+        target_root = target_root.resolve()
     if target_root == target or target in target_root.parents:
         raise SystemExit("The scan artifact directory must be outside the selected target.")
     return target_root
 
 
+def scan_scope_file_count(
+    target: Path, paths: list[str], diff_target: dict[str, str] | None
+) -> int | None:
+    if diff_target is not None:
+        return diff_scope_file_count(target, diff_target)
+    return sum(
+        1 if (target / path).is_file() else directory_snapshot_regular_file_count(target / path)
+        for path in paths
+    )
+
+
+def require_working_tree_unchanged(target: Path, diff_target: dict[str, str] | None) -> None:
+    if (
+        diff_target is not None
+        and diff_target["kind"] == "working_tree"
+        and (
+            git_revision(target) != diff_target["headRevision"]
+            or worktree_content_digest(target, expected_digest=diff_target["contentDigest"])
+            != diff_target["contentDigest"]
+        )
+    ):
+        raise SystemExit("The selected scan target changed while the scan was starting. Try again.")
+
+
 def start_scan(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
     workspace_id = require_uuid(args.workspace_id, "workspace-id")
     manages_transaction = not connection.in_transaction
@@ -819,7 +732,8 @@
             (workspace["id"],),
         ).fetchone()
         if active is not None:
-            return workspace_state(connection, workspace["id"])
+            require_scan_checkout_owner(connection, active)
+            return workspace_state(connection, workspace["id"], result_scan_id=active["id"])
         workspace_version = workspace["updated_at"]
         scan_id = str(uuid.uuid4())
         timestamp = now()
@@ -841,16 +755,21 @@
         )
         if diff_target is not None and not target_summary:
             target_summary = diff_target_summary(diff_target)
-        scope_file_count = directory_snapshot_regular_file_count(
-            target if scope == "." else target / scope
-        )
+        scope_file_count = scan_scope_file_count(target, [scope], diff_target)
         target_identity = scan_target_identity(
             target,
             diff_target,
             metadata=target_metadata,
         )
+        source_scopes = capture_source_scopes(
+            target,
+            target_identity,
+            [scope],
+            diff_target_kind=diff_target["kind"] if diff_target is not None else None,
+        )
         target_root = scan_target_root(args.scan_root, target)
-        create_private_directory(target_root)
+        create_private_directory(target_root, scan_output=True)
+        require_working_tree_unchanged(target, diff_target)
         if manages_transaction:
             connection.execute("BEGIN IMMEDIATE")
         workspace = require_workspace(connection, workspace_id)
@@ -863,9 +782,10 @@
             (workspace["id"],),
         ).fetchone()
         if active is not None:
+            require_scan_checkout_owner(connection, active)
             if manages_transaction:
                 connection.commit()
-            return workspace_state(connection, workspace["id"])
+            return workspace_state(connection, workspace["id"], result_scan_id=active["id"])
         if workspace["updated_at"] != workspace_version:
             raise SystemExit("Codex Security setup changed while the scan was starting. Try again.")
         current_target = require_remediation_target(str(target))
@@ -889,6 +809,11 @@
                     "This Codex thread already has an active Deep Scan for the selected "
                     "target and scope. Rejoin that scan instead of starting another one."
                 )
+        registration = register_security_target(connection, str(current_target))
+        if registration.target_id != workspace["target_id"]:
+            raise SystemExit(
+                "The saved workspace no longer matches the selected repository target."
+            )
         insert_running_scan(
             connection,
             scan_id=scan_id,
@@ -897,6 +822,8 @@
             scope=scope,
             diff_target=diff_target,
             target_identity=target_identity,
+            repository_generation=registration.repository_generation,
+            source_scopes=source_scopes,
             target_root=target_root,
             target_summary=target_summary,
             scope_file_count=scope_file_count,
@@ -910,7 +837,7 @@
         if manages_transaction:
             connection.rollback()
         raise
-    return workspace_state(connection, workspace["id"])
+    return workspace_state(connection, workspace["id"], result_scan_id=scan_id)
 
 
 def _start_prompt_driven_scan(
@@ -936,141 +863,168 @@
     target_summary = optional_text(args.target_summary, maximum=2400)
     if diff_target is not None and not target_summary:
         target_summary = diff_target_summary(diff_target)
-    scope_file_count = directory_snapshot_regular_file_count(
-        target if scope == "." else target / scope
-    )
+    scope_file_count = scan_scope_file_count(target, [scope], diff_target)
     diff_identity = scan_diff_identity(diff_target)
     target_identity = scan_target_identity(target, diff_target)
+    source_scopes = capture_source_scopes(
+        target,
+        target_identity,
+        [scope],
+        diff_target_kind=diff_target["kind"] if diff_target is not None else None,
+    )
     target_root = scan_target_root(args.scan_root, target)
 
-    connection.execute("BEGIN IMMEDIATE")
-    try:
-        current_target = require_remediation_target(target_path)
-        current_diff_target = (
-            require_diff_target(
-                current_target,
-                args.diff_target_kind,
-                args.diff_base_revision,
-                args.diff_head_revision,
-                args.diff_content_digest,
-            )
-            if args.mode == "diff"
-            else None
-        )
-        if (
-            scan_target_identity(current_target, current_diff_target) != target_identity
-            or scan_diff_identity(current_diff_target) != diff_identity
-        ):
-            raise SystemExit(
-                "The selected scan target changed while the scan was starting. Try again."
+    busy_timeout = int(connection.execute("PRAGMA busy_timeout").fetchone()[0])
+    for attempt in range(SQLITE_RETRY_ATTEMPTS):
+        try:
+            # Wait before hashing, then release the writer slot while reading the target.
+            connection.execute("BEGIN IMMEDIATE")
+            connection.rollback()
+            current_target = require_remediation_target(target_path)
+            current_diff_target = (
+                require_diff_target(
+                    current_target,
+                    args.diff_target_kind,
+                    args.diff_base_revision,
+                    args.diff_head_revision,
+                    args.diff_content_digest,
+                )
+                if args.mode == "diff"
+                else None
             )
-        existing = connection.execute(
-            """
-            SELECT scans.* FROM scans
-            JOIN workspaces ON workspaces.active_scan_id = scans.id
-            WHERE workspaces.thread_id = ? AND workspaces.target_path = ?
-                AND workspaces.default_scope = ? AND workspaces.default_mode = ?
-                AND workspaces.user_context IS ? AND workspaces.target_summary IS ?
-                AND workspaces.diff_target_kind IS ? AND workspaces.diff_base_revision IS ?
-                AND workspaces.diff_head_revision IS ? AND workspaces.diff_content_digest IS ?
-                AND workspaces.submitted = 1 AND scans.target_revision = ?
-                AND scans.target_snapshot_digest IS ? AND scans.target_device = ?
-                AND scans.target_inode = ? AND scans.status = 'running'
-                AND scans.handoff_status = 'delivered'
-                AND (
-                    (? = 0 AND scans.handoff_claim_token IS NULL)
-                    OR (
-                        ? = 1 AND scans.handoff_claim_token IS NOT NULL
-                        AND scans.continuation_thread_id = ?
-                    )
+            if (
+                scan_target_identity(current_target, current_diff_target) != target_identity
+                or scan_diff_identity(current_diff_target) != diff_identity
+            ):
+                raise SystemExit(
+                    "The selected scan target changed while the scan was starting. Try again."
                 )
-            ORDER BY scans.updated_at DESC, scans.started_at DESC, scans.id LIMIT 1
-            """,
-            (
-                thread_id,
-                target_path,
-                scope,
-                args.mode,
-                user_context,
-                target_summary,
-                *diff_identity,
-                *target_identity,
-                int(headless_standard),
-                int(headless_standard),
-                thread_id,
-            ),
-        ).fetchone()
-        if existing is not None:
-            connection.commit()
-            return {
-                **scan_context(connection, existing["id"]),
-                "startDisposition": "joined",
-            }
-        create_private_directory(target_root)
-        workspace_id = str(uuid.uuid4())
-        scan_id = str(uuid.uuid4())
-        timestamp = now()
-        target_id = ensure_security_target(connection, target_path)
-        connection.execute(
-            """
-            INSERT INTO workspaces (
-                id, thread_id, target_id, target_path, target_title, target_summary, default_scope,
-                default_mode, user_context, diff_target_kind, diff_base_revision,
-                diff_head_revision, diff_content_digest, submitted, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
-            """,
-            (
-                workspace_id,
-                thread_id,
-                target_id,
-                target_path,
-                target.name,
-                target_summary,
-                scope,
-                args.mode,
-                user_context,
-                *diff_identity,
-                timestamp,
-                timestamp,
-            ),
-        )
-        workspace = require_workspace(connection, workspace_id)
-        insert_running_scan(
-            connection,
-            scan_id=scan_id,
-            workspace=workspace,
-            target=target,
-            scope=scope,
-            diff_target=diff_target,
-            target_identity=target_identity,
-            target_root=target_root,
-            target_summary=target_summary,
-            scope_file_count=scope_file_count,
-            timestamp=timestamp,
-            handoff_status="delivered",
-            model=args.model,
-            reasoning_effort=args.reasoning_effort,
-        )
-        if headless_standard:
-            claimed = connection.execute(
+            # If another writer arrived during hashing, retry without waiting on a stale hash.
+            connection.execute("PRAGMA busy_timeout = 0")
+            try:
+                connection.execute("BEGIN IMMEDIATE")
+            finally:
+                connection.execute(f"PRAGMA busy_timeout = {busy_timeout}")
+            existing = connection.execute(
                 """
-                UPDATE scans
-                SET handoff_claim_token = ?, continuation_thread_id = ?
-                WHERE id = ? AND status = 'running' AND handoff_status = 'delivered'
-                    AND handoff_claim_token IS NULL AND continuation_thread_id IS NULL
+                SELECT scans.* FROM scans
+                JOIN workspaces ON workspaces.active_scan_id = scans.id
+                WHERE COALESCE(scans.continuation_thread_id, workspaces.thread_id) = ?
+                    AND scans.recipe_json IS NULL AND workspaces.target_path = ?
+                    AND workspaces.default_scope = ? AND workspaces.default_mode = ?
+                    AND workspaces.user_context IS ? AND workspaces.target_summary IS ?
+                    AND workspaces.diff_target_kind IS ? AND workspaces.diff_base_revision IS ?
+                    AND workspaces.diff_head_revision IS ? AND workspaces.diff_content_digest IS ?
+                    AND workspaces.submitted = 1 AND scans.target_revision = ?
+                    AND scans.target_snapshot_digest IS ? AND scans.target_device = ?
+                    AND scans.target_inode = ? AND scans.status = 'running'
+                    AND scans.handoff_status = 'delivered'
+                    AND (
+                        (? = 0 AND scans.handoff_claim_token IS NULL)
+                        OR (
+                            ? = 1 AND scans.handoff_claim_token IS NOT NULL
+                            AND scans.continuation_thread_id = workspaces.thread_id
+                        )
+                    )
+                ORDER BY scans.updated_at DESC, scans.started_at DESC, scans.id LIMIT 1
                 """,
-                (str(uuid.uuid4()), thread_id, scan_id),
+                (
+                    thread_id,
+                    target_path,
+                    scope,
+                    args.mode,
+                    user_context,
+                    target_summary,
+                    *diff_identity,
+                    *target_identity,
+                    int(headless_standard),
+                    int(headless_standard),
+                ),
+            ).fetchone()
+            if existing is not None:
+                require_scan_checkout_owner(connection, existing)
+                connection.commit()
+                return {
+                    **scan_context(connection, existing["id"], model_thread_id=thread_id),
+                    "startDisposition": "joined",
+                }
+            create_private_directory(target_root, scan_output=True)
+            workspace_id = str(uuid.uuid4())
+            scan_id = str(uuid.uuid4())
+            timestamp = now()
+            registration = 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, target_summary, default_scope,
+                    default_mode, user_context, diff_target_kind, diff_base_revision,
+                    diff_head_revision, diff_content_digest, submitted, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+                """,
+                (
+                    workspace_id,
+                    thread_id,
+                    target_id,
+                    target_path,
+                    target.name,
+                    target_summary,
+                    scope,
+                    args.mode,
+                    user_context,
+                    *diff_identity,
+                    timestamp,
+                    timestamp,
+                ),
             )
-            if claimed.rowcount != 1:
-                raise SystemExit("Codex Security headless scan ownership could not be recorded.")
-        connection.commit()
-    except BaseException:
-        connection.rollback()
-        raise
+            workspace = require_workspace(connection, workspace_id)
+            insert_running_scan(
+                connection,
+                scan_id=scan_id,
+                workspace=workspace,
+                target=target,
+                scope=scope,
+                diff_target=diff_target,
+                target_identity=target_identity,
+                repository_generation=registration.repository_generation,
+                source_scopes=source_scopes,
+                target_root=target_root,
+                target_summary=target_summary,
+                scope_file_count=scope_file_count,
+                timestamp=timestamp,
+                handoff_status="delivered",
+                model=args.model,
+                reasoning_effort=args.reasoning_effort,
+            )
+            if headless_standard:
+                claimed = connection.execute(
+                    """
+                    UPDATE scans
+                    SET handoff_claim_token = ?, continuation_thread_id = ?
+                    WHERE id = ? AND status = 'running' AND handoff_status = 'delivered'
+                        AND handoff_claim_token IS NULL AND continuation_thread_id IS NULL
+                    """,
+                    (str(uuid.uuid4()), thread_id, scan_id),
+                )
+                if claimed.rowcount != 1:
+                    raise SystemExit(
+                        "Codex Security headless scan ownership could not be recorded."
+                    )
+            connection.commit()
+            break
+        except sqlite3.OperationalError as exc:
+            connection.rollback()
+            if attempt == SQLITE_RETRY_ATTEMPTS - 1 or not sqlite_busy(exc):
+                raise
+            time.sleep(0.05 * (2**attempt))
+        except BaseException:
+            connection.rollback()
+            raise
     return {**scan_context(connection, scan_id), "startDisposition": "created"}
 
 
 def scan_local_file_digest(scan_dir: Path, relative_path: str) -> str:
+    """Return the SHA-256 of the scan-local file contents, prefixed with sha256:."""
     digest = hashlib.sha256()
     with open_scan_local_file(scan_dir, relative_path) as source:
         for chunk in iter(lambda: source.read(1024 * 1024), b""):
@@ -1079,6 +1033,7 @@
 
 
 def published_manifest_digest(scan_dir: Path, manifest: dict[str, Any]) -> str:
+    """Return the canonical manifest digest or raise SystemExit if the published bytes differ."""
     canonical = (json.dumps(manifest, allow_nan=False, indent=2, sort_keys=True) + "\n").encode()
     expected = f"sha256:{hashlib.sha256(canonical).hexdigest()}"
     actual = scan_local_file_digest(scan_dir, ARTIFACTS["manifest"])
@@ -1088,6 +1043,7 @@
 
 
 def require_recorded_manifest_digest(scan: sqlite3.Row, scan_dir: Path) -> None:
+    """Raise SystemExit if the saved manifest differs from the digest recorded when the scan was sealed."""
     expected = scan["seal_manifest_digest"]
     if expected is None:
         return
@@ -1098,6 +1054,7 @@
 def pin_legacy_manifest_digest(
     connection: sqlite3.Connection, scan_id: str, manifest_digest: str
 ) -> None:
+    """Record a previously missing digest in a write transaction, rejecting a conflict with an existing digest."""
     connection.execute("BEGIN IMMEDIATE")
     with connection:
         scan = require_scan(connection, scan_id)
@@ -1127,12 +1084,70 @@
             cost_json,
             prepare_only=prepare_only,
             thread_id=getattr(args, "thread_id", None),
+            turn_id=getattr(args, "turn_id", None),
+            model_thread_id=getattr(args, "model_thread_id", None),
         )
 
 
+def read_scan_usage(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
+    # Validation can finish after the scan's recorded completion timestamp.
+    usage = scan_usage.collect_scan_usage(
+        connection,
+        require_scan(connection, args.scan_id),
+        thread_id=args.thread_id,
+        validation_thread_id=args.validation_thread_id,
+        completed_at=now(),
+    )
+    if "cacheWriteInputTokens" in usage:
+        usage.setdefault("cacheWriteInputTokensReported", True)
+    return usage
+
+
+def finalize_scan_usage(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
+    scan_id = require_uuid(args.scan_id, "scan-id")
+    with scan_completion_lock(scan_id):
+        scan = require_scan(connection, scan_id)
+        stored = json.loads(scan["cost_json"]) if scan["cost_json"] is not None else {}
+        usage = stored.get("usage", {})
+        completion = usage.get("completion")
+        if scan["status"] != "complete" or not completion:
+            raise SystemExit("The scan has no pending completion usage.")
+        if completion["threadId"] != args.thread_id or completion["turnId"] != args.turn_id:
+            raise SystemExit("The scan usage belongs to a different completion turn.")
+        if not completion["finalized"]:
+            usage = scan_usage.collect_scan_usage_safely(
+                connection,
+                scan,
+                thread_id=args.thread_id,
+                completed_turn_id=args.turn_id,
+            )
+            if usage["coverage"] == "unavailable":
+                if not usage.get("accountRateLimits"):
+                    return scan_context(connection, scan_id)
+                usage = {**stored["usage"], "accountRateLimits": usage["accountRateLimits"]}
+            else:
+                if args.turn_status != "completed":
+                    if usage["coverage"] == "complete":
+                        usage["coverage"] = "partial"
+                    usage["warnings"] = [
+                        *usage.get("warnings", []),
+                        f"scan_turn_{args.turn_status}",
+                    ]
+                usage["completion"] = {**completion, "finalized": True}
+            fields = scan_usage.merge_scan_usage_fields(stored, {"usage": usage})
+            fields["usage"]["completion"] = usage["completion"]
+            cost_json = parse_scan_cost(json.dumps(fields))
+            with connection:
+                connection.execute(
+                    "UPDATE scans SET cost_json = ? WHERE id = ?", (cost_json, scan_id)
+                )
+        return scan_context(connection, scan_id)
+
+
 def complete_budget_exhausted_scan(
     connection: sqlite3.Connection, args: argparse.Namespace
 ) -> dict[str, Any]:
+    """Complete a running CLI Deep Scan using the measured cost and saved results after its budget is exhausted."""
     scan_id = require_uuid(args.scan_id, "scan-id")
     cost_json = parse_scan_cost(args.cost_json)
     if cost_json is None:
@@ -1174,7 +1189,7 @@
             if run["manifest_path"] == str(scan_dir / "scan-manifest.json")
             else budget_exhausted_candidates(scan, scan_dir)
         )
-        warning = optional_text(args.message, maximum=2400)
+        warning = optional_text(args.message)
         if warning is None:
             warning = (
                 f"Deep Scan reached its cost limit after an estimated "
@@ -1264,152 +1279,9 @@
 
 
 def budget_exhausted_draft(
-    scan: sqlite3.Row,
-    scan_dir: Path,
-    candidates: list[dict[str, Any]],
-    warning: str,
+    scan: sqlite3.Row, scan_dir: Path, candidates: list[dict[str, Any]], warning: str
 ) -> None:
-    documents: dict[str, dict[str, Any]] = {}
-    for name in ("scan-manifest.json", "findings.json", "coverage.json"):
-        path = artifact_path(scan_dir, name, required=False)
-        if path is not None:
-            documents[name] = read_json_object(path)
-    if documents and len(documents) != 3:
-        raise SystemExit("Budget-exhausted scan contains an incomplete canonical scan draft.")
-
-    if documents:
-        manifest = documents["scan-manifest.json"]
-        findings = documents["findings.json"]
-        coverage = documents["coverage.json"]
-        if not isinstance(manifest.get("scan"), dict) or not isinstance(
-            findings.get("findings"), list
-        ):
-            raise SystemExit("Budget-exhausted scan contains an invalid canonical scan draft.")
-        for key in ("surfaces", "explicitExclusions", "deferred"):
-            if not isinstance(coverage.get(key), list):
-                raise SystemExit("Budget-exhausted scan contains invalid canonical coverage.")
-        if manifest["scan"].get("sealedAt") is not None or manifest["scan"].get("artifacts"):
-            raise SystemExit("Budget-exhausted scan cannot replace an already sealed scan draft.")
-    else:
-        contract = scan_contract(scan)
-        target_contract = contract["target"]
-        target: dict[str, Any] = {
-            "kind": target_contract["allowedKinds"][0],
-            "targetId": target_contract["targetId"],
-            "displayName": target_contract["displayName"],
-        }
-        if scan["target_revision"] != "unversioned":
-            target["revision"] = scan["target_revision"]
-        if "requiredSnapshotDigest" in target_contract:
-            target["snapshotDigest"] = target_contract["requiredSnapshotDigest"]
-        manifest = {
-            "scan": {
-                "target": target,
-                "scope": {"limitations": [warning], "validationMode": "incomplete"},
-            }
-        }
-        findings = {"findings": []}
-        coverage = {
-            "completeness": "partial",
-            "inventoryStrategy": (
-                "scoped_path" if expected_coverage_mode(scan) == "scoped_path" else "repository"
-            ),
-            "surfaces": [],
-            "explicitExclusions": [],
-            "deferred": [],
-        }
-
-    findings_by_candidate = {
-        candidate_id
-        for finding in findings["findings"]
-        if isinstance(finding, dict)
-        and isinstance(candidate_id := finding_candidate_id(finding), str)
-    }
-    existing_deferred = {
-        item.get("candidateId", item.get("id"))
-        for item in coverage["deferred"]
-        if isinstance(item, dict) and isinstance(item.get("candidateId", item.get("id")), str)
-    }
-    existing_surfaces = {
-        item.get("id")
-        for item in coverage["surfaces"]
-        if isinstance(item, dict) and isinstance(item.get("id"), str)
-    }
-    for candidate in candidates:
-        candidate_id = candidate["candidate_id"]
-        if candidate_id in findings_by_candidate or candidate_id in existing_deferred:
-            continue
-        paths = list(dict.fromkeys(location["path"] for location in candidate["locations"]))
-        surface_id = f"candidate-{candidate_id}"
-        validation = candidate.get("validation")
-        validation = validation.get("disposition") if isinstance(validation, dict) else None
-        attack = candidate.get("attack_path")
-        attack = attack.get("decision") if isinstance(attack, dict) else None
-        disposition = (
-            "needs_follow_up"
-            if validation == "deferred" or attack == "deferred"
-            else "not_applicable"
-            if validation == "not_applicable"
-            else "rejected"
-            if validation == "suppressed" or attack == "ignore"
-            else "needs_follow_up"
-        )
-        if surface_id not in existing_surfaces:
-            coverage["surfaces"].append(
-                {
-                    "id": surface_id,
-                    "label": candidate["summary"],
-                    "disposition": disposition,
-                    "notes": candidate["evidence"],
-                    "receiptRefs": [],
-                }
-            )
-            existing_surfaces.add(surface_id)
-        if disposition != "needs_follow_up":
-            continue
-        coverage["deferred"].append(
-            {
-                "id": candidate_id,
-                "candidateId": candidate_id,
-                "reason": (
-                    "Validation was deferred because the scan reached its cost limit: "
-                    f"{candidate['summary']}. Evidence: {candidate['evidence']}"
-                ),
-                "paths": paths,
-                "surfaceIds": [surface_id],
-            }
-        )
-    if not any(
-        isinstance(item, dict)
-        and isinstance(reason := item.get("reason"), str)
-        and (
-            reason == "Validation was deferred because the scan reached its cost limit."
-            or reason.startswith(
-                "Validation was deferred because the scan reached its cost limit: "
-            )
-        )
-        for item in coverage["deferred"]
-    ):
-        coverage["deferred"].append(
-            {
-                "id": "scan-cost-limit",
-                "reason": "Validation was deferred because the scan reached its cost limit.",
-            }
-        )
-    coverage["completeness"] = "partial"
-    for name, payload in (
-        ("findings.json", findings),
-        ("coverage.json", coverage),
-        ("scan-manifest.json", manifest),
-    ):
-        try:
-            write_scan_local_bytes(
-                scan_dir,
-                name,
-                (json.dumps(payload, allow_nan=False, indent=2, sort_keys=True) + "\n").encode(),
-            )
-        except (ContractError, OSError, TypeError, ValueError) as exc:
-            raise SystemExit(f"Budget-exhausted scan draft could not be saved: {exc}") from exc
+    saved_results.budget_exhausted_draft(sys.modules[__name__], scan, scan_dir, candidates, warning)
 
 
 def complete_scan_locked(
@@ -1420,19 +1292,22 @@
     *,
     prepare_only: bool = False,
     thread_id: str | None = None,
+    turn_id: str | None = None,
+    model_thread_id: str | None = None,
 ) -> dict[str, Any]:
     scan = require_scan(connection, scan_id)
-    if scan["status"] == "complete":
-        return saved_results.refresh_completed_scan(
-            _WORKBENCH_DB_CONTEXT, connection, scan, cost_json
-        )
-    if scan["status"] != "running":
+    handoff.require_tokenless_scan_owner(connection, scan, model_thread_id)
+    if scan["status"] not in {"running", "complete"}:
         raise SystemExit("Only a running scan can be completed.")
     handoff.require_current_continuation(
         scan,
         claim_token,
         error_message="Scan completion is owned by another continuation.",
     )
+    if scan["status"] == "complete":
+        return saved_results.refresh_completed_scan(
+            _WORKBENCH_DB_CONTEXT, connection, scan, cost_json
+        )
     deep_scan.require_deep_scan_ready_for_parent_completion(connection, scan)
     warnings = json.loads(scan["completion_warnings_json"])
     target_warnings: list[str] = []
@@ -1453,10 +1328,7 @@
     already_sealed = (
         current_manifest_path is not None
         and isinstance(current_manifest.get("scan"), dict)
-        and (
-            current_manifest["scan"].get("sealedAt") is not None
-            or current_manifest["scan"].get("artifacts") is not None
-        )
+        and manifest_is_sealed(current_manifest["scan"])
     )
     completion_binding = workbench_completion_binding(scan, completion_timestamp, current_manifest)
     if scan["recipe_json"] is not None:
@@ -1464,7 +1336,6 @@
         for file_name in (
             ARTIFACTS["manifest"],
             ARTIFACTS["findings"],
-            ARTIFACTS["coverage"],
         ):
             try:
                 (scan_dir / file_name).lstat()
@@ -1493,12 +1364,10 @@
                     scan_dir,
                     scan["id"],
                     completion_binding,
-                    connection.execute(
-                        "SELECT * FROM deep_scan_workers WHERE scan_id = ? ORDER BY created_at, id",
-                        (scan["id"],),
-                    ).fetchall(),
+                    saved_deep_workers(connection, scan),
                     warnings,
                     stopped=False,
+                    scan_mode=scan["mode"],
                     reason="",
                 )
                 if merge_parent_draft
@@ -1517,17 +1386,43 @@
                 scan_dir,
                 expected_coverage_mode=expected_coverage_mode(scan),
                 completion_binding=completion_binding,
-                completion_warnings=warnings if scan["mode"] != "deep" else None,
+                recover_unsealed=scan["mode"] != "deep",
+                allow_missing_writeups=True,
                 draft_documents=draft_documents,
+                finding_scope=requested_finding_scope(scan) if scan["mode"] == "deep" else None,
             )
+        warnings.extend(warning for warning in prepared.warnings if warning not in warnings)
         add_warning()
+        with connection:
+            if warnings != json.loads(scan["completion_warnings_json"]):
+                # Retain pre-publication diagnostics even if output writes fail.
+                connection.execute(
+                    "UPDATE scans SET completion_warnings_json = ? WHERE id = ? AND status = 'running'",
+                    (json.dumps(warnings), scan_id),
+                )
+            prepared_scan = prepared.manifest["scan"]
+            if scan["mode"] == "deep" and (
+                not prepared.was_sealed
+                or "coverageRef" in prepared_scan
+                or "surfaces" in prepared_scan.get("reviewState", {})
+            ):
+                # A summary-only seal omits surfaces. Keep the count from its first preparation.
+                connection.execute(
+                    "UPDATE deep_scan_runs SET terminal_reviewed_surface_count = ? WHERE scan_id = ?",
+                    (len(prepared.coverage["surfaces"]), scan_id),
+                )
         wrote = True
         manifest, findings, _ = _write_prepared_scan_finalization(
             prepared, projection_warnings=warnings
         )
     except ContractError as exc:
-        if wrote or (
+        # Only a coordinator-selected parent is fenced for output-write replay.
+        selected_deep_parent = scan["mode"] == "deep" and deep_scan.require_deep_scan_run(
+            connection, scan_id
+        )["manifest_path"] == str(scan_dir / ARTIFACTS["manifest"])
+        if (wrote and not selected_deep_parent) or (
             scan["mode"] == "deep"
+            and not wrote
             and not already_sealed
             and not isinstance(exc, RecoverableContractError)
         ):
@@ -1540,6 +1435,7 @@
         for kind, filename in ARTIFACTS.items()
     }
     manifest_digest = published_manifest_digest(scan_dir, manifest)
+    reported_count = progress.reported_scope_file_count(_WORKBENCH_DB_CONTEXT, scan)
     if prepare_only:
         connection.execute("BEGIN IMMEDIATE")
         with connection:
@@ -1549,33 +1445,66 @@
             )
             if updated.rowcount != 1:
                 raise SystemExit("Only a running scan can be prepared for completion.")
+            if reported_count is not None:
+                connection.execute(
+                    """
+                    UPDATE scan_progress SET scope_file_count = ?, updated_at = ?
+                    WHERE scan_id = (SELECT id FROM scans WHERE id = ? AND scan_dir = ?
+                        AND handoff_status = ? AND handoff_claim_token IS ?)
+                    """,
+                    (
+                        reported_count,
+                        completion_timestamp,
+                        scan_id,
+                        scan["scan_dir"],
+                        scan["handoff_status"],
+                        scan["handoff_claim_token"],
+                    ),
+                )
         context = scan_context(connection, scan["id"])
         context["targetWarnings"] = target_warnings
         return context
 
-    if cost_json is None:
-        measured_usage = scan_usage.collect_scan_usage(
-            connection,
-            scan,
-            thread_id=thread_id,
-            completed_at=completion_timestamp,
+    measured_usage = scan_usage.collect_scan_usage_safely(
+        connection,
+        scan,
+        thread_id=thread_id,
+        completed_at=completion_timestamp,
+    )
+    cost_fields = scan_usage.merge_scan_usage_fields(
+        scan_usage.stored_scan_cost_fields(cost_json), {"usage": measured_usage}
+    )
+    measured_usage = cost_fields["usage"]
+    if thread_id is not None and turn_id is not None:
+        measured_usage["completion"] = {
+            "threadId": thread_id,
+            "turnId": turn_id,
+            "finalized": False,
+        }
+        if measured_usage["coverage"] == "complete":
+            measured_usage["coverage"] = "partial"
+        measured_usage["warnings"] = sorted(
+            {*measured_usage.get("warnings", []), "turn_in_progress"}
         )
-        cost_json = parse_scan_cost(scan_usage.measured_scan_cost_json(measured_usage))
+    cost_json = parse_scan_cost(json.dumps(cost_fields))
     connection.execute("BEGIN IMMEDIATE")
-    try:
+    with connection:
         timestamp = manifest["scan"]["completedAt"]
         scan = require_scan(connection, scan["id"])
-        if scan["status"] == "complete":
-            connection.commit()
-            return scan_context(connection, scan["id"])
-        if scan["status"] != "running":
+        handoff.require_tokenless_scan_owner(connection, scan, model_thread_id)
+        if scan["status"] not in {"running", "complete"}:
             raise SystemExit("Only a running scan can be completed.")
-        deep_scan.require_deep_scan_ready_for_parent_completion(connection, scan)
         handoff.require_current_continuation(
             scan,
             claim_token,
             error_message="Scan completion is owned by another continuation.",
         )
+        if scan["status"] == "complete":
+            connection.commit()
+            return scan_context(connection, scan["id"])
+        deep_scan.require_deep_scan_ready_for_parent_completion(connection, scan)
+        if scan["scan_dir"] != str(scan_dir):
+            reported_count = None
         connection.execute("DELETE FROM scan_artifacts WHERE scan_id = ?", (scan["id"],))
         for kind, path in artifacts.items():
             if path is not None:
@@ -1591,21 +1520,30 @@
             UPDATE scan_progress
             SET reportable_findings_count = ?, phase_items_total = ?,
                 phase_items_completed = ?, phase_progress_unit = 'report_artifacts',
-                updated_at = ?
+                scope_file_count = COALESCE(?, scope_file_count), updated_at = ?
             WHERE scan_id = ?
             """,
-            (finding_count, len(artifacts), len(artifacts), timestamp, scan["id"]),
+            (
+                finding_count,
+                len(artifacts),
+                len(artifacts),
+                reported_count,
+                timestamp,
+                scan["id"],
+            ),
         )
         updated = connection.execute(
             """
             UPDATE scans
             SET status = 'complete', phase = 'reporting', completed_at = ?, updated_at = ?,
-                seal_manifest_digest = ?, cost_json = ?, completion_warnings_json = ?
+                log_completed_at = ?, seal_manifest_digest = ?, cost_json = ?,
+                completion_warnings_json = ?
             WHERE id = ? AND status = 'running'
             """,
             (
                 timestamp,
                 timestamp,
+                now(),
                 manifest_digest,
                 cost_json,
                 json.dumps(warnings),
@@ -1614,36 +1552,81 @@
         )
         if updated.rowcount != 1:
             raise SystemExit("Only a running scan can be completed.")
-        connection.commit()
-    except BaseException:
-        connection.rollback()
-        raise
     context = scan_context(connection, scan["id"])
     context["targetWarnings"] = target_warnings
     return context
 
 
-def register_cli_scan(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
-    repository = require_target(args.repository)
-    require_scannable_target(repository)
-    scan_dir = require_canonical_scan_directory(Path(args.scan_dir).expanduser())
-    if scan_dir == repository or repository in scan_dir.parents:
-        raise SystemExit("The scan artifact directory must be outside the selected target.")
-    if next(scan_dir.iterdir(), None) is not None:
+def require_cli_scan_directory(repository: Path, args: argparse.Namespace) -> Path:
+    # Registration uses an empty output, including the replacement created with
+    # the original DACL after archival. Check that ACL before moving any results.
+    scan_dir = require_canonical_scan_directory(
+        Path(args.scan_dir).expanduser(), writable_output=True
+    )
+    if scan_dir == repository or repository in scan_dir.parents or scan_dir in repository.parents:
+        raise SystemExit(
+            "The scan artifact directory must be outside and not contain the selected target."
+        )
+    if (not args.archive_existing or args.archived_scan_dir is not None) and next(
+        scan_dir.iterdir(), None
+    ) is not None:
         raise SystemExit("The scan artifact directory must be empty before the scan starts.")
+    return scan_dir
+
+
+def register_cli_scan(
+    connection: sqlite3.Connection,
+    args: argparse.Namespace,
+    *,
+    before_archive: Callable[[], None] | None = None,
+) -> dict[str, Any]:
+    """Register the scan recipe and target identity, archiving any previous output atomically."""
+    # A selected plugin may replace __main__ while delegating to this workbench.
+    before_output_change = before_archive or getattr(
+        sys, "_codex_security_before_output_change", None
+    )
 
+    def acknowledge_output_change() -> None:
+        nonlocal before_output_change
+        if before_output_change is not None:
+            before_output_change()
+            before_output_change = None
+
+    repository = require_target(args.repository)
+    require_scannable_target(repository)
+    if not args.archive_existing or args.archived_scan_dir is not None:
+        # Preserve early output rejection when this call will not move the directory.
+        require_cli_scan_directory(repository, args)
     user_context = None
     workflow_id = None
+    hosted = False
+    surface = None
+    package_version = None
     if args.registration_json_stdin:
         registration = json.load(sys.stdin)
         recipe_json = json.dumps(registration["recipe"], ensure_ascii=False, separators=(",", ":"))
+        hosted = registration.get("hosted") is True
         user_context = registration.get("userContext")
         workflow_id = registration.get("workflowId")
+        if registration.get("surface") in ("cli", "sdk"):
+            surface = registration["surface"]
+        if isinstance(registration.get("packageVersion"), str):
+            package_version = registration["packageVersion"] or None
     else:
         recipe_json = sys.stdin.read() if args.recipe_json_stdin else args.recipe_json
     recipe = parse_scan_recipe(recipe_json, repository)
+    launch_kind = "scan"
+    if isinstance(recipe.get("import"), dict):
+        launch_kind = "import"
+    elif recipe.get("mock") is True:
+        launch_kind = "mock"
     requested_target = recipe["target"]
     paths = requested_target["paths"]
+    recipe.pop("_codexSecurityFileScopes", None)
+    # Capture host-observed kinds once; resumes and publication use the saved recipe.
+    recipe.pop("scopeFilePaths", None)
+    if file_paths := [path for path in paths if (repository / path).is_file()]:
+        recipe["scopeFilePaths"] = file_paths
     scope = paths[0] if len(paths) == 1 else "."
     diff_target = None
     if requested_target["kind"] in {"refs", "working_tree"}:
@@ -1660,17 +1643,21 @@
                 raise SystemExit("Working-tree HEAD changed before the scan started.")
             diff_target["contentDigest"] = worktree_content_digest(repository)
     mode = "diff" if diff_target is not None else recipe["mode"]
-    target_identity = scan_target_identity(repository, diff_target)
+    target_identity, resume_target = prepare_cli_scan_target(
+        repository, diff_target, mode, launch_kind
+    )
+    source_scopes = capture_source_scopes(
+        repository,
+        target_identity,
+        paths or ["."],
+        diff_target_kind=diff_target["kind"] if diff_target is not None else None,
+    )
     scope_file_count = (
-        directory_snapshot_regular_file_count(repository)
-        if not paths
-        else sum(
-            1
-            if (repository / path).is_file()
-            else directory_snapshot_regular_file_count(repository / path)
-            for path in paths
-        )
+        scoped_regular_file_count(repository, paths)
+        if mode == "standard" and len(paths) > 1
+        else scan_scope_file_count(repository, paths or ["."], diff_target)
     )
+    require_working_tree_unchanged(repository, diff_target)
     parent_scan_id = (
         require_uuid(args.parent_scan_id, "parent-scan-id")
         if args.parent_scan_id is not None
@@ -1681,64 +1668,131 @@
     workspace_id = str(uuid.uuid4())
 
     connection.execute("BEGIN IMMEDIATE")
-    with connection:
-        archive_scan(connection, args, scan_dir, timestamp, require_canonical_scan_directory)
-        target_id = ensure_security_target(connection, str(repository))
-        if parent_scan_id is not None:
-            parent = require_scan(connection, parent_scan_id)
-            if parent["target_id"] != target_id:
-                raise SystemExit("A rerun must belong to the same repository as its parent scan.")
-
-        connection.execute(
-            """
-            INSERT INTO workspaces (
-                id, target_id, target_path, target_title, default_scope, default_mode,
-                diff_target_kind, diff_base_revision, diff_head_revision,
-                diff_content_digest, submitted, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
-            """,
-            (
-                workspace_id,
-                target_id,
-                str(repository),
-                repository.name,
-                scope,
-                mode,
-                *scan_diff_identity(diff_target),
-                timestamp,
-                timestamp,
-            ),
-        )
-        workspace = require_workspace(connection, workspace_id)
-        insert_running_scan(
-            connection,
-            scan_id=scan_id,
-            workspace=workspace,
-            target=repository,
-            scope=scope,
-            diff_target=diff_target,
-            target_identity=target_identity,
-            target_root=scan_dir.parent,
-            target_summary=None,
-            scope_file_count=scope_file_count,
-            timestamp=timestamp,
-            handoff_status="delivered",
-            scan_dir=scan_dir,
-        )
-        connection.execute(
-            "UPDATE scans SET recipe_json = ?, parent_scan_id = ?, user_context = ? WHERE id = ?",
-            (
-                json.dumps(recipe, allow_nan=False, separators=(",", ":"), sort_keys=True),
-                parent_scan_id,
-                user_context,
-                scan_id,
-            ),
-        )
-        if workflow_id is not None:
-            register_workflow_scan(connection, workflow_id, scan_id, str(scan_dir), timestamp)
-    scan = require_scan(connection, scan_id)
+    try:
+        with ExitStack() as archive:
+            deadline = None
+            while True:
+                registration = register_security_target(connection, str(repository))
+                target_id = registration.target_id
+                if parent_scan_id is not None:
+                    parent = require_scan(connection, parent_scan_id)
+                    parent_scope = RepositoryScanScope(
+                        registration.repository_generation, target_id
+                    )
+                    if not parent_scope.contains(parent):
+                        raise SystemExit(
+                            "A rerun must belong to the same repository as its parent scan."
+                        )
+                # Revalidate the output and its owner under the current write lock.
+                scan_dir = require_cli_scan_directory(repository, args)
+                try:
+                    archived_scan_dir = archive.enter_context(
+                        archive_scan(
+                            connection,
+                            args,
+                            scan_dir,
+                            timestamp,
+                            require_canonical_scan_directory,
+                            before_archive=acknowledge_output_change,
+                        )
+                    )
+                    break
+                except PermissionError as exc:
+                    # A Windows patch writer can temporarily pin the source of this rename.
+                    if (
+                        getattr(exc, "winerror", None) not in {5, 32}
+                        or exc.filename != str(scan_dir)
+                        or not exc.filename2
+                    ):
+                        raise
+                    if deadline is None:
+                        timeout = connection.execute("PRAGMA busy_timeout").fetchone()[0]
+                        deadline = time.monotonic() + timeout / 1000
+                    remaining = deadline - time.monotonic()
+                    if remaining <= 0:
+                        raise
+                    connection.rollback()
+                    scan_dir = None  # Revalidate the directory and its owner under the next lock.
+                    time.sleep(min(0.05, remaining))
+                    connection.execute("BEGIN IMMEDIATE")
+            connection.execute(
+                """
+                INSERT INTO workspaces (
+                    id, target_id, target_path, target_title, default_scope, default_mode,
+                    diff_target_kind, diff_base_revision, diff_head_revision,
+                    diff_content_digest, submitted, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+                """,
+                (
+                    workspace_id,
+                    target_id,
+                    str(repository),
+                    repository.name,
+                    scope,
+                    mode,
+                    *scan_diff_identity(diff_target),
+                    timestamp,
+                    timestamp,
+                ),
+            )
+            workspace = require_workspace(connection, workspace_id)
+            insert_running_scan(
+                connection,
+                scan_id=scan_id,
+                workspace=workspace,
+                target=repository,
+                scope=scope,
+                diff_target=diff_target,
+                target_identity=target_identity,
+                repository_generation=registration.repository_generation,
+                source_scopes=source_scopes,
+                target_root=scan_dir.parent,
+                target_summary=None,
+                scope_file_count=scope_file_count,
+                timestamp=timestamp,
+                handoff_status="delivered",
+                scan_dir=scan_dir,
+                surface=surface,
+                package_version=package_version,
+                launch_kind=launch_kind,
+                hosted=hosted,
+            )
+            connection.execute(
+                "UPDATE scans SET recipe_json = ?, parent_scan_id = ?, user_context = ? WHERE id = ?",
+                (
+                    json.dumps(recipe, allow_nan=False, separators=(",", ":"), sort_keys=True),
+                    parent_scan_id,
+                    user_context,
+                    scan_id,
+                ),
+            )
+            if workflow_id is not None:
+                register_workflow_scan(connection, workflow_id, scan_id, str(scan_dir), timestamp)
+            if resume_target is not None:
+                archive.enter_context(
+                    register_windows_resume_output(
+                        connection, scan_id, scan_dir, resume_target, acknowledge_output_change
+                    )
+                )
+            scan = connection.execute(
+                "SELECT scans.*, snapshot AS lifecycle_json FROM scans "
+                "JOIN scan_lifecycles ON scan_id = scans.id WHERE scans.id = ?",
+                (scan_id,),
+            ).fetchone()
+            connection.commit()
+    except BaseException:
+        connection.rollback()
+        raise
     return {
+        **({"archivedScanDir": str(archived_scan_dir)} if archived_scan_dir is not None else {}),
         "contract": scan_contract(scan),
+        "lifecycle": json.loads(scan["lifecycle_json"]),
+        **({"phase": scan["phase"]} if mode == "standard" else {}),
+        **(
+            {"canSaveTimeBudgetStart": True}
+            if "maxTimeMinutes" in recipe and mode in {"standard", "diff"}
+            else {}
+        ),
         "scanDir": str(scan_dir),
         "scanId": scan_id,
         "scopeFileCount": scope_file_count,
@@ -1751,8 +1805,11 @@
     scan = require_scan(connection, args.scan_id)
     with connection:
         connection.execute(
-            "UPDATE scans SET continuation_thread_id = ?, updated_at = ? WHERE id = ?",
-            (args.thread_id, now(), scan["id"]),
+            """UPDATE scans SET continuation_thread_id = ?1, updated_at = ?2,
+               recipe_json = CASE WHEN ?3 IS NULL THEN recipe_json
+                   ELSE json_insert(recipe_json, '$.timeBudgetStartedAt', ?3) END
+               WHERE id = ?4""",
+            (args.thread_id, now(), getattr(args, "time_budget_started_at", None), scan["id"]),
         )
     return {"scanId": scan["id"], "threadId": args.thread_id}
 
@@ -1831,26 +1888,14 @@
     return recipe
 
 
-def coverage_for_comparison(scan: sqlite3.Row) -> dict[str, Any]:
-    return saved_results.coverage_for_comparison(_WORKBENCH_DB_CONTEXT, scan)
-
-
-def preserve_scan_results_locked(connection: sqlite3.Connection, scan_id: str) -> bool:
-    return saved_results.preserve_scan_results_locked(_WORKBENCH_DB_CONTEXT, connection, scan_id)
-
-
-def recover_scan_results(
-    connection: sqlite3.Connection, args: argparse.Namespace
-) -> dict[str, Any]:
-    return saved_results.recover_scan_results(_WORKBENCH_DB_CONTEXT, connection, args)
-
-
-def fail_scan(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
-    return saved_results.fail_scan(_WORKBENCH_DB_CONTEXT, connection, args)
+def coverage_summary_for_history(scan: sqlite3.Row) -> dict[str, Any]:
+    return scan_history.coverage_summary_for_history(
+        _WORKBENCH_DB_CONTEXT, scan, require_canonical_scan_directory
+    )
 
 
-def cancel_scan_locked(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
-    return saved_results.cancel_scan_locked(_WORKBENCH_DB_CONTEXT, connection, args)
+def coverage_for_comparison(scan: sqlite3.Row) -> dict[str, Any]:
+    return saved_results.coverage_for_comparison(_WORKBENCH_DB_CONTEXT, scan)
 
 
 def preserve_stopped_results_after_transition(connection: sqlite3.Connection, scan_id: str) -> None:
@@ -1872,22 +1917,13 @@
         timestamp = now()
         occurrence = require_occurrence(connection, args.occurrence_id)
         if args.status == "closed":
-            remediation = connection.execute(
-                """
-                SELECT *
-                FROM finding_remediation_attempts
-                WHERE occurrence_id = ?
-                ORDER BY created_at DESC, rowid DESC
-                LIMIT 1
-                """,
-                (occurrence["id"],),
-            ).fetchone()
+            remediation = remediation_state.latest_attempt(connection, occurrence["id"])
             if (
                 remediation is not None
                 and remediation["pending_action"] is not None
                 and not (
                     remediation["state"] == "failed"
-                    and not remediation_claim_is_active(remediation)
+                    and not remediation_state.remediation_claim_is_active(remediation)
                 )
             ):
                 raise SystemExit(
@@ -1957,7 +1993,7 @@
 ) -> dict[str, Any]:
     request_id = require_uuid(args.request_id, "request-id")
     action_token = require_uuid(args.action_token, "action-token")
-    try:
+    with connection:
         occurrence = require_occurrence(connection, args.occurrence_id)
         require_finding_open(connection, occurrence["id"])
         scan = require_scan(connection, occurrence["scan_id"])
@@ -1983,23 +2019,14 @@
                 raise SystemExit("This remediation request belongs to a different finding.")
             connection.commit()
             return scan_context(connection, occurrence["scan_id"])
-        latest = connection.execute(
-            """
-            SELECT *
-            FROM finding_remediation_attempts
-            WHERE occurrence_id = ?
-            ORDER BY created_at DESC, rowid DESC
-            LIMIT 1
-            """,
-            (occurrence["id"],),
-        ).fetchone()
+        latest = remediation_state.latest_attempt(connection, occurrence["id"])
         if latest is not None:
             active_operation = latest["pending_action"] is not None or latest["state"] in {
                 "requested",
                 "verifying",
             }
             if active_operation and (
-                latest["state"] != "failed" or remediation_claim_is_active(latest)
+                latest["state"] != "failed" or remediation_state.remediation_claim_is_active(latest)
             ):
                 raise SystemExit(
                     "Finish or retry the active remediation operation before regenerating."
@@ -2046,10 +2073,6 @@
                 timestamp,
             ),
         )
-        connection.commit()
-    except BaseException:
-        connection.rollback()
-        raise
     return scan_context(connection, occurrence["scan_id"])
 
 
@@ -2058,16 +2081,11 @@
 ) -> dict[str, Any]:
     request_id = require_uuid(args.request_id, "request-id")
     action_token = require_uuid(args.action_token, "action-token")
-    try:
+    with connection:
         occurrence = require_occurrence(connection, args.occurrence_id)
         require_finding_open(connection, occurrence["id"])
         scan = require_scan(connection, occurrence["scan_id"])
-        current = connection.execute(
-            "SELECT * FROM finding_remediation_attempts WHERE request_id = ?",
-            (request_id,),
-        ).fetchone()
-        if current is None or current["occurrence_id"] != occurrence["id"]:
-            raise SystemExit("Codex Security finding remediation request not found.")
+        current = remediation_state.require_request(connection, request_id, occurrence)
         if current["pending_action"] is not None:
             if (
                 current["pending_action"] == args.action
@@ -2122,10 +2140,6 @@
             raise SystemExit(
                 "This remediation request changed. Refresh it before recording an update."
             )
-        connection.commit()
-    except BaseException:
-        connection.rollback()
-        raise
     return scan_context(connection, occurrence["scan_id"])
 
 
@@ -2135,16 +2149,11 @@
     request_id = require_uuid(args.request_id, "request-id")
     action_token = require_uuid(args.action_token, "action-token")
     connection.execute("BEGIN IMMEDIATE")
-    try:
+    with connection:
         timestamp = now()
         occurrence = require_occurrence(connection, args.occurrence_id)
         require_finding_open(connection, occurrence["id"])
-        current = connection.execute(
-            "SELECT * FROM finding_remediation_attempts WHERE request_id = ?",
-            (request_id,),
-        ).fetchone()
-        if current is None or current["occurrence_id"] != occurrence["id"]:
-            raise SystemExit("Codex Security finding remediation request not found.")
+        current = remediation_state.require_request(connection, request_id, occurrence)
         if current["pending_action"] is None:
             raise SystemExit("This remediation attempt does not have a pending host request.")
         if current["pending_action_claim_token"] == action_token:
@@ -2154,7 +2163,6 @@
             return result
         delivered_at = current["pending_action_delivered_at"]
         if delivered_at is not None:
-            claimed_token = action_token
             updated = connection.execute(
                 """
                 UPDATE finding_remediation_attempts
@@ -2177,7 +2185,6 @@
                 "This remediation worker is still within its execution lease. Retry later."
             )
         else:
-            claimed_token = action_token
             updated = connection.execute(
                 """
                 UPDATE finding_remediation_attempts
@@ -2202,12 +2209,8 @@
             unavailable = "This remediation host request is still owned by another panel. Retry after its lease expires."
         if updated.rowcount != 1:
             raise SystemExit(unavailable)
-        connection.commit()
-    except BaseException:
-        connection.rollback()
-        raise
     result = scan_context(connection, occurrence["scan_id"])
-    result["actionToken"] = claimed_token
+    result["actionToken"] = action_token
     return result
 
 
@@ -2267,12 +2270,7 @@
         occurrence = require_occurrence(connection, args.occurrence_id)
         require_finding_open(connection, occurrence["id"])
         scan = require_scan(connection, occurrence["scan_id"])
-        current = connection.execute(
-            "SELECT * FROM finding_remediation_attempts WHERE request_id = ?",
-            (request_id,),
-        ).fetchone()
-        if current is None or current["occurrence_id"] != occurrence["id"]:
-            raise SystemExit("Codex Security finding remediation request not found.")
+        current = remediation_state.require_request(connection, request_id, occurrence)
         if current["version"] != args.expected_version:
             raise SystemExit(
                 "This remediation request changed. Refresh it before recording an update."
@@ -2283,29 +2281,24 @@
             )
         if current["pending_action_claim_token"] != action_token:
             raise SystemExit("This remediation host request is owned by a different action token.")
-        remediation.require_transition(current["state"], args.state)
-        remediation.require_pending_action(current, args.state)
-        patch_path = current["patch_path"]
-        if args.patch_path is not None:
-            requested_patch_path = require_scan_relative_file(scan, args.patch_path)
-            if patch_path is not None and requested_patch_path != patch_path:
-                raise SystemExit("A remediation attempt cannot replace its reviewed patch path.")
-            patch_path = requested_patch_path
-        patch_digest = current["patch_digest"]
-        if args.patch_digest is not None:
-            requested_patch_digest = require_sha256_digest(args.patch_digest, "patch-digest")
-            if patch_digest is not None and requested_patch_digest != patch_digest:
-                raise SystemExit("A remediation attempt cannot replace its reviewed patch digest.")
-            patch_digest = requested_patch_digest
+        remediation_state.require_transition(current["state"], args.state)
+        remediation_state.require_pending_action(current, args.state)
+        patch = sys.stdin.buffer.read() if args.patch_stdin else None
+        patch_path, patch_digest = remediation_state.patch_metadata(
+            current, args, patch, partial(require_scan_relative_file, scan)
+        )
         base_revision = optional_text(args.base_revision, maximum=512)
         if args.state in {"generated", "applied", "verifying", "verified"}:
             if patch_path is None or patch_digest is None:
                 raise SystemExit(
                     "Generated remediation states require a scan-local patch path and digest."
                 )
-            require_matching_patch_digest(scan, patch_path, patch_digest)
+            if patch is None:
+                require_matching_patch_digest(scan, patch_path, patch_digest)
         if args.state == "generated":
             require_remediation_checkout_unchanged(scan, current, require_base_content=True)
+            if patch is not None:
+                remediation_state.require_valid_patch(Path(scan["target_path"]), patch)
         if args.state in {"applied", "verifying", "verified"}:
             if base_revision != current["base_revision"]:
                 raise SystemExit(
@@ -2326,63 +2319,133 @@
                 current,
                 patch_path,
             )
-        connection.execute("BEGIN IMMEDIATE")
-        timestamp = now()
-        occurrence = require_occurrence(connection, args.occurrence_id)
-        require_finding_open(connection, occurrence["id"])
-        replace_failure_summary = current["state"] == "failed" and args.state != "failed"
-        updated = connection.execute(
-            """
-            UPDATE finding_remediation_attempts
-            SET state = ?, version = version + 1, patch_path = ?, patch_digest = ?,
-                applied_content_digest = ?,
-                pending_action = CASE
-                    WHEN ? IN ('verifying', 'failed') THEN pending_action ELSE NULL
-                END,
-                pending_action_claimed_at = CASE
-                    WHEN ? = 'verifying' THEN pending_action_claimed_at ELSE NULL
-                END,
-                pending_action_claim_token = CASE
-                    WHEN ? = 'verifying' THEN pending_action_claim_token ELSE NULL
-                END,
-                pending_action_delivered_at = CASE
-                    WHEN ? = 'verifying' THEN pending_action_delivered_at ELSE NULL
-                END,
-                summary = CASE WHEN ? THEN ? ELSE COALESCE(?, summary) END,
-                verification_summary = COALESCE(?, verification_summary),
-                updated_at = ?
-            WHERE request_id = ? AND occurrence_id = ? AND version = ?
-                AND pending_action_claim_token = ?
-            """,
-            (
-                args.state,
-                patch_path,
-                patch_digest,
-                applied_content_digest,
-                args.state,
-                args.state,
-                args.state,
-                args.state,
-                replace_failure_summary,
-                summary,
-                summary,
-                verification_summary,
-                timestamp,
-                request_id,
-                occurrence["id"],
-                args.expected_version,
-                action_token,
-            ),
-        )
-        if updated.rowcount != 1:
-            raise SystemExit(
-                "This remediation request changed. Refresh it before recording an update."
+
+        def record_update() -> None:
+            connection.execute("BEGIN IMMEDIATE")
+            timestamp = now()
+            occurrence = require_occurrence(connection, args.occurrence_id)
+            require_finding_open(connection, occurrence["id"])
+            replace_failure_summary = current["state"] == "failed" and args.state != "failed"
+            updated = connection.execute(
+                """
+                UPDATE finding_remediation_attempts
+                SET state = ?, version = version + 1, patch_path = ?, patch_digest = ?,
+                    applied_content_digest = ?,
+                    pending_action = CASE
+                        WHEN ? IN ('verifying', 'failed') THEN pending_action ELSE NULL
+                    END,
+                    pending_action_claimed_at = CASE
+                        WHEN ? = 'verifying' THEN pending_action_claimed_at ELSE NULL
+                    END,
+                    pending_action_claim_token = CASE
+                        WHEN ? = 'verifying' THEN pending_action_claim_token ELSE NULL
+                    END,
+                    pending_action_delivered_at = CASE
+                        WHEN ? = 'verifying' THEN pending_action_delivered_at ELSE NULL
+                    END,
+                    summary = CASE WHEN ? THEN ? ELSE COALESCE(?, summary) END,
+                    verification_summary = COALESCE(?, verification_summary),
+                    updated_at = ?
+                WHERE request_id = ? AND occurrence_id = ? AND version = ?
+                    AND pending_action_claim_token = ?
+                """,
+                (
+                    args.state,
+                    patch_path,
+                    patch_digest,
+                    applied_content_digest,
+                    args.state,
+                    args.state,
+                    args.state,
+                    args.state,
+                    replace_failure_summary,
+                    summary,
+                    summary,
+                    verification_summary,
+                    timestamp,
+                    request_id,
+                    occurrence["id"],
+                    args.expected_version,
+                    action_token,
+                ),
             )
-    return scan_context(connection, occurrence["scan_id"])
+            if updated.rowcount != 1:
+                raise SystemExit(
+                    "This remediation request changed. Refresh it before recording an update."
+                )
 
+        if patch is None:
+            record_update()
+        else:
+            try:
+                remediation_state.save_patch(
+                    _WORKBENCH_DB_CONTEXT,
+                    connection,
+                    scan["id"],
+                    current,
+                    patch_path,
+                    patch_digest,
+                    patch,
+                    record_update,
+                )
+            except (ContractError, OSError, SystemExit) as exc:
+                raise SystemExit(f"Could not save the remediation patch: {exc}") from exc
+    if getattr(args, "assigned_finding", False):
+        return assigned_remediation_context(
+            connection,
+            occurrence["scan_id"],
+            occurrence["id"],
+            request_id,
+            action_token,
+            written_version=args.expected_version + 1,
+        )
+    return scan_context(connection, occurrence["scan_id"], occurrence["id"])
 
-def export_findings(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
-    return publication.export_findings(_WORKBENCH_PUBLICATION_CONTEXT, connection, args)
+
+def assigned_remediation_context(
+    connection: sqlite3.Connection,
+    scan_id: str,
+    occurrence_id: str,
+    request_id: str,
+    action_token: str,
+    *,
+    written_version: int | None = None,
+) -> dict[str, Any]:
+    """After authorization, project only the assigned finding and check the returned action state."""
+    occurrence = require_occurrence(connection, occurrence_id)
+    if occurrence["details_json"] == "{}":
+        backfill_legacy_finding_details(connection, require_scan(connection, scan_id))
+        occurrence = require_occurrence(connection, occurrence_id)
+    if occurrence["scan_id"] != scan_id:
+        raise SystemExit("This finding does not belong to the selected scan.")
+    scan = require_scan(connection, scan_id)
+    finding = finding_result(connection, scan, occurrence, related=None)
+    state = finding["remediationState"]
+    if written_version is None:
+        if not (
+            state.get("requestId") == request_id
+            and state.get("actionClaimToken") == action_token
+            and state.get("pendingAction")
+        ):
+            raise SystemExit(
+                "This remediation action is no longer owned by the supplied request and action token."
+            )
+    elif (
+        state.get("requestId") != request_id
+        or state.get("version") != written_version
+        or state.get("actionClaimToken") not in (None, action_token)
+    ):
+        # The next action may already have started since this write committed.
+        return {"occurrenceId": occurrence_id, "requestId": request_id, "version": written_version}
+    return {
+        "scan": {
+            "scanId": scan["id"],
+            "targetPath": scan["target_path"],
+            "targetRevision": scan["target_revision"],
+            "scanDir": scan["scan_dir"],
+            "findings": [finding],
+        }
+    }
 
 
 def require_reviewed_patch_applied(
@@ -2390,7 +2453,9 @@
 ) -> str | None:
     target = require_scan_target_identity(scan)
     _, content_digest = remediation_checkout_snapshot(
-        scan, expected_revision=remediation["base_revision"]
+        scan,
+        expected_revision=remediation["base_revision"],
+        expected_digest=remediation["base_content_digest"],
     )
     if content_digest == remediation["base_content_digest"]:
         raise SystemExit(
@@ -2398,15 +2463,19 @@
         )
     unversioned = remediation["base_revision"] == "unversioned"
     excluded = (Path(scan["scan_dir"]),)
-    git_dir = None
-    pathspec = None
+    # Unborn repositories still need their config while metadata junctions are deferred.
+    git_dir = git_output(target, "rev-parse", "--absolute-git-dir")
+    metadata = Path(git_dir) if git_dir is not None else None
     if not unversioned:
-        _, pathspec = git_worktree_context(target)
-        git_dir = git_output(target, "rev-parse", "--absolute-git-dir")
+        repository, pathspec = git_worktree_context(target)
         if git_dir is None:
             raise SystemExit("Could not inspect the selected Git working tree.")
         excluded += tuple(path for path, _ in git_submodule_entries(target))
-    with tempfile.TemporaryDirectory(prefix="codex-security-remediation-") as temporary:
+    with (
+        tempfile.TemporaryDirectory(prefix="codex-security-remediation-") as temporary,
+        ExitStack() as pins,
+    ):
+        pinned_metadata = pin_replay_metadata(pins, metadata, Path(temporary))
         reviewed_patch = Path(temporary) / "reviewed.patch"
         digest = hashlib.sha256()
         with open_scan_local_file(Path(scan["scan_dir"]), patch_path) as source:
@@ -2419,44 +2488,52 @@
         checkout_root = Path(temporary) / "checkout"
         if unversioned:
             checkout = checkout_root
-            copy_directory_excluding(target, checkout, excluded)
+            junctions = copy_directory_excluding(target, checkout, excluded)
         else:
-            copy_git_worktree_files(target, checkout_root, excluded)
-        arguments = ["apply", "--reverse", "--whitespace=nowarn"]
-        if unversioned:
-            arguments.append("--no-index")
-        elif pathspec != ".":
-            arguments.append(f"--directory={pathspec}")
-        arguments.append(str(reviewed_patch))
-        applied = git_command(
+            _, junctions = copy_git_worktree_files(target, checkout_root, excluded)
+        short, replay_root = remediation_state.reverse_reviewed_patch(
+            target,
+            checkout_root,
+            metadata,
+            pinned_metadata,
+            remediation["patch_digest"],
+            pins,
+            reviewed_patch,
+            None if unversioned else pathspec,
+        )
+        restore_directory_junctions(
+            target if unversioned else repository,
             checkout if unversioned else checkout_root,
-            *arguments,
-            text=False,
-            git_dir=Path(git_dir) if git_dir is not None else None,
-            work_tree=checkout_root if git_dir is not None else None,
+            junctions,
         )
-        if applied.returncode != 0:
-            raise SystemExit(
-                "The selected checkout does not contain the reviewed remediation patch. Apply exactly that patch before recording it as applied."
-            )
         reverted_digest = (
-            directory_content_digest(checkout)
+            directory_content_digest(checkout, replay_git_dir=replay_root)
             if unversioned
             else worktree_content_digest_for_context(
                 checkout_root,
                 pathspec or ".",
-                git_dir=Path(git_dir),
+                git_dir=short or metadata,
                 work_tree=checkout_root,
+                expected_digest=remediation["base_content_digest"],
             )
         )
         if reverted_digest != remediation["base_content_digest"] and unversioned:
             checkout = Path(temporary) / "checkout-lf"
-            copy_directory_excluding(target, checkout, excluded)
+            junctions = copy_directory_excluding(target, checkout, excluded)
             applied_without_conversion = git_command(
-                checkout, "-c", "core.autocrlf=input", *arguments, text=True
+                checkout,
+                "-c",
+                "core.autocrlf=input",
+                "apply",
+                "--reverse",
+                "--whitespace=nowarn",
+                "--no-index",
+                str(reviewed_patch),
+                text=True,
             )
             if applied_without_conversion.returncode == 0:
-                reverted_digest = directory_content_digest(checkout)
+                restore_directory_junctions(target, checkout, junctions)
+                reverted_digest = directory_content_digest(checkout, replay_git_dir=replay_root)
         if reverted_digest != remediation["base_content_digest"]:
             raise SystemExit(
                 "The selected checkout contains changes outside the reviewed patch. Remove them before recording the patch as applied."
@@ -2471,9 +2548,6 @@
     require_applied_content: bool = False,
     require_base_content: bool = False,
 ) -> None:
-    _, content_digest = remediation_checkout_snapshot(
-        scan, expected_revision=remediation["base_revision"]
-    )
     expected_digest = (
         remediation["applied_content_digest"]
         if require_applied_content
@@ -2481,45 +2555,29 @@
         if require_base_content
         else None
     )
+    _, content_digest = remediation_checkout_snapshot(
+        scan, expected_revision=remediation["base_revision"], expected_digest=expected_digest
+    )
     if expected_digest is not None and content_digest != expected_digest:
         raise SystemExit(
             "Working-tree contents changed. Regenerate the remediation patch against the current checkout."
         )
 
 
-def require_sha256_digest(value: str, label: str) -> str:
-    normalized = optional_text(value, maximum=71)
-    if (
-        normalized is None
-        or not normalized.startswith("sha256:")
-        or len(normalized) != 71
-        or any(
-            character not in "0123456789abcdef" for character in normalized.removeprefix("sha256:")
-        )
-    ):
-        raise SystemExit(f"{label} must use sha256:<64 lowercase hex characters>.")
-    return normalized
-
-
 def require_scan_relative_file(scan: sqlite3.Row, value: str) -> str:
-    normalized = optional_text(value, maximum=4096)
-    if normalized is None or "\\" in normalized:
+    if len(value) > 4096:
+        raise SystemExit("Text value must be no longer than 4096 characters.")
+    if not value.strip() or "\\" in value:
         raise SystemExit("Patch path must identify a scan-local regular file.")
-    parsed = PurePosixPath(normalized)
+    parsed = PurePosixPath(value)
     if parsed.is_absolute() or ".." in parsed.parts:
         raise SystemExit("Patch path must identify a scan-local regular file.")
-    path = artifact_path(Path(scan["scan_dir"]), parsed.as_posix(), required=True)
-    if path is None:
-        raise SystemExit("Patch path must identify a scan-local regular file.")
+    artifact_path(Path(scan["scan_dir"]), parsed.as_posix(), required=True)
     return parsed.as_posix()
 
 
 def require_matching_patch_digest(scan: sqlite3.Row, patch_path: str, patch_digest: str) -> None:
-    digest = hashlib.sha256()
-    with open_scan_local_file(Path(scan["scan_dir"]), patch_path) as patch:
-        while chunk := patch.read(1024 * 1024):
-            digest.update(chunk)
-    if f"sha256:{digest.hexdigest()}" != patch_digest:
+    if scan_local_file_digest(Path(scan["scan_dir"]), patch_path) != patch_digest:
         raise SystemExit("Patch digest does not match the scan-local patch file.")
 
 
@@ -2566,6 +2624,11 @@
         "mode": workspace["default_mode"],
         "scope": workspace["default_scope"],
         "setup": {"submitted": bool(workspace["submitted"])},
+        **(
+            {"deepScanConfig": json.loads(workspace["deep_scan_config_json"])}
+            if workspace["deep_scan_config_json"] is not None
+            else {}
+        ),
         "setupValidation": {"error": None, "valid": bool(workspace["submitted"])},
         "targetPath": workspace["target_path"],
         "targetSummary": workspace["target_summary"],
@@ -2575,11 +2638,10 @@
     }
     selected_scan_id = result_scan_id or workspace["active_scan_id"]
     if selected_scan_id:
-        selected_scan = require_scan(connection, selected_scan_id)
-        result["userContext"] = selected_scan["user_context"]
-        result["results"] = (
-            result_scan if result_scan is not None else scan_result(connection, selected_scan)
-        )
+        if result_scan is None:
+            result_scan = scan_result(connection, require_scan(connection, selected_scan_id))
+        result["userContext"] = result_scan["userContext"]
+        result["results"] = result_scan
         return result
 
     target_metadata = None
@@ -2604,6 +2666,7 @@
                 target = require_target(workspace["target_path"])
                 target_metadata = git_target_metadata(target)
             except SystemExit:
+                # Target metadata is optional; retain the original setup error for the caller.
                 pass
     result["diffTarget"] = validated_diff_target or persisted_diff_target
     result["setupValidation"] = {
@@ -2619,10 +2682,20 @@
     connection: sqlite3.Connection,
     scan_id: str,
     occurrence_id: str | None = None,
+    *,
+    model_thread_id: str | None = None,
 ) -> dict[str, Any]:
     scan = require_scan(connection, scan_id)
-    result = scan_result(connection, scan, occurrence_id=occurrence_id)
-    workspace_result = result if occurrence_id is None else scan_result(connection, scan)
+    # Legacy backfill may write before scan_result reloads the row for its response.
+    handoff.require_tokenless_scan_owner(connection, scan, model_thread_id)
+    result = scan_result(
+        connection, scan, occurrence_id=occurrence_id, model_thread_id=model_thread_id
+    )
+    workspace_result = result
+    if len(result["findings"]) > FINDINGS_RESULT_LIMIT:
+        workspace_result = dict(
+            result, findings=result["findings"][:FINDINGS_RESULT_LIMIT], findingsTruncated=True
+        )
     workspace = workspace_state(
         connection,
         scan["workspace_id"],
@@ -2636,14 +2709,95 @@
     }
     if scan["recipe_json"] is not None:
         context["parentScanId"] = scan["parent_scan_id"]
-        context["recipe"] = json.loads(scan["recipe_json"], parse_constant=reject_non_finite_json)
+        context["recipe"] = public_scan_recipe(scan)
     return context
 
 
+def get_scan(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
+    if getattr(args, "progress_only", False):
+        scan = connection.execute(
+            """
+            SELECT scans.id, scans.mode, scans.phase, scans.status, scans.canceled_at,
+                   progress.*, progress.updated_at AS progress_updated_at
+            FROM scans JOIN scan_progress AS progress ON progress.scan_id = scans.id
+            WHERE scans.id = ?
+            """,
+            (resolve_scan_id(connection, args.scan_id),),
+        ).fetchone()
+        if scan is None:
+            raise SystemExit("Codex Security scan not found.")
+        progress_result, _ = progress.scan_progress_result(connection, scan)
+        return {"scan": {"progress": progress_result}}
+    request_id = getattr(args, "request_id", None)
+    action_token = getattr(args, "action_token", None)
+    if request_id is not None or action_token is not None:
+        scan_id = require_uuid(args.scan_id, "scan-id")
+        request_id = require_uuid(request_id or "", "request-id")
+        action_token = require_uuid(action_token or "", "action-token")
+        authorized = connection.execute(
+            """
+            SELECT 1 FROM finding_remediation_attempts AS action
+            JOIN finding_occurrences AS finding ON finding.id = action.occurrence_id
+            WHERE finding.scan_id = ? AND finding.id = ? AND action.request_id = ?
+                AND action.pending_action_claim_token = ? AND action.pending_action IS NOT NULL
+            """,
+            (scan_id, args.occurrence_id, request_id, action_token),
+        ).fetchone()
+        if authorized is None:
+            raise SystemExit(
+                "This remediation action is no longer owned by the supplied request and action token."
+            )
+        return assigned_remediation_context(
+            connection, scan_id, args.occurrence_id, request_id, action_token
+        )
+    context_claim = getattr(args, "context_claim_token", None)
+    model_thread = getattr(args, "model_thread_id", None)
+    if context_claim is not None:
+        scan = require_scan(connection, args.scan_id)
+        handoff.require_tokenless_scan_owner(connection, scan, model_thread)
+        if scan["handoff_status"] == "pending":
+            detail = (
+                "Pass the handoffClaimToken returned by the Codex Security scan launcher."
+                if scan["handoff_claim_token"]
+                else "Claim the pending Codex Security scan handoff before loading its context."
+            )
+            raise SystemExit(f"This Codex Security scan handoff has not been delivered. {detail}")
+        if context_claim:
+            context_claim = handoff.require_handoff_claim_token(context_claim)
+        if scan["handoff_claim_token"] and scan["handoff_claim_token"] != context_claim:
+            if not model_thread:
+                raise SystemExit("Scan context requires its current continuation claim.")
+            owner = (
+                scan["continuation_thread_id"]
+                or require_workspace(connection, scan["workspace_id"])["thread_id"]
+            )
+            if model_thread != owner:
+                raise SystemExit("Scan context is owned by another continuation.")
+        if (
+            args.occurrence_id is not None
+            and connection.execute(
+                "SELECT 1 FROM finding_occurrences WHERE scan_id = ? AND id = ?",
+                (scan["id"], args.occurrence_id),
+            ).fetchone()
+            is None
+        ):
+            raise SystemExit("This finding was not found in the selected scan.")
+    result = scan_context(
+        connection, args.scan_id, args.occurrence_id, model_thread_id=model_thread
+    )
+    if result["scan"]["progress"]["status"] != "running":
+        scan = require_scan(connection, args.scan_id)
+        try:
+            result["scan"] = dict(result["scan"], coverage=coverage_summary_for_history(scan))
+        except (OSError, RuntimeError, SystemExit):
+            pass  # Historical artifacts may no longer be available or verifiable.
+    return result
+
+
 def list_findings(connection: sqlite3.Connection, args: argparse.Namespace) -> dict[str, Any]:
     scan = require_scan(connection, args.scan_id)
     backfill_legacy_finding_details(connection, scan)
-    limit = min(args.limit, FINDINGS_PAGE_MAX)
+    limit = args.limit
     rows = scan_history.finding_occurrence_rows(
         connection,
         scan["id"],
@@ -2687,11 +2841,16 @@
     scan: sqlite3.Row,
     *,
     occurrence_id: str | None = None,
+    model_thread_id: str | None = None,
 ) -> dict[str, Any]:
+    """Assemble the workbench view of a saved scan, backfilling older finding details as needed.
+
+    An occurrence ID selects one finding from that scan. An occurrence belonging
+    to a different scan raises SystemExit.
+    """
     backfill_legacy_finding_details(connection, scan)
-    progress = connection.execute(
-        "SELECT * FROM scan_progress WHERE scan_id = ?", (scan["id"],)
-    ).fetchone()
+    scan = scan_history.scan_with_progress(connection, scan["id"])
+    handoff.require_tokenless_scan_owner(connection, scan, model_thread_id)
     artifact_rows = connection.execute(
         "SELECT kind, path FROM scan_artifacts WHERE scan_id = ?", (scan["id"],)
     )
@@ -2713,14 +2872,12 @@
     occurrence_rows = scan_history.finding_occurrence_rows(
         connection, scan["id"], offset=0, limit=FINDINGS_RESULT_LIMIT
     )
-    if occurrence_id is not None and all(row["id"] != occurrence_id for row in occurrence_rows):
+    if occurrence_id is not None:
         occurrence = require_occurrence(connection, occurrence_id)
         if occurrence["scan_id"] != scan["id"]:
             raise SystemExit("This finding does not belong to the selected scan.")
-        occurrence_rows.append(occurrence)
-    finding_count = connection.execute(
-        "SELECT COUNT(*) FROM finding_occurrences WHERE scan_id = ?", (scan["id"],)
-    ).fetchone()[0]
+        if all(row["id"] != occurrence["id"] for row in occurrence_rows):
+            occurrence_rows.append(occurrence)
     severity_counts = {
         row["severity"]: row["count"]
         for row in connection.execute(
@@ -2733,41 +2890,9 @@
             (scan["id"],),
         )
     }
+    finding_count = sum(severity_counts.values())
     remediation_available, remediation_unavailable_reason = remediation_availability(scan)
-    independent_reviews = (
-        deep_scan.independent_review_progress(connection, scan["id"])
-        if scan["mode"] == "deep"
-        else None
-    )
-    progress_result = {
-        "candidates": {"reportable": progress["reportable_findings_count"]},
-        "coverage": {
-            "closedRows": progress["review_items_completed"],
-            "filesTotal": progress["scope_file_count"],
-            "worklistRows": progress["review_items_total"],
-        },
-        "phase": scan["phase"],
-        "phaseProgress": {
-            "completed": progress["phase_items_completed"],
-            "total": progress["phase_items_total"],
-            "unit": progress["phase_progress_unit"],
-        },
-        "preflightProgress": {
-            "completed": progress["preflight_checks_completed"],
-            "total": progress["preflight_checks_total"],
-        },
-        "preflightIssues": json.loads(progress["preflight_issues_json"]),
-        "reviewPass": progress["deep_review_pass"],
-        "status": "canceled" if scan["canceled_at"] else scan["status"],
-        "updatedAt": progress["updated_at"],
-    }
-    if independent_reviews is not None:
-        progress_result["independentReviews"] = {
-            "active": independent_reviews["active"],
-            "completed": independent_reviews["completed"],
-            "maximum": independent_reviews["maximum"],
-            "consolidating": independent_reviews["consolidating"],
-        }
+    progress_result, review_updated_at = progress.scan_progress_result(connection, scan)
     relations = scan_history.finding_relations(
         connection, scan["id"], (row["id"] for row in occurrence_rows)
     )
@@ -2775,12 +2900,14 @@
         "artifacts": artifacts,
         **model_fields,
         "canceledAt": scan["canceled_at"],
+        "logCompletedAt": scan["log_completed_at"],
         **scan_usage.stored_scan_cost_fields(scan["cost_json"]),
         "contract": scan_contract(scan),
         "continuationThreadId": scan["continuation_thread_id"],
         "threadIds": scan_usage._scan_root_thread_ids(connection, scan, None),
         "executionThreadIds": scan_usage._scan_execution_thread_ids(connection, scan),
         "failureMessage": scan["failure_message"],
+        "lifecycle": json.loads(scan["lifecycle_json"]),
         "findings": [
             finding_result(connection, scan, row, related=relations.get(row["id"], []))
             for row in occurrence_rows
@@ -2794,6 +2921,7 @@
         "mode": scan["mode"],
         "model": scan["model"],
         "diffTarget": stored_diff_target(scan),
+        "name": scan["name"],
         "progress": progress_result,
         "reasoningEffort": scan["reasoning_effort"],
         "remediationAvailable": remediation_available,
@@ -2810,8 +2938,8 @@
         "targetSummary": scan["target_summary"],
         "updatedAt": max(
             scan["updated_at"],
-            progress["updated_at"],
-            str(independent_reviews["updatedAt"]) if independent_reviews is not None else "",
+            scan["progress_updated_at"],
+            review_updated_at,
             finding_management_updated_at(connection, scan["id"]) or "",
         ),
         "userContext": scan["user_context"],
@@ -2821,9 +2949,10 @@
 
 def remediation_availability(scan: sqlite3.Row) -> tuple[bool, str | None]:
     if scan["status"] != "complete":
-        return False, remediation.SCAN_STATUS_ERROR
+        return False, remediation_state.SCAN_STATUS_ERROR
     try:
-        current_revision = git_revision(require_scan_target_identity(scan))
+        with checked_scan_target(scan) as target:
+            current_revision = git_revision(target)
     except SystemExit as exc:
         return False, str(exc)
     expected_revision = scan["target_revision"]
@@ -2881,15 +3010,7 @@
     if not updates:
         return
 
-    # Reads normally avoid writer admission, but legacy details still need a write.
-    for attempt in range(SQLITE_RETRY_ATTEMPTS):
-        try:
-            connection.execute("BEGIN IMMEDIATE")
-            break
-        except sqlite3.OperationalError as exc:
-            if attempt == SQLITE_RETRY_ATTEMPTS - 1 or not sqlite_busy(exc):
-                raise
-            time.sleep(0.05 * (2**attempt))
+    begin_immediate_with_retry(connection)
     with connection:
         current = require_scan(connection, scan["id"])
         recorded_digest = current["seal_manifest_digest"]
@@ -2928,7 +3049,7 @@
     scan: sqlite3.Row,
     occurrence: sqlite3.Row,
     *,
-    related: list[dict[str, Any]],
+    related: list[dict[str, Any]] | None,
 ) -> dict[str, Any]:
     details = bounded_finding_details(read_finding_details(occurrence["details_json"]))
     confidence = details.get("confidence")
@@ -2936,24 +3057,35 @@
     severity = details.get("severity")
     severity = severity if isinstance(severity, dict) else {}
     locations = []
+    excerpt_locations = []
     try:
         target = require_scan_target_identity(scan)
     except SystemExit:
         target = None
     for row in connection.execute(
-        """
+        f"""
         SELECT relative_path, start_line, end_line, role
         FROM finding_locations
         WHERE occurrence_id = ?
-        ORDER BY CASE WHEN role = 'root_control' THEN 0 ELSE 1 END, sort_order
+        ORDER BY {FINDING_LOCATION_ORDER_SQL}
         LIMIT ?
         """,
         (occurrence["id"], FINDING_LOCATIONS_LIMIT),
     ):
+        display_path = bounded_output_text(row["relative_path"], FINDING_LOCATION_PATH_BYTES)
+        if display_path == row["relative_path"]:
+            excerpt_locations.append(
+                {
+                    "endLine": row["end_line"],
+                    "path": row["relative_path"],
+                    "role": row["role"],
+                    "startLine": row["start_line"],
+                }
+            )
         absolute_path = safe_source_path(target, row["relative_path"]) if target else None
         location = {
             "endLine": row["end_line"],
-            "path": bounded_output_text(row["relative_path"], FINDING_LOCATION_PATH_BYTES),
+            "path": display_path,
             "role": (
                 bounded_output_text(row["role"], FINDING_LOCATION_ROLE_BYTES)
                 if row["role"] is not None
@@ -2986,16 +3118,19 @@
         "title": bounded_output_text(occurrence["title"], FINDING_TITLE_BYTES),
         "triage": finding_triage_result(connection, occurrence["id"]),
     }
-    matches, known_since, known_scan_ids = scan_history.finding_matches(
-        connection, occurrence["id"], scan["id"], scan["started_at"]
+    if related is not None:
+        matches, known_since, known_scan_ids = scan_history.finding_matches(
+            connection, occurrence["id"], scan["id"], scan["started_at"]
+        )
+        if matches:
+            result["matches"] = matches
+            result["knownSince"] = known_since
+            result["knownScanIds"] = known_scan_ids
+        if related:
+            result["related"] = related
+    source_excerpt = finding_source_excerpt(
+        scan, target, excerpt_locations, requested_scan_paths(scan)
     )
-    if matches:
-        result["matches"] = matches
-        result["knownSince"] = known_since
-        result["knownScanIds"] = known_scan_ids
-    if related:
-        result["related"] = related
-    source_excerpt = finding_source_excerpt(scan, target, locations)
     if source_excerpt:
         result["sourceExcerpt"] = source_excerpt
     artifact_paths = finding_artifact_paths(Path(scan["scan_dir"]), details)
@@ -3074,39 +3209,10 @@
     return details if isinstance(details, dict) else {}
 
 
-def finding_management_updated_at(connection: sqlite3.Connection, scan_id: str) -> str | None:
-    return connection.execute(
-        """
-        SELECT MAX(updated_at)
-        FROM (
-            SELECT triage.updated_at
-            FROM finding_triage AS triage
-            JOIN finding_occurrences AS occurrences ON occurrences.id = triage.occurrence_id
-            WHERE occurrences.scan_id = ?
-            UNION ALL
-            SELECT remediation.updated_at
-            FROM finding_remediation_attempts AS remediation
-            JOIN finding_occurrences AS occurrences ON occurrences.id = remediation.occurrence_id
-            WHERE occurrences.scan_id = ?
-        )
-        """,
-        (scan_id, scan_id),
-    ).fetchone()[0]
+finding_management_updated_at = scan_history.finding_management_updated_at
 
 
-def finding_triage_result(connection: sqlite3.Connection, occurrence_id: str) -> dict[str, Any]:
-    row = connection.execute(
-        "SELECT status, close_reason, note, updated_at FROM finding_triage WHERE occurrence_id = ?",
-        (occurrence_id,),
-    ).fetchone()
-    if row is None:
-        return {"status": "open"}
-    return {
-        "closeReason": row["close_reason"],
-        "note": row["note"],
-        "status": row["status"],
-        "updatedAt": row["updated_at"],
-    }
+finding_triage_result = scan_history.finding_triage_result
 
 
 def finding_remediation_result(
@@ -3115,8 +3221,7 @@
     row = connection.execute(
         """
         SELECT remediation.request_id, remediation.state, remediation.version,
-            remediation.base_revision, remediation.base_content_digest,
-            remediation.applied_content_digest, remediation.pending_action,
+            remediation.base_revision, remediation.pending_action,
             remediation.pending_action_claimed_at, remediation.pending_action_claim_token,
             remediation.pending_action_delivered_at,
             remediation.patch_path, remediation.patch_digest, remediation.summary,
@@ -3157,48 +3262,9 @@
 def patch_artifact_preview(
     scan_dir: Path, relative_path: str | None, expected_digest: str | None
 ) -> tuple[str | None, dict[str, int | bool] | None]:
-    if relative_path is None or expected_digest is None:
-        return None, None
-    digest = hashlib.sha256()
-    preview = bytearray()
-    additions = 0
-    deletions = 0
-    file_count = 0
-    old_headers = 0
-    new_headers = 0
-    at_line_start = True
-    try:
-        with open_scan_local_file(scan_dir, relative_path) as patch:
-            while chunk := patch.readline(1024 * 1024):
-                digest.update(chunk)
-                if len(preview) <= PATCH_PREVIEW_BYTES:
-                    preview.extend(chunk[: PATCH_PREVIEW_BYTES + 1 - len(preview)])
-                if at_line_start:
-                    if chunk.startswith(b"diff --git "):
-                        file_count += 1
-                    elif chunk.startswith(b"+++ "):
-                        new_headers += 1
-                    elif chunk.startswith(b"--- "):
-                        old_headers += 1
-                    elif chunk.startswith(b"+"):
-                        additions += 1
-                    elif chunk.startswith(b"-"):
-                        deletions += 1
-                at_line_start = chunk.endswith(b"\n")
-    except SystemExit:
-        return None, None
-    if f"sha256:{digest.hexdigest()}" != expected_digest:
-        return None, None
-    preview_truncated = len(preview) > PATCH_PREVIEW_BYTES
-    preview_text = preview[:PATCH_PREVIEW_BYTES].decode("utf-8", errors="replace")
-    if preview_truncated:
-        preview_text = f"{preview_text}\n... patch preview truncated ..."
-    return preview_text, {
-        "additions": additions,
-        "deletions": deletions,
-        "fileCount": file_count or min(old_headers, new_headers),
-        "previewTruncated": preview_truncated,
-    }
+    return remediation_state.patch_artifact_preview(
+        scan_dir, relative_path, expected_digest, open_scan_local_file
+    )
 
 
 def available_artifact_path(scan_dir: Path, candidate: Path) -> Path | None:
@@ -3230,12 +3296,12 @@
     return resolved
 
 
-def require_canonical_scan_directory(scan_dir: Path) -> Path:
+def require_canonical_scan_directory(scan_dir: Path, *, writable_output: bool = False) -> Path:
     scan_dir = scan_dir.absolute()
     try:
         metadata = scan_dir.lstat()
         resolved = scan_dir.resolve(strict=True)
-    except OSError as exc:
+    except (OSError, RuntimeError) as exc:
         raise SystemExit(
             "Scan directory must be an existing canonical non-symlink directory."
         ) from exc
@@ -3243,10 +3309,15 @@
         scan_dir
     ):
         raise SystemExit("Scan directory must be an existing canonical non-symlink directory.")
-    # Re-check privacy so a shared parent cannot be used to substitute forged artifacts.
-    if os.name != "nt":
-        if stat.S_IMODE(metadata.st_mode) & 0o077:
-            raise SystemExit("Scan directory must not be accessible to other users (chmod 700).")
+    # Re-check ownership and parents so the scan directory cannot be substituted.
+    if os.name == "nt":
+        from windows_scan_local_files import require_windows_output_path
+
+        try:
+            require_windows_output_path(scan_dir, writable_output=writable_output)
+        except OSError as exc:
+            raise SystemExit(str(exc)) from exc
+    else:
         geteuid = getattr(os, "geteuid", None)
         effective_uid = geteuid() if geteuid is not None else None
         if effective_uid is not None and metadata.st_uid != effective_uid:
@@ -3273,109 +3344,140 @@
     return scan_dir
 
 
-def read_json_object(path: Path) -> dict[str, Any]:
-    try:
-        payload = json.loads(
-            path.read_text(encoding="utf-8"),
-            parse_constant=reject_non_finite_json,
-        )
-    except (OSError, ValueError) as exc:
-        raise SystemExit(f"{path.name}: invalid JSON: {exc}") from exc
-    if not isinstance(payload, dict):
-        raise SystemExit(f"{path.name}: expected a JSON object.")
-    return payload
+_WORKBENCH_PUBLICATION_CONTEXT = _WORKBENCH_DB_CONTEXT = SimpleNamespace(**globals())
 
 
-_WORKBENCH_PUBLICATION_CONTEXT = SimpleNamespace(**globals())
-
-
-_WORKBENCH_DB_CONTEXT = SimpleNamespace(**globals())
-
-
-def main() -> None:
+def main(*, before_archive: Callable[[], None] | None = None) -> None:
     # Workbench callers send UTF-8 even when Windows uses a legacy code page.
     sys.stdin.reconfigure(encoding="utf-8")
     args = parse_args(__doc__)
-    deep_scan.configure(
-        SimpleNamespace(
-            **globals(),
-            preserve_stopped_results=preserve_stopped_results_after_transition,
-        )
+    command_context = SimpleNamespace(
+        **globals(),
+        preserve_stopped_results=preserve_stopped_results_after_transition,
     )
+    deep_scan.configure(command_context)
     if args.command == "resolve-scan-root":
         print(json.dumps({"scanRoot": str(resolve_scan_root(args.scan_root))}))
         return
-    if args.command == "inspect-target":
-        result = inspect_target(args.target_path)
-        print(json.dumps(result, allow_nan=False, sort_keys=True))
-        return
-    if args.command == "inspect-setup":
-        result = inspect_setup_values(
-            args.target_path,
-            args.scope,
-            args.mode,
-            args.diff_target_kind,
-            args.diff_base_revision,
-            args.diff_head_revision,
-            args.diff_content_digest,
-        )
-        print(json.dumps(result, allow_nan=False, sort_keys=True))
+    if args.command in {"inspect-target", "inspect-setup"}:
+        print(json.dumps(inspect_command(args), allow_nan=False, sort_keys=True))
         return
     if args.command in {"save-artifact", "read-artifact"}:
         print(json.dumps(saved_results.read_or_save_artifact(args)))
         return
-    if args.command == "read-severity-classification":
-        result = severity.read_classification(database_path(), args.scan_id)
-        print(json.dumps(result, allow_nan=False, sort_keys=True))
-        return
-    if args.command == "inspect-linear-publication":
-        result = publication.inspect_linear_publication(_WORKBENCH_PUBLICATION_CONTEXT, args)
+    if args.command == "finding-issues":
+        try:
+            result = publication.finding_issues(
+                _WORKBENCH_PUBLICATION_CONTEXT, json.load(sys.stdin)
+            )
+        except sqlite3.OperationalError as exc:
+            if not getattr(exc, "_codex_security_state_unavailable", False):
+                raise
+            print(f"sqlite3.OperationalError: {exc}", file=sys.stderr)
+            raise SystemExit(73) from None
         print(json.dumps(result, allow_nan=False, sort_keys=True))
         return
-    with closing(
-        connect(deferred=args.command in {"get-scan", "list-scans", "database-info"})
-    ) as connection:
-        remediation.require_available(connection, args, require_scan)
-        if args.command == "create-workspace":
-            result = create_workspace(connection, args)
+    command_targets = tuple(
+        Path(value).expanduser()
+        for field in ("target_path", "repository")
+        if (value := getattr(args, field, None))
+    )
+    with (
+        closing(
+            connect(
+                deferred=args.command
+                in {
+                    "get-scan",
+                    "read-scan-usage",
+                    "list-scans",
+                    "database-info",
+                    "update-progress",
+                },
+                discovery_roots=command_targets,
+                in_memory=scan_history.reads_missing_history(args, database_path()),
+            )
+        ) as connection,
+        scoped_git_discovery(
+            lambda: [*migration_target_paths(connection), *command_targets],
+            recorded_git_roots=lambda: recorded_git_checkout_roots(connection),
+        ),
+    ):
+        remediation_state.require_available(connection, args, require_scan)
+        handlers = {
+            "create-workspace": create_workspace,
+            "save-workspace": save_workspace,
+            "start-scan": start_scan,
+            "begin-deep-scan": deep_scan.begin_deep_scan,
+            "acknowledge-deep-scan-result": deep_scan.acknowledge_deep_scan_result,
+            "get-deep-scan": deep_scan.get_deep_scan,
+            "claim-deep-scan-coordinator": deep_scan.claim_deep_scan_coordinator,
+            "upsert-deep-scan-worker": deep_scan.upsert_deep_scan_worker,
+            "record-deep-scan-iteration": deep_scan.record_deep_scan_iteration,
+            "finish-deep-scan": deep_scan.finish_deep_scan,
+            "fail-deep-scan": deep_scan.fail_deep_scan,
+            "record-deep-scan-publication-failure": deep_scan.record_deep_scan_publication_failure,
+            "list-scans": scan_history.list_scans,
+            "register-cli-scan": partial(register_cli_scan, before_archive=before_archive),
+            "restore-cli-scan-archive": partial(
+                restore_cli_scan_archive, canonical_directory=require_canonical_scan_directory
+            ),
+            "set-scan-thread": set_scan_thread,
+            "set-scan-cost-limit": set_scan_cost_limit,
+            "read-scan-usage": read_scan_usage,
+            "finalize-scan-usage": finalize_scan_usage,
+            "list-global-findings": native_indexes.list_global_findings,
+            "list-repositories": native_indexes.list_repositories,
+            "list-findings": list_findings,
+            "complete-budget-exhausted-scan": complete_budget_exhausted_scan,
+            "set-finding-triage": set_finding_triage,
+            "request-finding-remediation": request_finding_remediation,
+            "request-finding-remediation-action": request_finding_remediation_action,
+            "claim-finding-remediation-resend": claim_finding_remediation_resend,
+            "mark-finding-remediation-delivered": mark_finding_remediation_delivered,
+            "release-finding-remediation-claim": release_finding_remediation_claim,
+            "set-finding-remediation": set_finding_remediation,
+            "update-progress": partial(progress.update_progress, command_context),
+            "update-scan-context": partial(progress.update_context, command_context),
+            "cancel-scan": partial(saved_results.cancel_scan, _WORKBENCH_DB_CONTEXT),
+            "fail-scan": partial(saved_results.fail_scan, _WORKBENCH_DB_CONTEXT),
+            "preserve-scan-results": partial(
+                saved_results.preserve_scan_results, _WORKBENCH_DB_CONTEXT
+            ),
+            "recover-scan-results": partial(
+                saved_results.recover_scan_results, _WORKBENCH_DB_CONTEXT
+            ),
+            "write-scan-draft": partial(saved_results.write_scan_draft, _WORKBENCH_DB_CONTEXT),
+            "save-scan-artifact": partial(saved_results.save_scan_artifact, _WORKBENCH_DB_CONTEXT),
+            "mark-handoff-delivered": partial(handoff.mark_handoff_delivered, command_context),
+            "claim-handoff-delivery": partial(handoff.claim_handoff_delivery, command_context),
+            "release-handoff-delivery": partial(handoff.release_handoff_delivery, command_context),
+            "attach-scan-continuation-thread": partial(
+                handoff.attach_scan_continuation_thread, command_context
+            ),
+            "export-findings": partial(publication.export_findings, _WORKBENCH_PUBLICATION_CONTEXT),
+        }
+        if handler := handlers.get(args.command):
+            result = handler(connection, args)
         elif args.command == "get-workspace":
             result = workspace_state(
                 connection,
                 args.workspace_id,
                 thread_id=args.thread_id,
             )
-        elif args.command == "save-workspace":
-            result = save_workspace(connection, args)
-        elif args.command == "start-scan":
-            result = start_scan(connection, args)
         elif args.command == "start-prompt-only-scan":
             result = _start_prompt_driven_scan(connection, args, headless_standard=False)
         elif args.command == "start-headless-standard-scan":
             result = _start_prompt_driven_scan(connection, args, headless_standard=True)
-        elif args.command == "begin-deep-scan":
-            result = deep_scan.begin_deep_scan(connection, args)
-        elif args.command == "get-deep-scan":
-            result = deep_scan.get_deep_scan(connection, args)
-        elif args.command == "claim-deep-scan-coordinator":
-            result = deep_scan.claim_deep_scan_coordinator(connection, args)
-        elif args.command == "upsert-deep-scan-worker":
-            result = deep_scan.upsert_deep_scan_worker(connection, args)
-        elif args.command == "claim-deep-scan-dedup":
-            result = deep_scan.claim_deep_scan_dedup(connection, args)
-        elif args.command == "commit-deep-scan-dedup":
-            result = deep_scan.commit_deep_scan_dedup(connection, args)
-        elif args.command == "finish-deep-scan":
-            result = deep_scan.finish_deep_scan(connection, args)
-        elif args.command == "fail-deep-scan":
-            result = deep_scan.fail_deep_scan(connection, args)
-        elif args.command == "record-deep-scan-publication-failure":
-            result = deep_scan.record_deep_scan_publication_failure(connection, args)
         elif args.command == "get-scan":
-            result = scan_context(connection, args.scan_id, args.occurrence_id)
+            if args.check_target:
+                require_scan_target_unchanged(require_scan(connection, args.scan_id))
+            result = get_scan(connection, args)
+        elif args.command == "rename-scan":
+            result = scan_history.rename_scan(
+                connection, require_scan(connection, args.scan_id), args.name
+            )
         elif args.command == "get-scan-feedback":
             result = get_scan_feedback(connection, require_scan(connection, args.scan_id))
-        elif args.command == "list-scans":
-            result = scan_history.list_scans(connection, args)
         elif args.command == "list-unmatched-scan-pairs":
             result = scan_history.list_unmatched_scan_pairs(
                 connection,
@@ -3383,27 +3485,16 @@
                 backfill_finding_details=backfill_legacy_finding_details,
                 read_coverage=coverage_for_comparison,
             )
-        elif args.command == "register-cli-scan":
-            result = register_cli_scan(connection, args)
-        elif args.command == "set-scan-thread":
-            result = set_scan_thread(connection, args)
-        elif args.command == "set-scan-cost-limit":
-            result = set_scan_cost_limit(connection, args)
         elif args.command == "get-scan-recipe":
             result = scan_history.scan_recipe(require_scan(connection, args.scan_id))
         elif args.command == "get-cli-scan-resume":
             scan = require_scan(connection, args.scan_id)
             try:
                 result = scan_history.cli_scan_resume(
+                    command_context,
                     connection,
                     scan,
                     require_workspace(connection, scan["workspace_id"]),
-                    parse_scan_recipe=parse_scan_recipe,
-                    scan_contract=scan_contract,
-                    require_scan_directory=require_canonical_scan_directory,
-                    artifact_path=artifact_path,
-                    read_json_object=read_json_object,
-                    workbench_completion_binding=workbench_completion_binding,
                 )
             except SystemExit as exc:
                 if not args.allow_unavailable:
@@ -3427,122 +3518,26 @@
                 require_scan=require_scan,
                 read_coverage=coverage_for_comparison,
             )
-        elif args.command == "list-global-findings":
-            result = native_indexes.list_global_findings(connection, args)
-        elif args.command == "list-repositories":
-            result = native_indexes.list_repositories(connection, args)
-        elif args.command == "list-findings":
-            result = list_findings(connection, args)
-        elif args.command in {"update-progress", "update-scan-context"}:
-            result = progress.update(
-                connection, args, now, require_scan, require_workspace, scan_context
-            )
         elif args.command in {"prepare-scan-completion", "complete-scan"}:
             result = complete_scan(
                 connection, args, prepare_only=args.command == "prepare-scan-completion"
             )
-        elif args.command == "complete-budget-exhausted-scan":
-            result = complete_budget_exhausted_scan(connection, args)
-        elif args.command == "cancel-scan":
-            result = saved_results.cancel_scan(_WORKBENCH_DB_CONTEXT, connection, args)
-        elif args.command == "fail-scan":
-            result = fail_scan(connection, args)
-        elif args.command == "preserve-scan-results":
-            result = saved_results.preserve_scan_results(_WORKBENCH_DB_CONTEXT, connection, args)
-        elif args.command == "recover-scan-results":
-            result = recover_scan_results(connection, args)
-        elif args.command == "write-scan-draft":
-            result = saved_results.write_scan_draft(_WORKBENCH_DB_CONTEXT, connection, args)
-        elif args.command == "save-scan-artifact":
-            result = saved_results.save_scan_artifact(_WORKBENCH_DB_CONTEXT, connection, args)
-        elif args.command == "mark-handoff-delivered":
-            result = handoff.mark_handoff_delivered(
-                connection,
-                args,
-                now=now,
-                require_scan=require_scan,
-                require_workspace=require_workspace,
-                workspace_state=workspace_state,
-            )
-        elif args.command == "claim-handoff-delivery":
-            result = handoff.claim_handoff_delivery(
-                connection,
-                args,
-                now=now,
-                require_scan=require_scan,
-                stale_claim_before=stale_claim_before,
-                workspace_state=workspace_state,
-            )
-        elif args.command == "release-handoff-delivery":
-            result = handoff.release_handoff_delivery(
-                connection,
-                args,
-                now=now,
-                require_scan=require_scan,
-                workspace_state=workspace_state,
-            )
-        elif args.command == "attach-scan-continuation-thread":
-            result = handoff.attach_scan_continuation_thread(
-                connection,
-                args,
-                now=now,
-                require_scan=require_scan,
-                workspace_state=workspace_state,
-            )
-        elif args.command == "set-finding-triage":
-            result = set_finding_triage(connection, args)
-        elif args.command == "request-finding-remediation":
-            result = request_finding_remediation(connection, args)
-        elif args.command == "request-finding-remediation-action":
-            result = request_finding_remediation_action(connection, args)
-        elif args.command == "claim-finding-remediation-resend":
-            result = claim_finding_remediation_resend(connection, args)
-        elif args.command == "mark-finding-remediation-delivered":
-            result = mark_finding_remediation_delivered(connection, args)
-        elif args.command == "release-finding-remediation-claim":
-            result = release_finding_remediation_claim(connection, args)
         elif args.command == "cancel-finding-remediation-request":
             result = scan_context(
                 connection,
-                remediation.cancel_finding_remediation_request(connection, args),
-            )
-        elif args.command == "set-finding-remediation":
-            result = set_finding_remediation(connection, args)
-        elif args.command == "prepare-linear-publication":
-            result = publication.prepare_linear_publication(
-                _WORKBENCH_PUBLICATION_CONTEXT, connection, args
-            )
-        elif args.command == "record-linear-publications":
-            result = publication.record_linear_publications(
-                _WORKBENCH_PUBLICATION_CONTEXT, connection, args
+                remediation_state.cancel_finding_remediation_request(connection, args),
             )
-        elif args.command == "export-findings":
-            result = export_findings(connection, args)
         elif args.command == "database-info":
             result = {"databasePath": str(database_path())}
-        elif args.command == "severity-classification":
-            result = severity.checkpoint(connection, json.load(sys.stdin), now())
         elif args.command == "finding-workflow":
             result = finding_workflow(connection, json.load(sys.stdin), now())
-        elif args.command == "dashboard":
-            result = dashboard(connection, json.load(sys.stdin))
-        elif args.command == "store-findings":
-            payload = json.load(sys.stdin)
-            result = store_findings(
-                connection, payload["entries"], now(), payload.get("repositoryId")
-            )
-        elif args.command == "find-potential-duplicates":
-            result = find_potential_duplicates(connection, args.finding_id, args.repository_id)
-        elif args.command == "store-dedupe-groups":
-            result = store_dedupe_groups(connection, json.load(sys.stdin)["groups"], now())
-        elif args.command == "list-dedupe-groups":
-            result = list_dedupe_groups(connection, args.finding_id)
-        elif args.command == "list-stored-findings":
-            result = list_stored_findings(connection, limit=args.limit, offset=args.offset)
         else:
             raise SystemExit(f"Unknown command: {args.command}")
     print(json.dumps(result, allow_nan=False, sort_keys=True))
 
 
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    except ContractError as exc:
+        raise SystemExit(str(exc)) from None
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