← Files Codex SecurityARCHIVED FILE

shared/workbench-migrations.json

46.2 KB · Nov 18, 2026 · 06:11 UTC

↓ Download file

See the change to this file →

[
  {
    "version": 1,
    "name": "initial workbench schema",
    "statements": [
      "CREATE TABLE workspaces (\n    id TEXT PRIMARY KEY,\n    target_path TEXT,\n    target_title TEXT,\n    target_summary TEXT,\n    default_scope TEXT NOT NULL DEFAULT '.',\n    default_mode TEXT NOT NULL DEFAULT 'standard'\n        CHECK (default_mode IN ('diff', 'standard', 'deep')),\n    user_context TEXT,\n    diff_target_kind TEXT\n        CHECK (diff_target_kind IN ('working_tree', 'commit', 'range')),\n    diff_base_revision TEXT,\n    diff_head_revision TEXT,\n    diff_content_digest TEXT,\n    diff_resolution_id TEXT,\n    submitted INTEGER NOT NULL DEFAULT 0 CHECK (submitted IN (0, 1)),\n    active_scan_id TEXT REFERENCES scans(id) ON DELETE SET NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);",
      "CREATE TABLE scans (\n    id TEXT PRIMARY KEY,\n    workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,\n    target_path TEXT NOT NULL,\n    target_revision TEXT NOT NULL,\n    target_snapshot_digest TEXT,\n    scope TEXT NOT NULL,\n    mode TEXT NOT NULL CHECK (mode IN ('diff', 'standard', 'deep')),\n    user_context TEXT,\n    diff_target_kind TEXT\n        CHECK (diff_target_kind IN ('working_tree', 'commit', 'range')),\n    diff_base_revision TEXT,\n    diff_head_revision TEXT,\n    diff_content_digest TEXT,\n    scan_dir TEXT NOT NULL UNIQUE,\n    status TEXT NOT NULL CHECK (status IN ('running', 'complete', 'failed')),\n    phase TEXT NOT NULL CHECK (\n        phase IN ('preflight', 'threat_model', 'discovery', 'validation', 'attack_path', 'reporting')\n    ),\n    handoff_status TEXT NOT NULL DEFAULT 'pending'\n        CHECK (handoff_status IN ('pending', 'delivered')),\n    failure_message TEXT,\n    started_at TEXT NOT NULL,\n    completed_at TEXT,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);",
      "CREATE TABLE scan_progress (\n    scan_id TEXT PRIMARY KEY REFERENCES scans(id) ON DELETE CASCADE,\n    review_items_total INTEGER NOT NULL DEFAULT 0 CHECK (review_items_total >= 0),\n    review_items_completed INTEGER NOT NULL DEFAULT 0\n        CHECK (review_items_completed >= 0 AND review_items_completed <= review_items_total),\n    reportable_findings_count INTEGER NOT NULL DEFAULT 0\n        CHECK (reportable_findings_count >= 0),\n    deep_review_pass INTEGER CHECK (deep_review_pass IS NULL OR deep_review_pass >= 1),\n    updated_at TEXT NOT NULL\n);",
      "CREATE TABLE scan_artifacts (\n    scan_id TEXT NOT NULL REFERENCES scans(id) ON DELETE CASCADE,\n    kind TEXT NOT NULL CHECK (\n        kind IN ('coverage', 'findings', 'manifest', 'markdownReport')\n    ),\n    path TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    PRIMARY KEY (scan_id, kind)\n);",
      "CREATE TABLE findings (\n    id TEXT PRIMARY KEY,\n    fingerprint TEXT NOT NULL UNIQUE,\n    rule_id TEXT NOT NULL,\n    identity_anchor TEXT NOT NULL,\n    identity_instance TEXT,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);",
      "CREATE TABLE finding_occurrences (\n    id TEXT PRIMARY KEY,\n    finding_id TEXT NOT NULL REFERENCES findings(id),\n    scan_id TEXT NOT NULL REFERENCES scans(id) ON DELETE CASCADE,\n    title TEXT NOT NULL,\n    summary TEXT NOT NULL,\n    severity TEXT NOT NULL,\n    confidence TEXT NOT NULL,\n    remediation TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    UNIQUE (scan_id, finding_id)\n);",
      "CREATE TABLE finding_locations (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    occurrence_id TEXT NOT NULL REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    relative_path TEXT NOT NULL,\n    start_line INTEGER NOT NULL CHECK (start_line >= 1),\n    end_line INTEGER NOT NULL CHECK (end_line >= start_line),\n    role TEXT,\n    sort_order INTEGER NOT NULL CHECK (sort_order >= 0),\n    UNIQUE (occurrence_id, sort_order)\n);",
      "CREATE UNIQUE INDEX scans_one_running_per_workspace\nON scans(workspace_id)\nWHERE status = 'running';"
    ]
  },
  {
    "version": 2,
    "name": "persist capability preflight summaries",
    "statements": [
      "ALTER TABLE workspaces ADD COLUMN capability_preflight_json TEXT;"
    ]
  },
  {
    "version": 3,
    "name": "finding management schema",
    "statements": [
      "CREATE TABLE finding_triage (\n    occurrence_id TEXT PRIMARY KEY REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    status TEXT NOT NULL CHECK (status IN ('open', 'closed')),\n    close_reason TEXT CHECK (\n        close_reason IS NULL OR close_reason IN ('already_fixed', 'wont_fix', 'false_positive')\n    ),\n    note TEXT,\n    updated_at TEXT NOT NULL,\n    CHECK (\n        (status = 'open' AND close_reason IS NULL)\n        OR (status = 'closed' AND close_reason IS NOT NULL)\n    )\n);",
      "CREATE TABLE finding_remediation_attempts (\n    request_id TEXT PRIMARY KEY,\n    occurrence_id TEXT NOT NULL REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    state TEXT NOT NULL CHECK (\n        state IN ('idle', 'requested', 'generated', 'applied', 'verifying', 'verified', 'failed', 'superseded')\n    ),\n    version INTEGER NOT NULL CHECK (version >= 1),\n    base_revision TEXT NOT NULL,\n    base_content_digest TEXT,\n    applied_content_digest TEXT,\n    pending_action TEXT CHECK (\n        pending_action IS NULL OR pending_action IN ('generate', 'apply', 'verify')\n    ),\n    patch_path TEXT,\n    patch_digest TEXT,\n    summary TEXT,\n    verification_summary TEXT,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);",
      "CREATE INDEX finding_remediation_attempts_by_occurrence\nON finding_remediation_attempts(occurrence_id, created_at DESC);",
      "ALTER TABLE finding_occurrences\nADD COLUMN details_json TEXT NOT NULL DEFAULT '{}';"
    ]
  },
  {
    "version": 4,
    "name": "scan handoff delivery claims",
    "statements": [
      "ALTER TABLE scans\nADD COLUMN handoff_claimed_at TEXT;",
      "ALTER TABLE scans\nADD COLUMN handoff_claim_token TEXT;"
    ]
  },
  {
    "version": 5,
    "name": "finding remediation action claims",
    "statements": [
      "ALTER TABLE finding_remediation_attempts\nADD COLUMN pending_action_claimed_at TEXT;",
      "ALTER TABLE finding_remediation_attempts\nADD COLUMN pending_action_claim_token TEXT;"
    ]
  },
  {
    "version": 6,
    "name": "thread-scoped workspaces",
    "statements": [
      "ALTER TABLE workspaces\nADD COLUMN thread_id TEXT;",
      "CREATE INDEX workspaces_by_thread_and_updated_at\nON workspaces(thread_id, updated_at DESC);"
    ]
  },
  {
    "version": 7,
    "name": "remediation host delivery state",
    "statements": [
      "ALTER TABLE finding_remediation_attempts\nADD COLUMN pending_action_delivered_at TEXT;"
    ]
  },
  {
    "version": 8,
    "name": "sealed manifest digests",
    "statements": ["ALTER TABLE scans\nADD COLUMN seal_manifest_digest TEXT;"]
  },
  {
    "version": 9,
    "name": "scan target filesystem identity",
    "statements": [
      "ALTER TABLE scans\nADD COLUMN target_device INTEGER;",
      "ALTER TABLE scans\nADD COLUMN target_inode INTEGER;"
    ]
  },
  {
    "version": 10,
    "name": "scan cancellation state",
    "statements": ["ALTER TABLE scans\nADD COLUMN canceled_at TEXT;"]
  },
  {
    "version": 11,
    "name": "deep scan orchestration state",
    "statements": [
      "ALTER TABLE scans\nADD COLUMN deep_scan_owner_thread_id TEXT;",
      "UPDATE scans\nSET deep_scan_owner_thread_id = (\n    SELECT workspaces.thread_id\n    FROM workspaces\n    WHERE workspaces.id = scans.workspace_id\n)\nWHERE mode = 'deep'\n    AND status = 'running'\n    AND id IN (\n        SELECT MIN(active_scans.id)\n        FROM scans AS active_scans\n        JOIN workspaces AS active_workspaces\n            ON active_workspaces.id = active_scans.workspace_id\n        WHERE active_scans.mode = 'deep'\n            AND active_scans.status = 'running'\n            AND active_workspaces.thread_id IS NOT NULL\n        GROUP BY active_workspaces.thread_id,\n            active_scans.target_path,\n            active_scans.scope\n    );",
      "CREATE UNIQUE INDEX scans_one_running_deep_per_owner_target\nON scans(deep_scan_owner_thread_id, target_path, scope)\nWHERE mode = 'deep'\n    AND status = 'running'\n    AND deep_scan_owner_thread_id IS NOT NULL;",
      "CREATE TABLE deep_scan_runs (\n    scan_id TEXT PRIMARY KEY REFERENCES scans(id) ON DELETE CASCADE,\n    schema_version INTEGER NOT NULL CHECK (schema_version = 1),\n    workflow_version TEXT NOT NULL,\n    coordinator_generation INTEGER NOT NULL DEFAULT 1\n        CHECK (coordinator_generation >= 1),\n    status TEXT NOT NULL CHECK (\n        status IN ('running', 'succeeded', 'failed', 'canceled', 'interrupted')\n    ),\n    phase TEXT NOT NULL CHECK (\n        phase IN ('setup', 'discovery', 'reducing', 'terminal')\n    ),\n    workers INTEGER NOT NULL CHECK (workers >= 1),\n    subagents INTEGER NOT NULL CHECK (subagents >= 0),\n    stop_after_no_new INTEGER NOT NULL CHECK (stop_after_no_new >= 1),\n    max_discovery_runs INTEGER NOT NULL CHECK (max_discovery_runs >= 1),\n    discovery_runs_dispatched INTEGER NOT NULL DEFAULT 0\n        CHECK (discovery_runs_dispatched >= 0),\n    completion_sequence INTEGER NOT NULL DEFAULT 0\n        CHECK (completion_sequence >= 0),\n    consecutive_no_new INTEGER NOT NULL DEFAULT 0\n        CHECK (consecutive_no_new >= 0),\n    cancel_requested INTEGER NOT NULL DEFAULT 0\n        CHECK (cancel_requested IN (0, 1)),\n    canonical_inventory_path TEXT,\n    canonical_finding_report_path TEXT,\n    canonical_candidates_path TEXT,\n    dedupe_report_path TEXT,\n    seed_research_path TEXT,\n    work_ledger_path TEXT,\n    raw_candidates_path TEXT,\n    coverage_ledger_path TEXT,\n    findings_dir TEXT,\n    manifest_path TEXT,\n    terminal_reason TEXT CHECK (\n        terminal_reason IS NULL OR terminal_reason IN ('saturated', 'capped')\n    ),\n    error_message TEXT,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    completed_at TEXT,\n    CHECK (\n        (\n            canonical_inventory_path IS NULL\n            AND canonical_finding_report_path IS NULL\n            AND canonical_candidates_path IS NULL\n            AND dedupe_report_path IS NULL\n            AND seed_research_path IS NULL\n            AND work_ledger_path IS NULL\n            AND raw_candidates_path IS NULL\n            AND coverage_ledger_path IS NULL\n            AND findings_dir IS NULL\n        ) OR (\n            canonical_inventory_path IS NOT NULL\n            AND canonical_finding_report_path IS NOT NULL\n            AND canonical_candidates_path IS NOT NULL\n            AND dedupe_report_path IS NOT NULL\n            AND seed_research_path IS NOT NULL\n            AND work_ledger_path IS NOT NULL\n            AND raw_candidates_path IS NOT NULL\n            AND coverage_ledger_path IS NOT NULL\n            AND findings_dir IS NOT NULL\n        )\n    )\n);",
      "CREATE TABLE deep_scan_workers (\n    id TEXT PRIMARY KEY,\n    scan_id TEXT NOT NULL REFERENCES deep_scan_runs(scan_id) ON DELETE CASCADE,\n    kind TEXT NOT NULL CHECK (kind IN ('setup', 'discovery', 'dedup')),\n    status TEXT NOT NULL CHECK (\n        status IN ('queued', 'running', 'succeeded', 'failed', 'canceled')\n    ),\n    merge_state TEXT NOT NULL DEFAULT 'none' CHECK (\n        merge_state IN ('none', 'buffered', 'merging', 'merged')\n    ),\n    prompt_path TEXT NOT NULL,\n    artifact_dir TEXT NOT NULL,\n    result_manifest_path TEXT,\n    attempt INTEGER NOT NULL DEFAULT 0 CHECK (attempt >= 0),\n    sdk_thread_id TEXT,\n    completion_sequence INTEGER CHECK (completion_sequence >= 1),\n    error_message TEXT,\n    created_at TEXT NOT NULL,\n    started_at TEXT,\n    completed_at TEXT,\n    updated_at TEXT NOT NULL,\n    UNIQUE (scan_id, id),\n    CHECK (kind = 'discovery' OR merge_state = 'none'),\n    CHECK (kind = 'discovery' OR completion_sequence IS NULL)\n);",
      "CREATE UNIQUE INDEX deep_scan_workers_completion_sequence\nON deep_scan_workers(scan_id, completion_sequence)\nWHERE completion_sequence IS NOT NULL;",
      "CREATE INDEX deep_scan_workers_by_scan_status\nON deep_scan_workers(scan_id, status, kind, created_at);",
      "CREATE TABLE deep_scan_dedup_inputs (\n    scan_id TEXT NOT NULL,\n    dedup_worker_id TEXT NOT NULL,\n    discovery_worker_id TEXT NOT NULL,\n    input_order INTEGER NOT NULL CHECK (input_order >= 0),\n    PRIMARY KEY (dedup_worker_id, discovery_worker_id),\n    UNIQUE (dedup_worker_id, input_order),\n    FOREIGN KEY (scan_id, dedup_worker_id)\n        REFERENCES deep_scan_workers(scan_id, id) ON DELETE CASCADE,\n    FOREIGN KEY (scan_id, discovery_worker_id)\n        REFERENCES deep_scan_workers(scan_id, id) ON DELETE CASCADE\n);"
    ]
  },
  {
    "version": 12,
    "name": "scan continuation threads",
    "statements": ["ALTER TABLE scans\nADD COLUMN continuation_thread_id TEXT;"]
  },
  {
    "version": 13,
    "name": "scan scope file counts",
    "statements": [
      "ALTER TABLE scan_progress\nADD COLUMN scope_file_count INTEGER\n    CHECK (scope_file_count >= 0);"
    ]
  },
  {
    "version": 14,
    "name": "imported triage results",
    "statements": [
      "CREATE TABLE triage_results (\n    id TEXT PRIMARY KEY,\n    repository_path TEXT NOT NULL,\n    repository_revision TEXT,\n    finding_count INTEGER NOT NULL CHECK (finding_count >= 0),\n    result_json TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);",
      "CREATE INDEX triage_results_by_updated_at\nON triage_results(updated_at DESC, id);"
    ]
  },
  {
    "version": 15,
    "name": "append-only finding decisions",
    "statements": [
      "CREATE TABLE finding_decisions (\n    id TEXT PRIMARY KEY,\n    occurrence_id TEXT NOT NULL REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    status TEXT NOT NULL CHECK (status IN ('open', 'closed')),\n    close_reason TEXT CHECK (\n        close_reason IS NULL OR close_reason IN ('already_fixed', 'wont_fix', 'false_positive')\n    ),\n    note TEXT,\n    created_at TEXT NOT NULL,\n    CHECK (\n        (status = 'open' AND close_reason IS NULL)\n        OR (status = 'closed' AND close_reason IS NOT NULL)\n    )\n);",
      "CREATE INDEX finding_decisions_by_occurrence\nON finding_decisions(occurrence_id, created_at DESC, id DESC);",
      "INSERT INTO finding_decisions (\n    id, occurrence_id, status, close_reason, note, created_at\n)\nSELECT\n    'legacy_' || occurrence_id,\n    occurrence_id,\n    status,\n    close_reason,\n    note,\n    updated_at\nFROM finding_triage;"
    ]
  },
  {
    "version": 16,
    "name": "stable repository targets",
    "statements": [
      "CREATE TABLE security_targets (\n    id TEXT PRIMARY KEY,\n    current_path TEXT NOT NULL UNIQUE,\n    display_name TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);",
      "ALTER TABLE workspaces\nADD COLUMN target_id TEXT REFERENCES security_targets(id);",
      "ALTER TABLE scans\nADD COLUMN target_id TEXT REFERENCES security_targets(id);",
      "CREATE INDEX scans_by_target\nON scans(target_id, started_at DESC, id);"
    ]
  },
  {
    "version": 17,
    "name": "scan target summaries",
    "statements": ["ALTER TABLE scans\nADD COLUMN target_summary TEXT;"]
  },
  {
    "version": 18,
    "name": "clear legacy delivered handoff claims",
    "statements": [
      "UPDATE scans\nSET handoff_claimed_at = NULL, handoff_claim_token = NULL\nWHERE handoff_status = 'delivered';"
    ]
  },
  {
    "version": 19,
    "name": "persist setup workspace preference",
    "statements": [
      "CREATE TABLE setup_preferences (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    skip_setup_ui INTEGER NOT NULL CHECK (skip_setup_ui IN (0, 1)),\n    updated_at TEXT NOT NULL\n);"
    ]
  },
  {
    "version": 20,
    "name": "phase-specific scan progress",
    "statements": [
      "ALTER TABLE scan_progress\nADD COLUMN phase_items_total INTEGER NOT NULL DEFAULT 0\n    CHECK (phase_items_total >= 0);",
      "ALTER TABLE scan_progress\nADD COLUMN phase_items_completed INTEGER NOT NULL DEFAULT 0\n    CHECK (phase_items_completed >= 0 AND phase_items_completed <= phase_items_total);",
      "ALTER TABLE scan_progress\nADD COLUMN phase_progress_unit TEXT CHECK (\n    phase_progress_unit IS NULL OR phase_progress_unit IN (\n        'checks',\n        'threat_surfaces',\n        'review_receipts',\n        'candidate_findings',\n        'validated_findings',\n        'report_artifacts'\n    )\n);"
    ]
  },
  {
    "version": 21,
    "name": "current scan preflight state",
    "statements": [
      "ALTER TABLE scan_progress\nADD COLUMN preflight_issues_json TEXT NOT NULL DEFAULT '[]';",
      "ALTER TABLE scan_progress\nADD COLUMN preflight_checks_total INTEGER NOT NULL DEFAULT 0\n    CHECK (preflight_checks_total >= 0);",
      "ALTER TABLE scan_progress\nADD COLUMN preflight_checks_completed INTEGER NOT NULL DEFAULT 0\n    CHECK (\n        preflight_checks_completed >= 0\n        AND preflight_checks_completed <= preflight_checks_total\n    );"
    ]
  },
  {
    "version": 22,
    "name": "replayable scan launch recipes",
    "statements": [
      "ALTER TABLE scans ADD COLUMN recipe_json TEXT;",
      "ALTER TABLE scans ADD COLUMN parent_scan_id TEXT REFERENCES scans(id) ON DELETE SET NULL;"
    ]
  },
  {
    "version": 23,
    "name": "semantic scan comparison matches",
    "statements": [
      "CREATE TABLE scan_comparisons (\n    before_scan_id TEXT NOT NULL REFERENCES scans(id) ON DELETE CASCADE,\n    after_scan_id TEXT NOT NULL REFERENCES scans(id) ON DELETE CASCADE,\n    result_json TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    PRIMARY KEY (before_scan_id, after_scan_id),\n    CHECK (before_scan_id != after_scan_id)\n);",
      "CREATE TABLE scan_comparison_matches (\n    before_scan_id TEXT NOT NULL,\n    after_scan_id TEXT NOT NULL,\n    before_occurrence_id TEXT NOT NULL\n        REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    after_occurrence_id TEXT NOT NULL\n        REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    reason TEXT NOT NULL,\n    PRIMARY KEY (\n        before_scan_id, after_scan_id, before_occurrence_id, after_occurrence_id\n    ),\n    FOREIGN KEY (before_scan_id, after_scan_id)\n        REFERENCES scan_comparisons(before_scan_id, after_scan_id) ON DELETE CASCADE\n);",
      "CREATE INDEX scan_comparison_matches_by_before_occurrence\nON scan_comparison_matches(before_occurrence_id);",
      "CREATE INDEX scan_comparison_matches_by_after_occurrence\nON scan_comparison_matches(after_occurrence_id);"
    ]
  },
  {
    "version": 24,
    "name": "persist scan cost estimates",
    "statements": ["ALTER TABLE scans ADD COLUMN cost_json TEXT;"]
  },
  {
    "version": 25,
    "name": "persist scan model settings",
    "statements": [
      "ALTER TABLE scans ADD COLUMN model TEXT;",
      "ALTER TABLE scans ADD COLUMN reasoning_effort TEXT;"
    ]
  },
  {
    "version": 26,
    "name": "persist scan completion warnings",
    "statements": [
      "ALTER TABLE scans\nADD COLUMN completion_warnings_json TEXT NOT NULL DEFAULT '[]';"
    ]
  },
  {
    "version": 27,
    "name": "persist deep scan consecutive discovery failures",
    "statements": [
      "ALTER TABLE deep_scan_runs\nADD COLUMN stop_after_consecutive_errors INTEGER NOT NULL DEFAULT 1\n    CHECK (stop_after_consecutive_errors >= 1);",
      "ALTER TABLE deep_scan_runs\nADD COLUMN consecutive_errors INTEGER NOT NULL DEFAULT 0\n    CHECK (consecutive_errors >= 0);",
      "UPDATE deep_scan_runs\nSET stop_after_consecutive_errors = stop_after_no_new;"
    ]
  },
  {
    "version": 28,
    "name": "persist deep scan discovery time limit",
    "statements": [
      "ALTER TABLE deep_scan_runs\nADD COLUMN max_time_hours REAL NOT NULL DEFAULT 96;"
    ]
  },
  {
    "version": 29,
    "name": "persist finding publication associations",
    "statements": [
      "CREATE TABLE finding_publications (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    scan_id TEXT NOT NULL REFERENCES scans(id) ON DELETE CASCADE,\n    finding_id TEXT NOT NULL REFERENCES findings(id),\n    occurrence_id TEXT NOT NULL\n        REFERENCES finding_occurrences(id) ON DELETE CASCADE,\n    destination_type TEXT NOT NULL,\n    team_id TEXT,\n    project_id TEXT,\n    external_id TEXT NOT NULL,\n    external_url TEXT,\n    created_at TEXT NOT NULL,\n    UNIQUE (occurrence_id, destination_type, team_id, project_id, external_id),\n    UNIQUE (destination_type, team_id, project_id, external_id)\n);",
      "CREATE INDEX finding_publications_by_scan\nON finding_publications(scan_id, occurrence_id, id);",
      "CREATE INDEX finding_publications_by_finding\nON finding_publications(finding_id, id);"
    ]
  },
  {
    "version": 30,
    "name": "preserve team-only finding publication associations",
    "statements": [
      "CREATE UNIQUE INDEX finding_publications_team_only_occurrence\nON finding_publications(occurrence_id, destination_type, team_id, external_id)\nWHERE project_id IS NULL;",
      "CREATE UNIQUE INDEX finding_publications_team_only_external_issue\nON finding_publications(destination_type, team_id, external_id)\nWHERE project_id IS NULL;"
    ]
  },
  {
    "version": 31,
    "name": "freeze stopped scan source digests",
    "statements": [
      "ALTER TABLE scans ADD COLUMN retained_source_digests_json TEXT;"
    ]
  },
  {
    "version": 32,
    "name": "separate deep scan publication failures",
    "statements": [
      "ALTER TABLE deep_scan_runs ADD COLUMN publication_error_message TEXT;"
    ]
  },
  {
    "version": 33,
    "name": "store complete findings and embeddings without a scan",
    "statements": [
      "ALTER TABLE findings ADD COLUMN details_json TEXT;",
      "UPDATE findings SET details_json = (\n    SELECT details_json FROM finding_occurrences\n    WHERE finding_id = findings.id AND details_json != '{}'\n    ORDER BY created_at DESC, id DESC LIMIT 1\n);",
      "CREATE TABLE finding_embeddings (\n    finding_id TEXT PRIMARY KEY REFERENCES findings(id) ON DELETE CASCADE,\n    model TEXT NOT NULL,\n    vector_json TEXT NOT NULL\n);",
      "CREATE TRIGGER invalidate_finding_embedding\nAFTER UPDATE OF details_json ON findings\nWHEN OLD.details_json IS NOT NEW.details_json\nBEGIN\n    DELETE FROM finding_embeddings WHERE finding_id = NEW.id;\nEND;"
    ]
  },
  {
    "version": 34,
    "name": "associate findings with repositories",
    "statements": [
      "CREATE TABLE finding_repositories (\n    repository_id TEXT NOT NULL,\n    finding_id TEXT NOT NULL REFERENCES findings(id) ON DELETE CASCADE,\n    PRIMARY KEY (repository_id, finding_id)\n);",
      "INSERT OR IGNORE INTO finding_repositories (repository_id, finding_id)\nSELECT scans.target_id, finding_occurrences.finding_id\nFROM finding_occurrences JOIN scans ON scans.id = finding_occurrences.scan_id\nWHERE scans.target_id IS NOT NULL;"
    ]
  },
  {
    "version": 35,
    "name": "persist finding dedupe groups",
    "statements": [
      "CREATE TABLE finding_dedupe_groups (\n    id TEXT PRIMARY KEY,\n    created_at TEXT NOT NULL\n);",
      "CREATE TABLE finding_dedupe_group_members (\n    group_id TEXT NOT NULL REFERENCES finding_dedupe_groups(id) ON DELETE CASCADE,\n    finding_id TEXT NOT NULL REFERENCES findings(id),\n    PRIMARY KEY (group_id, finding_id)\n);",
      "CREATE INDEX finding_dedupe_groups_by_finding\nON finding_dedupe_group_members(finding_id, group_id);"
    ]
  },
  {
    "version": 36,
    "name": "persist local findings workflows",
    "statements": [
      "CREATE TABLE finding_workflows (\n    id TEXT PRIMARY KEY,\n    state_json TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n);"
    ]
  },
  {
    "version": 37,
    "name": "checkpoint validated dedupe reviews",
    "statements": [
      "CREATE TABLE finding_workflow_reviews (\n    workflow_id TEXT NOT NULL REFERENCES finding_workflows(id) ON DELETE CASCADE,\n    review_key TEXT NOT NULL,\n    binding_json TEXT NOT NULL,\n    result_json TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    PRIMARY KEY (workflow_id, review_key)\n);"
    ]
  },
  {
    "version": 38,
    "name": "store findings workflow metadata in columns",
    "statements": [
      "ALTER TABLE finding_workflows RENAME COLUMN state_json TO results_json;",
      "ALTER TABLE finding_workflows ADD COLUMN repository_path TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN scan_request_digest TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN scan_id TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN scan_dir TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN artifact_digest TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN destination TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN scope_repository_id TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN scope_all_repositories INTEGER;",
      "ALTER TABLE finding_workflows ADD COLUMN scan_status TEXT NOT NULL DEFAULT 'pending';",
      "ALTER TABLE finding_workflows ADD COLUMN scan_error TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN publish_status TEXT NOT NULL DEFAULT 'pending';",
      "ALTER TABLE finding_workflows ADD COLUMN publish_error TEXT;",
      "ALTER TABLE finding_workflows ADD COLUMN dedupe_status TEXT NOT NULL DEFAULT 'pending';",
      "ALTER TABLE finding_workflows ADD COLUMN dedupe_error TEXT;",
      "UPDATE finding_workflows SET\n    repository_path = json_extract(results_json, '$.repositoryPath'),\n    scan_request_digest = json_extract(results_json, '$.scanRequestDigest'),\n    scan_id = json_extract(results_json, '$.scanId'),\n    scan_dir = json_extract(results_json, '$.scanDir'),\n    artifact_digest = json_extract(results_json, '$.artifactDigest'),\n    destination = json_extract(results_json, '$.destination'),\n    scope_repository_id = json_extract(results_json, '$.scope.repositoryId'),\n    scope_all_repositories = json_extract(results_json, '$.scope.allRepositories'),\n    scan_status = json_extract(results_json, '$.stages.scan.status'),\n    publish_status = json_extract(results_json, '$.stages.publish.status'),\n    dedupe_status = json_extract(results_json, '$.stages.dedupe.status');"
    ]
  },
  {
    "version": 39,
    "name": "store dedupe checkpoint bindings in columns",
    "statements": [
      "ALTER TABLE finding_workflow_reviews RENAME COLUMN binding_json TO prompt_digest;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN review_contract_version INTEGER;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN codex_version TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN source_repository_path TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN source_revision TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN source_refs_digest TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN source_content_digest TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN scope_repository_id TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN scope_all_repositories INTEGER;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN model TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN effort TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN settings_digest TEXT;",
      "ALTER TABLE finding_workflow_reviews ADD COLUMN contract_digest TEXT;",
      "UPDATE finding_workflow_reviews SET\n    review_contract_version = json_extract(prompt_digest, '$.version'),\n    codex_version = json_extract(prompt_digest, '$.codexVersion'),\n    source_repository_path = json_extract(prompt_digest, '$.source.repository'),\n    source_revision = json_extract(prompt_digest, '$.source.revision'),\n    source_refs_digest = json_extract(prompt_digest, '$.source.refsDigest'),\n    source_content_digest = json_extract(prompt_digest, '$.source.content'),\n    scope_repository_id = json_extract(prompt_digest, '$.scope.repositoryId'),\n    scope_all_repositories = json_extract(prompt_digest, '$.scope.allRepositories'),\n    model = json_extract(prompt_digest, '$.model'),\n    effort = json_extract(prompt_digest, '$.effort'),\n    settings_digest = json_extract(prompt_digest, '$.settingsDigest'),\n    contract_digest = json_extract(prompt_digest, '$.contractDigest'),\n    prompt_digest = json_extract(prompt_digest, '$.promptDigest');"
    ]
  },
  {
    "version": 40,
    "name": "index finding identity and comparison history",
    "statements": [
      "CREATE INDEX finding_occurrences_by_finding\nON finding_occurrences(finding_id, id);",
      "CREATE INDEX scan_comparisons_by_after_scan\nON scan_comparisons(after_scan_id, before_scan_id);"
    ]
  },
  {
    "version": 41,
    "name": "checkpoint finding severity assessments",
    "statements": [
      "CREATE TABLE finding_severity_assessments (\n    finding_id TEXT PRIMARY KEY REFERENCES findings(id) ON DELETE CASCADE,\n    occurrence_id TEXT,\n    input_sha256 TEXT NOT NULL,\n    rubric_sha256 TEXT,\n    knowledge_base_sha256 TEXT,\n    assessed_at TEXT NOT NULL,\n    source TEXT NOT NULL CHECK (source IN ('existing-severity', 'rubric')),\n    decision TEXT NOT NULL CHECK (decision IN ('assessed', 'excluded')),\n    level TEXT CHECK (level IN ('critical', 'high', 'medium', 'low', 'informational')),\n    rubric_label TEXT,\n    rationale TEXT NOT NULL,\n    confidence TEXT CHECK (confidence IN ('high', 'medium', 'low')),\n    review_trigger TEXT,\n    CHECK ((decision = 'assessed' AND level IS NOT NULL)\n        OR (decision = 'excluded' AND level IS NULL AND rubric_label IS NULL))\n);",
      "CREATE TABLE scan_severity_classifications (\n    scan_id TEXT PRIMARY KEY,\n    finding_ids_json TEXT NOT NULL,\n    assessed_at TEXT NOT NULL,\n    rubric_sha256 TEXT,\n    knowledge_base_sha256 TEXT\n);"
    ]
  },
  {
    "version": 42,
    "name": "editable scan names",
    "statements": ["ALTER TABLE scans ADD COLUMN name TEXT;"]
  },
  {
    "version": 43,
    "name": "preserve severity assessments per scan",
    "statements": [
      "CREATE TABLE scan_severity_assessments (\n            scan_id TEXT NOT NULL REFERENCES scan_severity_classifications(scan_id) ON DELETE CASCADE,\n            finding_id TEXT NOT NULL REFERENCES findings(id) ON DELETE CASCADE,\n            occurrence_id TEXT,\n            input_sha256 TEXT NOT NULL,\n            rubric_sha256 TEXT,\n            knowledge_base_sha256 TEXT,\n            assessed_at TEXT NOT NULL,\n            source TEXT NOT NULL CHECK (source IN ('existing-severity', 'rubric')),\n            decision TEXT NOT NULL CHECK (decision IN ('assessed', 'excluded')),\n            level TEXT CHECK (level IN ('critical', 'high', 'medium', 'low', 'informational')),\n            rubric_label TEXT,\n            rationale TEXT NOT NULL,\n            confidence TEXT CHECK (confidence IN ('high', 'medium', 'low')),\n            review_trigger TEXT,\n            PRIMARY KEY (scan_id, finding_id),\n            CHECK ((decision = 'assessed' AND level IS NOT NULL)\n                OR (decision = 'excluded' AND level IS NULL AND rubric_label IS NULL))\n        );",
      "INSERT INTO scan_severity_assessments\n        SELECT classification.scan_id, assessment.*\n        FROM scan_severity_classifications AS classification\n        CROSS JOIN json_each(classification.finding_ids_json) AS selected\n        CROSS JOIN finding_severity_assessments AS assessment ON assessment.finding_id = selected.value\n        WHERE assessment.rubric_sha256 IS classification.rubric_sha256\n          AND assessment.knowledge_base_sha256 IS classification.knowledge_base_sha256\n          AND EXISTS (\n              SELECT 1 FROM finding_occurrences AS occurrence\n              WHERE occurrence.id = assessment.occurrence_id\n                AND occurrence.scan_id = classification.scan_id\n          );"
    ]
  },
  {
    "version": 44,
    "name": "version local finding embedding inputs",
    "statements": ["ALTER TABLE finding_embeddings ADD COLUMN cache_key TEXT;"]
  },
  {
    "version": 45,
    "name": "separate local and service embedding caches",
    "statements": [
      "CREATE TABLE local_finding_embeddings (\n    finding_id TEXT PRIMARY KEY REFERENCES findings(id) ON DELETE CASCADE,\n    model TEXT NOT NULL,\n    vector_json TEXT NOT NULL,\n    cache_key TEXT NOT NULL\n);",
      "INSERT INTO local_finding_embeddings\n    SELECT finding_id, model, vector_json, cache_key FROM finding_embeddings\n    WHERE cache_key IS NOT NULL;",
      "DELETE FROM finding_embeddings WHERE cache_key IS NOT NULL;"
    ]
  },
  {
    "version": 46,
    "name": "invalidate local embeddings when finding bodies change",
    "statements": [
      "CREATE TRIGGER invalidate_local_finding_embedding\nAFTER UPDATE OF details_json ON findings\nWHEN OLD.details_json IS NOT NEW.details_json\nBEGIN\n    DELETE FROM local_finding_embeddings WHERE finding_id = NEW.id;\nEND;"
    ]
  },
  {
    "version": 47,
    "name": "snapshot deep scan discovery context",
    "statements": [
      "ALTER TABLE deep_scan_runs ADD COLUMN discovery_user_context_json TEXT;"
    ]
  },
  {
    "version": 48,
    "name": "share finding issue receipts across trackers",
    "statements": [
      "CREATE TABLE finding_issue_receipts (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    scan_id TEXT NOT NULL,\n    finding_id TEXT NOT NULL,\n    occurrence_id TEXT NOT NULL,\n    destination_key TEXT NOT NULL,\n    external_id TEXT NOT NULL,\n    external_url TEXT,\n    operation TEXT NOT NULL CHECK (operation IN ('create', 'update', 'reuse')),\n    readback_json TEXT,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    UNIQUE (occurrence_id, destination_key, external_id, operation)\n);",
      "INSERT INTO finding_issue_receipts (\n    scan_id, finding_id, occurrence_id, destination_key, external_id, external_url,\n    operation, readback_json, created_at, updated_at\n) SELECT scan_id, finding_id, occurrence_id, json_array(destination_type, team_id, project_id),\n    external_id, external_url, 'create', NULL, created_at, created_at\nFROM finding_publications ORDER BY id;",
      "DROP TABLE finding_publications;",
      "CREATE INDEX finding_issue_receipts_by_finding\nON finding_issue_receipts(finding_id, destination_key, id);"
    ]
  },
  {
    "version": 49,
    "name": "index finding issue receipt ownership",
    "statements": [
      "CREATE INDEX finding_issue_receipts_by_destination_issue\nON finding_issue_receipts(destination_key, external_id, finding_id);"
    ]
  },
  {
    "version": 50,
    "name": "persist authorized source excerpt scopes",
    "statements": ["ALTER TABLE scans ADD COLUMN source_scopes_json TEXT;"]
  },
  {
    "version": 51,
    "name": "preserve deep scan worker thread history",
    "statements": [
      "CREATE TABLE deep_scan_worker_threads (\n    scan_id TEXT NOT NULL REFERENCES scans(id) ON DELETE CASCADE,\n    worker_id TEXT NOT NULL,\n    sdk_thread_id TEXT NOT NULL,\n    PRIMARY KEY (scan_id, worker_id, sdk_thread_id)\n);",
      "INSERT INTO deep_scan_worker_threads (scan_id, worker_id, sdk_thread_id)\nSELECT scan_id, id, sdk_thread_id FROM deep_scan_workers\nWHERE sdk_thread_id IS NOT NULL;",
      "CREATE TRIGGER record_deep_scan_worker_thread_insert\nAFTER INSERT ON deep_scan_workers\nWHEN NEW.sdk_thread_id IS NOT NULL\nBEGIN\n    INSERT OR IGNORE INTO deep_scan_worker_threads (scan_id, worker_id, sdk_thread_id)\n    VALUES (NEW.scan_id, NEW.id, NEW.sdk_thread_id);\nEND;",
      "CREATE TRIGGER record_deep_scan_worker_thread_update\nAFTER UPDATE OF sdk_thread_id ON deep_scan_workers\nWHEN NEW.sdk_thread_id IS NOT NULL\nBEGIN\n    INSERT OR IGNORE INTO deep_scan_worker_threads (scan_id, worker_id, sdk_thread_id)\n    VALUES (NEW.scan_id, NEW.id, NEW.sdk_thread_id);\nEND;"
    ]
  },
  {
    "version": 52,
    "name": "record severity classification review counts",
    "statements": [
      "ALTER TABLE finding_severity_assessments ADD COLUMN classification_runs INTEGER CHECK (classification_runs BETWEEN 1 AND 10);",
      "ALTER TABLE scan_severity_assessments ADD COLUMN classification_runs INTEGER CHECK (classification_runs BETWEEN 1 AND 10);",
      "ALTER TABLE scan_severity_classifications ADD COLUMN classification_runs INTEGER CHECK (classification_runs BETWEEN 1 AND 10);"
    ]
  },
  {
    "version": 53,
    "name": "store external source findings without assessments",
    "statements": [
      "CREATE TABLE external_source_reports (\n    id TEXT PRIMARY KEY,\n    repository TEXT NOT NULL,\n    provider TEXT NOT NULL,\n    source_key TEXT NOT NULL,\n    source_finding_id TEXT NOT NULL,\n    evidence_json TEXT NOT NULL,\n    version INTEGER NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    UNIQUE (repository, provider, source_key, source_finding_id)\n);"
    ]
  },
  {
    "version": 54,
    "name": "snapshot deep scan setup configuration",
    "statements": [
      "ALTER TABLE workspaces ADD COLUMN deep_scan_config_json TEXT;"
    ]
  },
  {
    "version": 55,
    "name": "retain undelivered headless deep scan results",
    "statements": [
      "ALTER TABLE deep_scan_runs ADD COLUMN pending_target_project_path TEXT;"
    ]
  },
  {
    "version": 56,
    "name": "recover unfinished legacy headless deep scans",
    "statements": [
      "UPDATE deep_scan_runs\nSET pending_target_project_path = ''\nWHERE pending_target_project_path IS NULL\n    AND status IN ('running', 'succeeded') AND cancel_requested = 0\n    AND discovery_user_context_json IS NOT NULL\n    AND EXISTS (\n        SELECT 1 FROM scans JOIN workspaces ON workspaces.id = scans.workspace_id\n        WHERE scans.id = deep_scan_runs.scan_id AND scans.mode = 'deep'\n            AND scans.status = 'running' AND scans.canceled_at IS NULL\n            AND scans.recipe_json IS NULL AND scans.handoff_status = 'delivered'\n            AND scans.handoff_claim_token IS NULL AND scans.continuation_thread_id IS NULL\n            AND workspaces.active_scan_id = scans.id AND workspaces.deep_scan_config_json IS NULL\n            AND workspaces.created_at = scans.created_at AND scans.created_at = deep_scan_runs.created_at\n    );"
    ]
  },
  {
    "version": 57,
    "name": "freeze stopped scan checkpoint selections",
    "statements": [
      "ALTER TABLE scans ADD COLUMN retained_checkpoint_heads_json TEXT;"
    ]
  },
  {
    "version": 58,
    "name": "record the final Deep Scan reviewed surface count",
    "statements": [
      "ALTER TABLE deep_scan_runs ADD COLUMN terminal_reviewed_surface_count INTEGER CHECK (terminal_reviewed_surface_count >= 0);"
    ]
  },
  {
    "version": 59,
    "name": "retain the launching Deep Scan service tier",
    "statements": ["ALTER TABLE deep_scan_runs ADD COLUMN service_tier TEXT;"]
  },
  {
    "version": 60,
    "name": "record classification rubric provenance",
    "statements": [
      "ALTER TABLE scan_severity_classifications ADD COLUMN rubric_binding_json TEXT;"
    ]
  },
  {
    "version": 61,
    "name": "record scan launch attribution",
    "statements": [
      "ALTER TABLE scans ADD COLUMN launch_surface TEXT;",
      "ALTER TABLE scans ADD COLUMN launch_package_version TEXT;",
      "ALTER TABLE scans ADD COLUMN launch_plugin_version TEXT;",
      "ALTER TABLE scans ADD COLUMN launch_kind TEXT CHECK (launch_kind IN ('scan', 'mock', 'import'));"
    ]
  },
  {
    "version": 62,
    "name": "project scan lifecycle snapshots",
    "statements": [
      "CREATE TRIGGER classify_legacy_scan_recipe\nAFTER UPDATE OF recipe_json ON scans\nWHEN OLD.recipe_json IS NULL AND (NEW.launch_kind IS NULL OR NEW.launch_plugin_version IS NULL)\n     AND json_valid(NEW.recipe_json)\nBEGIN\n    UPDATE scans SET\n        launch_kind = COALESCE(launch_kind, CASE\n            WHEN json_type(recipe_json, '$.import') = 'object' THEN 'import'\n            WHEN json_type(recipe_json, '$.mock') = 'true' THEN 'mock' END),\n        launch_plugin_version = COALESCE(launch_plugin_version, CASE\n            WHEN json_type(recipe_json, '$.pluginVersion') = 'text'\n                AND trim(json_extract(recipe_json, '$.pluginVersion'), char(9, 10, 11, 12, 13, 32)) <> ''\n            THEN json_extract(recipe_json, '$.pluginVersion') END)\n    WHERE id = NEW.id;\nEND;",
      "UPDATE scans\nSET launch_kind = CASE WHEN json_type(recipe_json, '$.import') = 'object' THEN 'import' ELSE 'mock' END\nWHERE launch_kind IS NULL AND CASE WHEN json_valid(recipe_json) THEN\n    json_type(recipe_json, '$.import') = 'object' OR json_type(recipe_json, '$.mock') = 'true'\nEND;",
      "UPDATE scans SET launch_plugin_version = json_extract(recipe_json, '$.pluginVersion')\nWHERE launch_plugin_version IS NULL AND CASE WHEN json_valid(recipe_json) THEN\n    json_type(recipe_json, '$.pluginVersion') = 'text'\n        AND trim(json_extract(recipe_json, '$.pluginVersion'), char(9, 10, 11, 12, 13, 32)) <> ''\nEND;",
      "CREATE VIEW scan_lifecycles AS\nSELECT scans.id AS scan_id, json_object(\n    'scanId', scans.id,\n    'mode', CASE WHEN launch_kind = 'import' THEN 'import' ELSE scans.mode END,\n    'startedAt', scans.started_at,\n    'status', CASE WHEN canceled_at IS NOT NULL THEN 'canceled'\n                   WHEN scans.status = 'complete' THEN 'completed' ELSE scans.status END,\n    'finishedAt', COALESCE(canceled_at, completed_at),\n    'hasReportableFindings', json(CASE\n        WHEN scans.status = 'complete' AND canceled_at IS NULL\n        THEN (SELECT CASE WHEN reportable_findings_count > 0 THEN 'true' ELSE 'false' END\n              FROM scan_progress WHERE scan_id = scans.id) END),\n    'surface', launch_surface,\n    'packageVersion', launch_package_version,\n    'pluginVersion', launch_plugin_version,\n    'mock', json(CASE WHEN launch_kind = 'mock' THEN 'true'\n                      WHEN launch_kind IS NOT NULL THEN 'false' END)\n) AS snapshot\nFROM scans;"
    ]
  },
  {
    "version": 63,
    "name": "retain unverified Deep Scan worker attempts",
    "statements": [
      "ALTER TABLE deep_scan_runs ADD COLUMN worker_usage_gap INTEGER NOT NULL DEFAULT 0 CHECK (worker_usage_gap IN (0, 1));",
      "UPDATE deep_scan_runs SET worker_usage_gap = 1\nWHERE scan_id IN (\n    SELECT w.scan_id FROM deep_scan_workers AS w\n    WHERE w.kind IN ('discovery', 'dedup') AND w.attempt > 1\n      AND w.started_at IS NOT NULL AND w.sdk_thread_id IS NULL\n      AND NOT EXISTS (SELECT 1 FROM deep_scan_worker_threads AS t\n                      WHERE t.scan_id = w.scan_id AND t.worker_id = w.id)\n);",
      "CREATE TRIGGER retain_unverified_deep_scan_worker_attempt\nAFTER UPDATE OF attempt ON deep_scan_workers\nWHEN NEW.attempt > OLD.attempt AND OLD.started_at IS NOT NULL\n     AND OLD.sdk_thread_id IS NULL AND OLD.kind IN ('discovery', 'dedup')\nBEGIN\n    UPDATE deep_scan_runs SET worker_usage_gap = 1 WHERE scan_id = OLD.scan_id;\nEND;"
    ]
  },
  {
    "version": 64,
    "name": "persist scan log completion boundaries",
    "statements": ["ALTER TABLE scans ADD COLUMN log_completed_at TEXT;"]
  },
  {
    "version": 65,
    "name": "bind Windows Deep Scan resume output directories",
    "statements": [
      "ALTER TABLE scans ADD COLUMN windows_resume_output_identity TEXT;"
    ]
  },
  {
    "version": 66,
    "name": "bind Windows Deep Scan resume checkouts",
    "statements": [
      "ALTER TABLE scans ADD COLUMN windows_resume_target_identity TEXT;"
    ]
  },
  {
    "version": 67,
    "name": "persist repository identities",
    "statements": [
      "ALTER TABLE security_targets\n        ADD COLUMN repository_identity TEXT;",
      "CREATE INDEX security_targets_by_repository_identity\n        ON security_targets(repository_identity);",
      "ALTER TABLE scans\n        ADD COLUMN repository_generation TEXT;",
      "CREATE INDEX scans_by_repository_generation\n        ON scans(repository_generation);",
      "CREATE INDEX scans_by_target_path\n        ON scans(target_path);",
      "ALTER TABLE scans\n        ADD COLUMN completion_sequence INTEGER CHECK (completion_sequence >= 1);",
      "CREATE UNIQUE INDEX scans_completion_sequence\n        ON scans(completion_sequence);",
      "CREATE TRIGGER scans_assign_inserted_completion_sequence\n        AFTER INSERT ON scans\n        WHEN NEW.status = 'complete' AND NEW.completion_sequence IS NULL\n        BEGIN\n            UPDATE scans\n            SET completion_sequence = (\n                SELECT COALESCE(MAX(completion_sequence), 0) + 1 FROM scans\n            )\n            WHERE id = NEW.id AND completion_sequence IS NULL;\n        END;",
      "CREATE TRIGGER scans_assign_updated_completion_sequence\n        AFTER UPDATE OF status ON scans\n        WHEN NEW.status = 'complete' AND NEW.completion_sequence IS NULL\n        BEGIN\n            UPDATE scans\n            SET completion_sequence = (\n                SELECT COALESCE(MAX(completion_sequence), 0) + 1 FROM scans\n            )\n            WHERE id = NEW.id AND completion_sequence IS NULL;\n        END;"
    ]
  },
  {
    "version": 68,
    "name": "stabilize Linux repository generations",
    "statements": []
  },
  {
    "version": 69,
    "name": "distinguish unvalidated workspace targets",
    "statements": [
      "ALTER TABLE workspaces\n        ADD COLUMN target_path_unvalidated INTEGER NOT NULL DEFAULT 0\n        CHECK (target_path_unvalidated IN (0, 1));"
    ]
  },
  {
    "version": 70,
    "name": "retain checkout roots for Git discovery",
    "statements": [
      "ALTER TABLE security_targets ADD COLUMN git_checkout_root TEXT;"
    ]
  },
  {
    "version": 71,
    "name": "retain rejected workspace checkout boundaries",
    "statements": [
      "ALTER TABLE workspaces ADD COLUMN rejected_checkout_roots_json TEXT;"
    ]
  },
  {
    "version": 72,
    "name": "retain external finding import selections and provenance",
    "statements": [
      "CREATE TABLE external_finding_imports (\n    id TEXT PRIMARY KEY,\n    repository TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    provider TEXT NOT NULL,\n    source_key TEXT NOT NULL,\n    provenance_json TEXT,\n    selection_json TEXT NOT NULL\n);",
      "CREATE INDEX external_finding_imports_by_repository ON external_finding_imports (repository, created_at);",
      "CREATE TABLE external_finding_import_members (\n    import_id TEXT NOT NULL REFERENCES external_finding_imports(id),\n    position INTEGER NOT NULL,\n    finding_id TEXT NOT NULL REFERENCES external_source_reports(id),\n    version INTEGER NOT NULL,\n    PRIMARY KEY (import_id, position)\n) WITHOUT ROWID;",
      "CREATE INDEX external_finding_members_by_version\nON external_finding_import_members (finding_id, version);",
      "CREATE TABLE external_finding_publications (\n    finding_id TEXT NOT NULL REFERENCES external_source_reports(id),\n    version INTEGER NOT NULL,\n    cloud_api_url TEXT NOT NULL,\n    account_id TEXT NOT NULL,\n    destination_id TEXT NOT NULL,\n    receipt_id TEXT NOT NULL,\n    outcome TEXT NOT NULL,\n    cloud_finding_id TEXT,\n    created_at TEXT NOT NULL,\n    PRIMARY KEY (finding_id, version, cloud_api_url, account_id, destination_id, receipt_id)\n) WITHOUT ROWID;"
    ]
  }
]

SHA-256: ac63f2f69d36428a5fea82ac4bc522b7f98b8e825f7f9bf35d3aae009c89258f