sdd-agent-platform 0.4.1 → 0.4.2

package/packages/core/dist/storage/runtime-store.js

@@ -2,10 +2,10 @@ import { createHash } from 'node:crypto';
 import { mkdir, readFile } from 'node:fs/promises';
 import { getRuntimeStorePath, getSddDir } from '../runtime-paths.js';
 import { exists } from './json-io.js';
-import { RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION } from '../contracts.js';
+import { INVOCATION_LEDGER_CONTRACT_VERSION, RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION } from '../contracts.js';
 import { assertAdvisoryAssessment, assertValidFanInEvidenceSet, assertValidStageRoleResult } from '../execution/stage-team-runtime.js';
-export const RUNTIME_STORE_SCHEMA_VERSION = 6;
-export const RUNTIME_STORE_CONTRACT_VERSION = 'phase-8.17-validation-wave-runtime-v6';
+export const RUNTIME_STORE_SCHEMA_VERSION = 12;
+export const RUNTIME_STORE_CONTRACT_VERSION = 'phase-9.1-stage-collaboration-contracts-runtime-v12';
 export class RuntimeStoreError extends Error {
     code;
     constructor(code, message, options) {
@@ -78,6 +78,7 @@ function initializeRuntimeStoreSchema(db) {
     if (currentVersion > RUNTIME_STORE_SCHEMA_VERSION) {
         throw new RuntimeStoreError('SCHEMA_MISMATCH', `Runtime store schema ${currentVersion} is newer than supported schema ${RUNTIME_STORE_SCHEMA_VERSION}.`);
     }
+    migrateRuntimeStoreSchema(db, currentVersion);
     db.exec(`
 CREATE TABLE IF NOT EXISTS runtime_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS runs (run_id TEXT PRIMARY KEY, status TEXT NOT NULL, phase TEXT, current_task TEXT, partition TEXT, git_branch TEXT, task_id TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, state_json TEXT NOT NULL, state_hash TEXT NOT NULL);
@@ -95,12 +96,14 @@ CREATE TABLE IF NOT EXISTS source_snapshots (snapshot_id TEXT PRIMARY KEY, run_i
 CREATE TABLE IF NOT EXISTS projections (projection_id TEXT PRIMARY KEY, projection_type TEXT NOT NULL, scope_key TEXT NOT NULL, generated_at TEXT NOT NULL, payload_json TEXT NOT NULL, UNIQUE(projection_type, scope_key));
 CREATE TABLE IF NOT EXISTS legacy_imports (import_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, entity_type TEXT NOT NULL, content_hash TEXT NOT NULL, imported_at TEXT NOT NULL, status TEXT NOT NULL, issue TEXT, UNIQUE(run_id, entity_type));
 CREATE TABLE IF NOT EXISTS test_runs (test_run_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, partition TEXT, task_id TEXT NOT NULL, status TEXT NOT NULL, started_at TEXT NOT NULL, completed_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS test_steps (test_step_id TEXT PRIMARY KEY, test_run_id TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, command TEXT NOT NULL, status TEXT NOT NULL, exit_code INTEGER, duration_ms INTEGER NOT NULL, output_artifact TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(test_run_id) REFERENCES test_runs(test_run_id) ON DELETE CASCADE, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS test_steps (test_step_id TEXT PRIMARY KEY, test_run_id TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, command TEXT NOT NULL, status TEXT NOT NULL, exit_code INTEGER, duration_ms INTEGER NOT NULL, output_artifact TEXT, payload_json TEXT NOT NULL, FOREIGN KEY(test_run_id) REFERENCES test_runs(test_run_id) ON DELETE CASCADE, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS agent_executions (execution_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT NOT NULL, profile TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS team_sessions (team_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS worker_runtimes (runtime_id TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, status TEXT NOT NULL, claimed_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, PRIMARY KEY(run_id, runtime_id), FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS artifact_payloads (payload_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, source_run_id TEXT NOT NULL, branch_slug TEXT NOT NULL, task_id TEXT, logical_ref TEXT NOT NULL, physical_payload_path TEXT NOT NULL, artifact_role TEXT NOT NULL, digest TEXT NOT NULL, sequence INTEGER NOT NULL, status TEXT NOT NULL, supersedes TEXT, created_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE, UNIQUE(branch_slug, physical_payload_path), UNIQUE(run_id, logical_ref, digest));
-CREATE TABLE IF NOT EXISTS sync_back_decisions (decision_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, branch TEXT NOT NULL, task_id TEXT, status TEXT NOT NULL, proposal_path TEXT, proposal_digest TEXT, proposal_payload_id TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS evidence_sets (evidence_set_id TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, scope_kind TEXT NOT NULL, scope_id TEXT NOT NULL, source_run_id TEXT, document_contract_hashes_json TEXT NOT NULL, gate_decision_id TEXT, status TEXT NOT NULL, created_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(source_run_id) REFERENCES runs(run_id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS evidence_set_items (evidence_set_id TEXT NOT NULL, payload_id TEXT NOT NULL, logical_ref TEXT NOT NULL, role TEXT NOT NULL, required INTEGER NOT NULL, digest_at_selection TEXT NOT NULL, PRIMARY KEY(evidence_set_id, payload_id), FOREIGN KEY(evidence_set_id) REFERENCES evidence_sets(evidence_set_id) ON DELETE CASCADE, FOREIGN KEY(payload_id) REFERENCES artifact_payloads(payload_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS selection_pointers (branch_slug TEXT NOT NULL, scope_kind TEXT NOT NULL, scope_id TEXT NOT NULL, selected_evidence_set_id TEXT NOT NULL, selected_at TEXT NOT NULL, selected_by_gate_decision_id TEXT, reason TEXT NOT NULL, PRIMARY KEY(branch_slug, scope_kind, scope_id), FOREIGN KEY(selected_evidence_set_id) REFERENCES evidence_sets(evidence_set_id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS durable_gaps (gap_id TEXT PRIMARY KEY, partition TEXT NOT NULL, task_id TEXT, run_id TEXT, stage TEXT, gate_name TEXT, source TEXT NOT NULL, category TEXT NOT NULL, severity TEXT NOT NULL, status TEXT NOT NULL, message TEXT NOT NULL, recommendation TEXT, evidence_refs_json TEXT NOT NULL, proposal_refs_json TEXT NOT NULL, source_refs_json TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, closed_at TEXT, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS stage_team_sessions (session_id TEXT PRIMARY KEY, partition TEXT NOT NULL, run_id TEXT, task_id TEXT, stage TEXT NOT NULL, lifecycle_profile TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS stage_role_results (result_id TEXT PRIMARY KEY, session_id TEXT NOT NULL, partition TEXT NOT NULL, run_id TEXT, task_id TEXT, role_id TEXT NOT NULL, agent_id TEXT, output_kind TEXT NOT NULL, authority_ceiling TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE SET NULL);
@@ -110,6 +113,12 @@ CREATE TABLE IF NOT EXISTS workflow_gate_decisions (decision_id TEXT PRIMARY KEY
 CREATE TABLE IF NOT EXISTS validation_environment_sessions (session_id TEXT PRIMARY KEY, partition TEXT NOT NULL, run_id TEXT, wave_run_id TEXT, status TEXT NOT NULL, reuse_key TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS validation_wave_runs (wave_run_id TEXT PRIMARY KEY, partition TEXT NOT NULL, run_id TEXT, task_ids_json TEXT NOT NULL, status TEXT NOT NULL, environment_session_id TEXT NOT NULL, started_at TEXT NOT NULL, completed_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS acceptance_evidence_maps (map_id TEXT PRIMARY KEY, wave_run_id TEXT NOT NULL, test_run_id TEXT NOT NULL, partition TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, acceptance_ref TEXT NOT NULL, status TEXT NOT NULL, evidence_refs_json TEXT NOT NULL, gaps_json TEXT NOT NULL, created_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS validation_cache_entries (cache_key TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, command TEXT NOT NULL, status TEXT NOT NULL, source_test_run_id TEXT NOT NULL, source_run_id TEXT NOT NULL, source_evidence_set_id TEXT, output_artifact TEXT, stdout_digest TEXT NOT NULL, stderr_digest TEXT NOT NULL, created_at TEXT NOT NULL, last_used_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(source_test_run_id) REFERENCES test_runs(test_run_id) ON DELETE CASCADE, FOREIGN KEY(source_run_id) REFERENCES runs(run_id) ON DELETE CASCADE, FOREIGN KEY(source_evidence_set_id) REFERENCES evidence_sets(evidence_set_id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS validation_cache_uses (use_id TEXT PRIMARY KEY, cache_key TEXT NOT NULL, branch_slug TEXT NOT NULL, test_run_id TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, source_test_run_id TEXT NOT NULL, source_evidence_set_id TEXT, reused_at TEXT NOT NULL, mapped_task_ids_json TEXT NOT NULL, reason TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(cache_key) REFERENCES validation_cache_entries(cache_key) ON DELETE CASCADE, FOREIGN KEY(test_run_id) REFERENCES test_runs(test_run_id) ON DELETE CASCADE, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS repair_records (repair_id TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, task_id TEXT, repair_type TEXT NOT NULL, repair_of_run_id TEXT, repair_of_gate_decision_id TEXT, status TEXT NOT NULL, affected_tasks_json TEXT NOT NULL, blockers_json TEXT NOT NULL, recommended_commands_json TEXT NOT NULL, required_evidence_json TEXT NOT NULL, created_at TEXT NOT NULL, resolved_at TEXT, payload_json TEXT NOT NULL, FOREIGN KEY(repair_of_run_id) REFERENCES runs(run_id) ON DELETE SET NULL, FOREIGN KEY(repair_of_gate_decision_id) REFERENCES workflow_gate_decisions(decision_id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS capability_adoptions (adoption_id TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, lifecycle_stage TEXT NOT NULL, capability_domain TEXT NOT NULL, source_id TEXT, status TEXT NOT NULL, reason TEXT NOT NULL, evidence_refs_json TEXT NOT NULL, final_authority TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, UNIQUE(branch_slug, lifecycle_stage, capability_domain, source_id));
+CREATE TABLE IF NOT EXISTS stage_artifacts (artifact_id TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, stage TEXT NOT NULL, artifact_kind TEXT NOT NULL, producer TEXT NOT NULL, artifact_ref TEXT NOT NULL, content_hash TEXT NOT NULL, contract TEXT NOT NULL, target_ref TEXT, target_hash TEXT, review_ref TEXT, review_hash TEXT, verdict TEXT, finding_count INTEGER, blocking_count INTEGER, recommendation TEXT, frontmatter_json TEXT NOT NULL, registered_at TEXT NOT NULL, payload_json TEXT NOT NULL, UNIQUE(branch_slug, stage, artifact_ref, content_hash));
+CREATE TABLE IF NOT EXISTS stage_collaboration_contracts (contract_id TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, stage TEXT NOT NULL, contract_ref TEXT NOT NULL, content_hash TEXT NOT NULL, contract_version TEXT NOT NULL, producer TEXT NOT NULL, work_order_id TEXT, status TEXT NOT NULL, validation_errors_json TEXT NOT NULL, selected_agents_json TEXT NOT NULL, selected_skills_json TEXT NOT NULL, selected_materials_json TEXT NOT NULL, evidence_contracts_json TEXT NOT NULL, checkpoint_plan_json TEXT NOT NULL, rework_plan_json TEXT NOT NULL, permission_projection_json TEXT NOT NULL, frontmatter_json TEXT NOT NULL, registered_at TEXT NOT NULL, payload_json TEXT NOT NULL, UNIQUE(branch_slug, stage, contract_ref, content_hash));
 CREATE INDEX IF NOT EXISTS idx_runs_partition_task_updated ON runs(partition, task_id, updated_at);
 CREATE INDEX IF NOT EXISTS idx_events_run_time ON events(run_id, event_time, event_id);
 CREATE INDEX IF NOT EXISTS idx_artifacts_run_path ON artifacts(run_id, path);
@@ -123,7 +132,8 @@ CREATE INDEX IF NOT EXISTS idx_team_sessions_run_task ON team_sessions(run_id, t
 CREATE INDEX IF NOT EXISTS idx_worker_runtimes_run_task ON worker_runtimes(run_id, task_id, updated_at);
 CREATE INDEX IF NOT EXISTS idx_artifact_payloads_logical ON artifact_payloads(branch_slug, logical_ref, status, sequence);
 CREATE INDEX IF NOT EXISTS idx_artifact_payloads_run_logical ON artifact_payloads(run_id, logical_ref, status, sequence);
-CREATE INDEX IF NOT EXISTS idx_sync_back_decisions_run_task ON sync_back_decisions(run_id, task_id, updated_at);
+CREATE INDEX IF NOT EXISTS idx_evidence_sets_scope ON evidence_sets(branch_slug, scope_kind, scope_id, status, created_at);
+CREATE INDEX IF NOT EXISTS idx_selection_pointers_scope ON selection_pointers(branch_slug, scope_kind, scope_id);
 CREATE INDEX IF NOT EXISTS idx_durable_gaps_partition_task ON durable_gaps(partition, task_id, status, severity, updated_at);
 CREATE INDEX IF NOT EXISTS idx_durable_gaps_run_task ON durable_gaps(run_id, task_id, status, severity, updated_at);
 CREATE INDEX IF NOT EXISTS idx_stage_team_sessions_partition_task ON stage_team_sessions(partition, task_id, updated_at);
@@ -134,12 +144,54 @@ CREATE INDEX IF NOT EXISTS idx_workflow_gate_decisions_partition_task ON workflo
 CREATE INDEX IF NOT EXISTS idx_validation_environment_sessions_partition ON validation_environment_sessions(partition, wave_run_id, updated_at);
 CREATE INDEX IF NOT EXISTS idx_validation_wave_runs_partition ON validation_wave_runs(partition, status, completed_at);
 CREATE INDEX IF NOT EXISTS idx_acceptance_evidence_maps_task ON acceptance_evidence_maps(partition, task_id, acceptance_ref, created_at);
+CREATE INDEX IF NOT EXISTS idx_validation_cache_entries_branch_status ON validation_cache_entries(branch_slug, status, last_used_at);
+CREATE INDEX IF NOT EXISTS idx_validation_cache_uses_run_task ON validation_cache_uses(run_id, task_id, reused_at);
+CREATE INDEX IF NOT EXISTS idx_repair_records_branch_status ON repair_records(branch_slug, status, repair_type, created_at);
+CREATE INDEX IF NOT EXISTS idx_capability_adoptions_branch_domain ON capability_adoptions(branch_slug, capability_domain, status, updated_at);
+CREATE INDEX IF NOT EXISTS idx_stage_artifacts_branch_stage ON stage_artifacts(branch_slug, stage, registered_at);
+CREATE INDEX IF NOT EXISTS idx_stage_artifacts_ref ON stage_artifacts(branch_slug, stage, artifact_ref, content_hash);
+CREATE INDEX IF NOT EXISTS idx_stage_collaboration_contracts_branch_stage ON stage_collaboration_contracts(branch_slug, stage, registered_at);
+CREATE INDEX IF NOT EXISTS idx_stage_collaboration_contracts_ref ON stage_collaboration_contracts(branch_slug, stage, contract_ref, content_hash);
 `);
     db.exec(`PRAGMA user_version = ${RUNTIME_STORE_SCHEMA_VERSION}`);
     const now = new Date().toISOString();
     db.prepare('INSERT OR REPLACE INTO runtime_meta (key, value, updated_at) VALUES (?, ?, ?)').run('contract', RUNTIME_STORE_CONTRACT_VERSION, now);
     db.prepare('INSERT OR REPLACE INTO runtime_meta (key, value, updated_at) VALUES (?, ?, ?)').run('schema_version', String(RUNTIME_STORE_SCHEMA_VERSION), now);
 }
+function migrateRuntimeStoreSchema(db, currentVersion) {
+    if (currentVersion === 0 || currentVersion >= RUNTIME_STORE_SCHEMA_VERSION) {
+        return;
+    }
+    if (currentVersion < 12) {
+        migrateNullableOutputArtifactColumns(db);
+    }
+}
+function migrateNullableOutputArtifactColumns(db) {
+    migrateNullableOutputArtifactColumn(db, 'test_steps', 'test_step_id TEXT PRIMARY KEY, test_run_id TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, command TEXT NOT NULL, status TEXT NOT NULL, exit_code INTEGER, duration_ms INTEGER NOT NULL, output_artifact TEXT, payload_json TEXT NOT NULL, FOREIGN KEY(test_run_id) REFERENCES test_runs(test_run_id) ON DELETE CASCADE, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE', 'test_step_id, test_run_id, run_id, task_id, command, status, exit_code, duration_ms, output_artifact, payload_json');
+    migrateNullableOutputArtifactColumn(db, 'validation_cache_entries', 'cache_key TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, command TEXT NOT NULL, status TEXT NOT NULL, source_test_run_id TEXT NOT NULL, source_run_id TEXT NOT NULL, source_evidence_set_id TEXT, output_artifact TEXT, stdout_digest TEXT NOT NULL, stderr_digest TEXT NOT NULL, created_at TEXT NOT NULL, last_used_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(source_test_run_id) REFERENCES test_runs(test_run_id) ON DELETE CASCADE, FOREIGN KEY(source_run_id) REFERENCES runs(run_id) ON DELETE CASCADE, FOREIGN KEY(source_evidence_set_id) REFERENCES evidence_sets(evidence_set_id) ON DELETE SET NULL', 'cache_key, branch_slug, command, status, source_test_run_id, source_run_id, source_evidence_set_id, output_artifact, stdout_digest, stderr_digest, created_at, last_used_at, payload_json');
+}
+function migrateNullableOutputArtifactColumn(db, tableName, columnDefinitionSql, columnsSql) {
+    if (!runtimeStoreColumnIsNotNull(db, tableName, 'output_artifact')) {
+        return;
+    }
+    const tempTableName = `${tableName}_runtime_v12`;
+    db.exec('PRAGMA foreign_keys = OFF');
+    try {
+        db.exec(`DROP TABLE IF EXISTS ${tempTableName}`);
+        db.exec(`CREATE TABLE ${tempTableName} (${columnDefinitionSql})`);
+        db.exec(`INSERT INTO ${tempTableName} (${columnsSql}) SELECT ${columnsSql} FROM ${tableName}`);
+        db.exec(`DROP TABLE ${tableName}`);
+        db.exec(`ALTER TABLE ${tempTableName} RENAME TO ${tableName}`);
+    }
+    finally {
+        db.exec('PRAGMA foreign_keys = ON');
+    }
+}
+function runtimeStoreColumnIsNotNull(db, tableName, columnName) {
+    const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    const column = rows.find((row) => row.name === columnName);
+    return (column?.notnull ?? 0) === 1;
+}
 function readRuntimeStoreSchemaVersion(db) {
     const row = db.prepare('PRAGMA user_version').get();
     return typeof row?.user_version === 'number' ? row.user_version : 0;
@@ -359,6 +411,86 @@ export async function recordRuntimeEvidenceAttachment(projectRoot, input) {
             .run(runtimeScopedId(input.branchSlug, input.runId ?? 'none', input.relativePath, input.contentHash), input.branchSlug, input.runId ?? null, input.taskId ?? null, input.kind, input.relativePath, input.contentHash, input.bytes, now, payloadJson);
     });
 }
+export async function recordRuntimeStageArtifact(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO stage_artifacts (artifact_id, branch_slug, stage, artifact_kind, producer, artifact_ref, content_hash, contract, target_ref, target_hash, review_ref, review_hash, verdict, finding_count, blocking_count, recommendation, frontmatter_json, registered_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.artifactId, record.branch, record.stage, record.kind, record.producer, record.ref, record.hash, record.contract, record.targetRef?.ref ?? null, record.targetHash ?? null, record.reviewRef?.ref ?? null, record.reviewHash ?? null, record.verdict ?? null, record.findingCount ?? null, record.blockingCount ?? null, record.recommendation ?? null, JSON.stringify(record.frontmatter), record.registeredAt, JSON.stringify(record));
+    });
+    return record;
+}
+export async function listRuntimeStageArtifacts(projectRoot, filter = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (filter.branchSlug) {
+            clauses.push('branch_slug = ?');
+            params.push(filter.branchSlug);
+        }
+        if (filter.stage) {
+            clauses.push('stage = ?');
+            params.push(filter.stage);
+        }
+        if (filter.artifactKind) {
+            clauses.push('artifact_kind = ?');
+            params.push(filter.artifactKind);
+        }
+        if (filter.producer) {
+            clauses.push('producer = ?');
+            params.push(filter.producer);
+        }
+        if (filter.artifactRef) {
+            clauses.push('artifact_ref = ?');
+            params.push(filter.artifactRef);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT * FROM stage_artifacts${where} ORDER BY registered_at DESC, artifact_id ASC`).all(...params);
+        return rows.map(runtimeStageArtifactFromRow);
+    });
+}
+export async function readRuntimeStageArtifact(projectRoot, artifactId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const row = db.prepare('SELECT * FROM stage_artifacts WHERE artifact_id = ?').get(artifactId);
+        return row ? runtimeStageArtifactFromRow(row) : null;
+    });
+}
+export async function recordRuntimeStageCollaborationContract(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO stage_collaboration_contracts (contract_id, branch_slug, stage, contract_ref, content_hash, contract_version, producer, work_order_id, status, validation_errors_json, selected_agents_json, selected_skills_json, selected_materials_json, evidence_contracts_json, checkpoint_plan_json, rework_plan_json, permission_projection_json, frontmatter_json, registered_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.contractId, record.branch, record.stage, record.ref, record.hash, record.contract, record.producer, record.workOrderId ?? null, record.status, JSON.stringify(record.validationErrors), JSON.stringify(record.selectedAgents), JSON.stringify(record.selectedSkills), JSON.stringify(record.selectedMaterialPacks), JSON.stringify(record.evidenceContracts), JSON.stringify(record.checkpointPlan), JSON.stringify(record.reworkPlan), JSON.stringify(record.permissionProjection), JSON.stringify(record.frontmatter), record.registeredAt, JSON.stringify(record));
+    });
+    return record;
+}
+export async function listRuntimeStageCollaborationContracts(projectRoot, filter = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (filter.branchSlug) {
+            clauses.push('branch_slug = ?');
+            params.push(filter.branchSlug);
+        }
+        if (filter.stage) {
+            clauses.push('stage = ?');
+            params.push(filter.stage);
+        }
+        if (filter.status) {
+            clauses.push('status = ?');
+            params.push(filter.status);
+        }
+        if (filter.contractRef) {
+            clauses.push('contract_ref = ?');
+            params.push(filter.contractRef);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT * FROM stage_collaboration_contracts${where} ORDER BY registered_at DESC, contract_id ASC`).all(...params);
+        return rows.map(runtimeStageCollaborationContractFromRow);
+    });
+}
+export async function readRuntimeStageCollaborationContract(projectRoot, contractId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const row = db.prepare('SELECT * FROM stage_collaboration_contracts WHERE contract_id = ?').get(contractId);
+        return row ? runtimeStageCollaborationContractFromRow(row) : null;
+    });
+}
 export async function recordRuntimeArtifactPayload(projectRoot, input) {
     const createdAt = input.createdAt ?? new Date().toISOString();
     return withRuntimeStore(projectRoot, ({ db }) => {
@@ -417,25 +549,50 @@ export async function listRuntimeArtifactPayloads(projectRoot, input = {}) {
         return rows.map(runtimeArtifactPayloadFromRow);
     });
 }
-export async function recordRuntimeSyncBackDecision(projectRoot, record) {
-    const payloadJson = JSON.stringify({ payload: record.payload, reasons: record.reasons });
+export async function createRuntimeEvidenceSet(projectRoot, input) {
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const record = { ...input, createdAt };
     await withRuntimeStore(projectRoot, ({ db }) => {
-        db.prepare('INSERT OR REPLACE INTO sync_back_decisions (decision_id, run_id, branch, task_id, status, proposal_path, proposal_digest, proposal_payload_id, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-            .run(record.decisionId, record.runId, record.branch, record.taskId, record.status, record.proposalPath, record.proposalDigest, record.proposalPayloadId, record.createdAt, record.updatedAt, payloadJson);
+        db.prepare('INSERT OR REPLACE INTO evidence_sets (evidence_set_id, branch_slug, scope_kind, scope_id, source_run_id, document_contract_hashes_json, gate_decision_id, status, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.evidenceSetId, record.branchSlug, record.scopeKind, record.scopeId, record.sourceRunId, JSON.stringify(record.documentContractHashes), record.gateDecisionId, record.status, record.createdAt, JSON.stringify(record.payload));
+        for (const item of record.items) {
+            db.prepare('INSERT OR REPLACE INTO evidence_set_items (evidence_set_id, payload_id, logical_ref, role, required, digest_at_selection) VALUES (?, ?, ?, ?, ?, ?)')
+                .run(record.evidenceSetId, item.payloadId, item.logicalRef, item.role, item.required ? 1 : 0, item.digestAtSelection);
+        }
     });
+    return record;
 }
-export async function readRuntimeSyncBackDecision(projectRoot, runId, taskId) {
-    return withRuntimeStore(projectRoot, ({ db }) => {
-        const row = taskId
-            ? db.prepare('SELECT * FROM sync_back_decisions WHERE run_id = ? AND task_id = ? ORDER BY updated_at DESC LIMIT 1').get(runId, taskId)
-            : db.prepare('SELECT * FROM sync_back_decisions WHERE run_id = ? ORDER BY updated_at DESC LIMIT 1').get(runId);
-        return row ? runtimeSyncBackDecisionFromRow(row) : null;
+export async function updateRuntimeSelectionPointer(projectRoot, pointer) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        const previous = db.prepare('SELECT selected_evidence_set_id FROM selection_pointers WHERE branch_slug = ? AND scope_kind = ? AND scope_id = ?')
+            .get(pointer.branchSlug, pointer.scopeKind, pointer.scopeId);
+        db.prepare('INSERT OR REPLACE INTO selection_pointers (branch_slug, scope_kind, scope_id, selected_evidence_set_id, selected_at, selected_by_gate_decision_id, reason) VALUES (?, ?, ?, ?, ?, ?, ?)')
+            .run(pointer.branchSlug, pointer.scopeKind, pointer.scopeId, pointer.selectedEvidenceSetId, pointer.selectedAt, pointer.selectedByGateDecisionId, pointer.reason);
+        if (previous?.selected_evidence_set_id !== pointer.selectedEvidenceSetId) {
+            recordSelectionPointerActivity(db, pointer);
+        }
     });
+    return pointer;
 }
-export async function listRuntimeSyncBackDecisions(projectRoot, runId) {
+export async function resolveRuntimeSelectedEvidence(projectRoot, input) {
     return withRuntimeStore(projectRoot, ({ db }) => {
-        const rows = db.prepare('SELECT * FROM sync_back_decisions WHERE run_id = ? ORDER BY updated_at DESC, decision_id ASC').all(runId);
-        return rows.map(runtimeSyncBackDecisionFromRow);
+        const pointerRow = db.prepare('SELECT * FROM selection_pointers WHERE branch_slug = ? AND scope_kind = ? AND scope_id = ?').get(input.branchSlug, input.scopeKind, input.scopeId);
+        if (pointerRow) {
+            const evidenceSet = runtimeEvidenceSetFromDb(db, pointerRow.selected_evidence_set_id);
+            if (evidenceSet && evidenceSetMatchesFallbackRuns(evidenceSet, input.fallbackRunIds)) {
+                const payloads = payloadsForEvidenceSet(db, evidenceSet);
+                if (payloads.length > 0) {
+                    return { source: 'selection_pointer', evidenceSet, pointer: runtimeSelectionPointerFromRow(pointerRow), payloads };
+                }
+            }
+        }
+        const fallbackPayloads = legacyFallbackPayloads(db, input);
+        if (fallbackPayloads.length === 0) {
+            return { source: 'none', evidenceSet: null, pointer: null, payloads: [] };
+        }
+        return input.allowCandidateFallback
+            ? { source: 'candidate_payloads', evidenceSet: null, pointer: null, payloads: fallbackPayloads }
+            : { source: 'legacy_active_payloads', evidenceSet: null, pointer: null, payloads: fallbackPayloads };
     });
 }
 export async function recordRuntimeDurableGap(projectRoot, input) {
@@ -572,7 +729,7 @@ export async function listRuntimeProjections(projectRoot, projectionTypes) {
 }
 export async function recordRuntimeTestRun(projectRoot, record) {
     await withRuntimeStore(projectRoot, ({ db }) => {
-        db.prepare('INSERT OR REPLACE INTO test_runs (test_run_id, run_id, partition, task_id, status, started_at, completed_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+        db.prepare('INSERT INTO test_runs (test_run_id, run_id, partition, task_id, status, started_at, completed_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(test_run_id) DO UPDATE SET run_id = excluded.run_id, partition = excluded.partition, task_id = excluded.task_id, status = excluded.status, started_at = excluded.started_at, completed_at = excluded.completed_at, payload_json = excluded.payload_json')
             .run(record.testRunId, record.runId, record.partition, record.taskId, record.status, record.startedAt, record.completedAt, JSON.stringify(record.payload));
     });
 }
@@ -582,6 +739,23 @@ export async function recordRuntimeTestStep(projectRoot, record) {
             .run(record.stepId, record.testRunId, record.runId, record.taskId, record.command, record.status, record.exitCode, record.durationMs, record.outputArtifact, JSON.stringify(record.payload));
     });
 }
+export async function listRuntimeTestSteps(projectRoot, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (input.runId) {
+            clauses.push('run_id = ?');
+            params.push(input.runId);
+        }
+        if (input.testRunId) {
+            clauses.push('test_run_id = ?');
+            params.push(input.testRunId);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT test_step_id, test_run_id, run_id, task_id, command, status, exit_code, duration_ms, output_artifact, payload_json FROM test_steps${where} ORDER BY test_step_id ASC`).all(...params);
+        return rows.map(runtimeTestStepFromRow);
+    });
+}
 export async function listRuntimeTestRuns(projectRoot, runId) {
     return withRuntimeStore(projectRoot, ({ db }) => {
         const rows = runId
@@ -599,6 +773,122 @@ export async function listRuntimeTestRuns(projectRoot, runId) {
         }));
     });
 }
+export async function recordRuntimeValidationCacheEntry(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT INTO validation_cache_entries (cache_key, branch_slug, command, status, source_test_run_id, source_run_id, source_evidence_set_id, output_artifact, stdout_digest, stderr_digest, created_at, last_used_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(cache_key) DO UPDATE SET branch_slug = excluded.branch_slug, command = excluded.command, status = excluded.status, source_test_run_id = excluded.source_test_run_id, source_run_id = excluded.source_run_id, source_evidence_set_id = excluded.source_evidence_set_id, output_artifact = excluded.output_artifact, stdout_digest = excluded.stdout_digest, stderr_digest = excluded.stderr_digest, last_used_at = excluded.last_used_at, payload_json = excluded.payload_json')
+            .run(record.cacheKey, record.branchSlug, record.command, record.status, record.sourceTestRunId, record.sourceRunId, record.sourceEvidenceSetId, record.outputArtifact, record.stdoutDigest, record.stderrDigest, record.createdAt, record.lastUsedAt, JSON.stringify(record.payload));
+    });
+}
+export async function readRuntimeValidationCacheEntry(projectRoot, input) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const row = db.prepare('SELECT cache_key, branch_slug, command, status, source_test_run_id, source_run_id, source_evidence_set_id, output_artifact, stdout_digest, stderr_digest, created_at, last_used_at, payload_json FROM validation_cache_entries WHERE branch_slug = ? AND cache_key = ? AND status = ?').get(input.branchSlug, input.cacheKey, 'valid');
+        return row ? runtimeValidationCacheEntryFromRow(row) : null;
+    });
+}
+export async function listRuntimeValidationCacheEntries(projectRoot, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (input.branchSlug) {
+            clauses.push('branch_slug = ?');
+            params.push(input.branchSlug);
+        }
+        if (input.status) {
+            clauses.push('status = ?');
+            params.push(input.status);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT cache_key, branch_slug, command, status, source_test_run_id, source_run_id, source_evidence_set_id, output_artifact, stdout_digest, stderr_digest, created_at, last_used_at, payload_json FROM validation_cache_entries${where} ORDER BY last_used_at DESC, cache_key ASC`).all(...params);
+        return rows.map(runtimeValidationCacheEntryFromRow);
+    });
+}
+export async function recordRuntimeValidationCacheUse(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO validation_cache_uses (use_id, cache_key, branch_slug, test_run_id, run_id, task_id, source_test_run_id, source_evidence_set_id, reused_at, mapped_task_ids_json, reason, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.useId, record.cacheKey, record.branchSlug, record.testRunId, record.runId, record.taskId, record.sourceTestRunId, record.sourceEvidenceSetId, record.reusedAt, JSON.stringify(record.mappedTaskIds), record.reason, JSON.stringify(record.payload));
+        db.prepare('UPDATE validation_cache_entries SET last_used_at = ? WHERE cache_key = ?')
+            .run(record.reusedAt, record.cacheKey);
+    });
+}
+export async function listRuntimeValidationCacheUses(projectRoot, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (input.branchSlug) {
+            clauses.push('branch_slug = ?');
+            params.push(input.branchSlug);
+        }
+        if (input.runId) {
+            clauses.push('run_id = ?');
+            params.push(input.runId);
+        }
+        if (input.taskId) {
+            clauses.push('task_id = ?');
+            params.push(input.taskId);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT use_id, cache_key, branch_slug, test_run_id, run_id, task_id, source_test_run_id, source_evidence_set_id, reused_at, mapped_task_ids_json, reason, payload_json FROM validation_cache_uses${where} ORDER BY reused_at DESC, use_id ASC`).all(...params);
+        return rows.map(runtimeValidationCacheUseFromRow);
+    });
+}
+export async function recordRuntimeRepair(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT INTO repair_records (repair_id, branch_slug, task_id, repair_type, repair_of_run_id, repair_of_gate_decision_id, status, affected_tasks_json, blockers_json, recommended_commands_json, required_evidence_json, created_at, resolved_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(repair_id) DO UPDATE SET status = excluded.status, blockers_json = excluded.blockers_json, recommended_commands_json = excluded.recommended_commands_json, required_evidence_json = excluded.required_evidence_json, resolved_at = excluded.resolved_at, payload_json = excluded.payload_json')
+            .run(record.repairId, record.branchSlug, record.taskId, record.repairType, record.repairOfRunId, record.repairOfGateDecisionId, record.status, JSON.stringify(record.affectedTasks), JSON.stringify(record.blockers), JSON.stringify(record.recommendedCommands), JSON.stringify(record.requiredEvidence), record.createdAt, record.resolvedAt, JSON.stringify(record.payload));
+    });
+}
+export async function listRuntimeRepairs(projectRoot, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (input.branchSlug) {
+            clauses.push('branch_slug = ?');
+            params.push(input.branchSlug);
+        }
+        if (input.taskId) {
+            clauses.push('task_id = ?');
+            params.push(input.taskId);
+        }
+        if (input.status) {
+            clauses.push('status = ?');
+            params.push(input.status);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT repair_id, branch_slug, task_id, repair_type, repair_of_run_id, repair_of_gate_decision_id, status, affected_tasks_json, blockers_json, recommended_commands_json, required_evidence_json, created_at, resolved_at, payload_json FROM repair_records${where} ORDER BY created_at DESC, repair_id ASC`).all(...params);
+        return rows.map(runtimeRepairFromRow);
+    });
+}
+export async function recordRuntimeCapabilityAdoption(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT INTO capability_adoptions (adoption_id, branch_slug, lifecycle_stage, capability_domain, source_id, status, reason, evidence_refs_json, final_authority, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(branch_slug, lifecycle_stage, capability_domain, source_id) DO UPDATE SET adoption_id = excluded.adoption_id, status = excluded.status, reason = excluded.reason, evidence_refs_json = excluded.evidence_refs_json, final_authority = excluded.final_authority, updated_at = excluded.updated_at, payload_json = excluded.payload_json')
+            .run(record.adoptionId, record.branchSlug, record.lifecycleStage, record.capabilityDomain, record.sourceId, record.status, record.reason, JSON.stringify(record.evidenceRefs), record.finalAuthority, record.createdAt, record.updatedAt, JSON.stringify(record.payload));
+    });
+}
+export async function listRuntimeCapabilityAdoptions(projectRoot, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        if (input.branchSlug) {
+            clauses.push('branch_slug = ?');
+            params.push(input.branchSlug);
+        }
+        if (input.lifecycleStage) {
+            clauses.push('lifecycle_stage = ?');
+            params.push(input.lifecycleStage);
+        }
+        if (input.capabilityDomain) {
+            clauses.push('capability_domain = ?');
+            params.push(input.capabilityDomain);
+        }
+        if (input.status) {
+            clauses.push('status = ?');
+            params.push(input.status);
+        }
+        const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+        const rows = db.prepare(`SELECT adoption_id, branch_slug, lifecycle_stage, capability_domain, source_id, status, reason, evidence_refs_json, final_authority, created_at, updated_at, payload_json FROM capability_adoptions${where} ORDER BY updated_at DESC, adoption_id ASC`).all(...params);
+        return rows.map(runtimeCapabilityAdoptionFromRow);
+    });
+}
 export async function recordRuntimeValidationEnvironmentSession(projectRoot, record) {
     await withRuntimeStore(projectRoot, ({ db }) => {
         db.prepare('INSERT OR REPLACE INTO validation_environment_sessions (session_id, partition, run_id, wave_run_id, status, reuse_key, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
@@ -690,6 +980,111 @@ export async function listRuntimeAcceptanceEvidenceMaps(projectRoot, input = {})
         return rows.map((row) => ({ mapId: row.map_id, waveRunId: row.wave_run_id, testRunId: row.test_run_id, partition: row.partition, runId: row.run_id, taskId: row.task_id, acceptanceRef: row.acceptance_ref, status: row.status, evidenceRefs: JSON.parse(row.evidence_refs_json), gaps: JSON.parse(row.gaps_json), createdAt: row.created_at, payload: JSON.parse(row.payload_json) }));
     });
 }
+function runtimeEvidenceSetFromDb(db, evidenceSetId) {
+    const row = db.prepare('SELECT * FROM evidence_sets WHERE evidence_set_id = ?').get(evidenceSetId);
+    if (!row) {
+        return null;
+    }
+    const items = db.prepare('SELECT * FROM evidence_set_items WHERE evidence_set_id = ? ORDER BY logical_ref ASC, payload_id ASC').all(evidenceSetId);
+    return {
+        evidenceSetId: row.evidence_set_id,
+        branchSlug: row.branch_slug,
+        scopeKind: row.scope_kind,
+        scopeId: row.scope_id,
+        sourceRunId: row.source_run_id,
+        documentContractHashes: JSON.parse(row.document_contract_hashes_json),
+        gateDecisionId: row.gate_decision_id,
+        status: row.status,
+        createdAt: row.created_at,
+        items: items.map((item) => ({
+            evidenceSetId: item.evidence_set_id,
+            payloadId: item.payload_id,
+            logicalRef: item.logical_ref,
+            role: item.role,
+            required: item.required === 1,
+            digestAtSelection: item.digest_at_selection
+        })),
+        payload: JSON.parse(row.payload_json)
+    };
+}
+function payloadsForEvidenceSet(db, evidenceSet) {
+    const payloadIds = evidenceSet.items.map((item) => item.payloadId);
+    if (payloadIds.length === 0) {
+        return [];
+    }
+    const rows = db.prepare(`SELECT * FROM artifact_payloads WHERE payload_id IN (${payloadIds.map(() => '?').join(',')})`).all(...payloadIds);
+    const byId = new Map(rows.map((row) => [row.payload_id, runtimeArtifactPayloadFromRow(row)]));
+    return payloadIds.flatMap((payloadId) => byId.get(payloadId) ? [byId.get(payloadId)] : []);
+}
+function runtimeSelectionPointerFromRow(row) {
+    return {
+        branchSlug: row.branch_slug,
+        scopeKind: row.scope_kind,
+        scopeId: row.scope_id,
+        selectedEvidenceSetId: row.selected_evidence_set_id,
+        selectedAt: row.selected_at,
+        selectedByGateDecisionId: row.selected_by_gate_decision_id,
+        reason: row.reason
+    };
+}
+function recordSelectionPointerActivity(db, pointer) {
+    const evidenceSet = db.prepare('SELECT source_run_id FROM evidence_sets WHERE evidence_set_id = ?').get(pointer.selectedEvidenceSetId);
+    if (!evidenceSet?.source_run_id) {
+        return;
+    }
+    const entry = {
+        contract: 'sdd-invocation-ledger-v1',
+        version: INVOCATION_LEDGER_CONTRACT_VERSION,
+        entryId: runtimeScopedId('selection-pointer', pointer.branchSlug, pointer.scopeKind, pointer.scopeId, pointer.selectedEvidenceSetId, pointer.selectedAt),
+        runId: evidenceSet.source_run_id,
+        taskId: pointer.scopeKind === 'task' ? pointer.scopeId : null,
+        branch: pointer.branchSlug,
+        kind: 'policy_evaluation',
+        ref: `selection:${pointer.scopeKind}:${pointer.scopeId}`,
+        status: 'selected',
+        timestamp: pointer.selectedAt,
+        inputHash: pointer.selectedByGateDecisionId,
+        outputHash: pointer.selectedEvidenceSetId,
+        materialRefs: [pointer.selectedEvidenceSetId],
+        metadata: {
+            scopeKind: pointer.scopeKind,
+            scopeId: pointer.scopeId,
+            selectedEvidenceSetId: pointer.selectedEvidenceSetId
+        }
+    };
+    db.prepare('INSERT OR REPLACE INTO activities (activity_id, run_id, task_id, branch, kind, ref, status, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+        .run(entry.entryId, entry.runId, entry.taskId, entry.branch, entry.kind, entry.ref, entry.status, entry.timestamp, JSON.stringify(entry));
+}
+function evidenceSetMatchesFallbackRuns(evidenceSet, fallbackRunIds) {
+    if (!fallbackRunIds || fallbackRunIds.length === 0) {
+        return true;
+    }
+    return Boolean(evidenceSet.sourceRunId && fallbackRunIds.includes(evidenceSet.sourceRunId));
+}
+function legacyFallbackPayloads(db, input) {
+    const clauses = ['status = ?', 'branch_slug = ?'];
+    const params = ['active', input.branchSlug];
+    const scopeClauses = [];
+    const scopeParams = [];
+    if (input.fallbackRunIds && input.fallbackRunIds.length > 0) {
+        scopeClauses.push(`run_id IN (${input.fallbackRunIds.map(() => '?').join(',')})`);
+        scopeParams.push(...input.fallbackRunIds);
+    }
+    if (input.fallbackTaskIds && input.fallbackTaskIds.length > 0) {
+        scopeClauses.push(`task_id IN (${input.fallbackTaskIds.map(() => '?').join(',')})`);
+        scopeParams.push(...input.fallbackTaskIds);
+    }
+    if (input.fallbackLogicalRefPrefixes && input.fallbackLogicalRefPrefixes.length > 0) {
+        scopeClauses.push(`(task_id IS NULL AND (${input.fallbackLogicalRefPrefixes.map(() => 'logical_ref LIKE ?').join(' OR ')}))`);
+        scopeParams.push(...input.fallbackLogicalRefPrefixes.map((prefix) => `${prefix}%`));
+    }
+    if (scopeClauses.length > 0) {
+        clauses.push(`(${scopeClauses.join(' OR ')})`);
+        params.push(...scopeParams);
+    }
+    const rows = db.prepare(`SELECT * FROM artifact_payloads WHERE ${clauses.join(' AND ')} ORDER BY created_at DESC, sequence DESC`).all(...params);
+    return rows.map(runtimeArtifactPayloadFromRow);
+}
 export async function recordLegacyImportFailure(projectRoot, runId, entityType, error) {
     try {
         await withRuntimeStore(projectRoot, ({ db }) => {
@@ -708,10 +1103,10 @@ export async function inspectRuntimeStoreEvidence(projectRoot) {
             const integrityRow = db.prepare('PRAGMA integrity_check').get();
             const schemaVersion = versionRow?.user_version ?? 0;
             if (schemaVersion !== RUNTIME_STORE_SCHEMA_VERSION) {
-                return [{ level: 'FAIL', check: 'runtime_store', message: `Runtime store schema version ${schemaVersion} does not match expected ${RUNTIME_STORE_SCHEMA_VERSION}.`, action: 'Run a compatible sdd version or rebuild the runtime store from legacy .sdd/runs.' }];
+                return [{ level: 'FAIL', check: 'runtime_store', message: `Runtime store schema version ${schemaVersion} does not match expected ${RUNTIME_STORE_SCHEMA_VERSION}.`, action: 'Run a compatible sdd version or rebuild runtime.sqlite projections from canonical docs and accepted stage evidence refs.' }];
             }
             if (integrityRow?.integrity_check !== 'ok') {
-                return [{ level: 'FAIL', check: 'runtime_store', message: `Runtime store integrity check failed: ${integrityRow?.integrity_check ?? 'unknown'}.`, action: 'Rebuild runtime projections from legacy .sdd/runs after preserving the database for debugging.' }];
+                return [{ level: 'FAIL', check: 'runtime_store', message: `Runtime store integrity check failed: ${integrityRow?.integrity_check ?? 'unknown'}.`, action: 'Preserve runtime.sqlite for debugging, then rebuild projections from canonical docs and accepted stage evidence refs.' }];
             }
             const checks = [{ level: 'PASS', check: 'runtime_store', message: `${RUNTIME_STORE_CONTRACT_VERSION} is available at ${storePath} with schema ${schemaVersion}.` }];
             const scopeLeak = db.prepare('SELECT COUNT(*) AS count FROM evidence_claims c JOIN runs r ON r.run_id = c.run_id WHERE c.partition IS NOT NULL AND r.partition IS NOT NULL AND c.partition <> r.partition').get();
@@ -726,7 +1121,7 @@ export async function inspectRuntimeStoreEvidence(projectRoot) {
             const failedLegacy = legacy.find((row) => row.status === 'failed')?.count ?? 0;
             const importedLegacy = legacy.find((row) => row.status === 'imported')?.count ?? 0;
             checks.push(failedLegacy > 0
-                ? { level: 'FAIL', check: 'runtime_legacy_import', message: `${failedLegacy} legacy import record(s) failed.`, action: 'Inspect legacy .sdd/runs files and repair malformed state/events/invocation evidence before test or sync-back.' }
+                ? { level: 'FAIL', check: 'runtime_legacy_import', message: `${failedLegacy} legacy import record(s) failed.`, action: 'Inspect imported runtime records and repair malformed state/events/invocation metadata before continuing.' }
                 : importedLegacy > 0
                     ? { level: 'PASS', check: 'runtime_legacy_import', message: `${importedLegacy} legacy runtime record(s) imported non-destructively; trust debt was preserved, not upgraded.` }
                     : { level: 'PASS', check: 'runtime_legacy_import', message: 'No legacy runtime import debt detected.' });
@@ -741,6 +1136,20 @@ function nextArtifactPayloadSequence(db, branchSlug, taskId, logicalRef) {
     const row = db.prepare('SELECT MAX(sequence) AS sequence FROM artifact_payloads WHERE branch_slug = ? AND ((task_id IS NULL AND ? IS NULL) OR task_id = ?) AND logical_ref = ?').get(branchSlug, taskId, taskId, logicalRef);
     return (row?.sequence ?? 0) + 1;
 }
+function runtimeTestStepFromRow(row) {
+    return {
+        stepId: row.test_step_id,
+        testRunId: row.test_run_id,
+        runId: row.run_id,
+        taskId: row.task_id,
+        command: row.command,
+        status: row.status,
+        exitCode: row.exit_code,
+        durationMs: row.duration_ms,
+        outputArtifact: row.output_artifact,
+        payload: JSON.parse(row.payload_json)
+    };
+}
 function runtimeArtifactPayloadFromRow(row) {
     return {
         payloadId: row.payload_id,
@@ -759,23 +1168,126 @@ function runtimeArtifactPayloadFromRow(row) {
         payload: JSON.parse(row.payload_json)
     };
 }
-function runtimeSyncBackDecisionFromRow(row) {
-    const parsed = JSON.parse(row.payload_json);
+function runtimeValidationCacheEntryFromRow(row) {
+    return {
+        cacheKey: row.cache_key,
+        branchSlug: row.branch_slug,
+        command: row.command,
+        status: row.status,
+        sourceTestRunId: row.source_test_run_id,
+        sourceRunId: row.source_run_id,
+        sourceEvidenceSetId: row.source_evidence_set_id,
+        outputArtifact: row.output_artifact,
+        stdoutDigest: row.stdout_digest,
+        stderrDigest: row.stderr_digest,
+        createdAt: row.created_at,
+        lastUsedAt: row.last_used_at,
+        payload: JSON.parse(row.payload_json)
+    };
+}
+function runtimeValidationCacheUseFromRow(row) {
     return {
-        decisionId: row.decision_id,
+        useId: row.use_id,
+        cacheKey: row.cache_key,
+        branchSlug: row.branch_slug,
+        testRunId: row.test_run_id,
         runId: row.run_id,
-        branch: row.branch,
         taskId: row.task_id,
+        sourceTestRunId: row.source_test_run_id,
+        sourceEvidenceSetId: row.source_evidence_set_id,
+        reusedAt: row.reused_at,
+        mappedTaskIds: parseStringList(row.mapped_task_ids_json),
+        reason: row.reason,
+        payload: JSON.parse(row.payload_json)
+    };
+}
+function runtimeRepairFromRow(row) {
+    return {
+        repairId: row.repair_id,
+        branchSlug: row.branch_slug,
+        taskId: row.task_id,
+        repairType: row.repair_type,
+        repairOfRunId: row.repair_of_run_id,
+        repairOfGateDecisionId: row.repair_of_gate_decision_id,
+        status: row.status,
+        affectedTasks: parseStringList(row.affected_tasks_json),
+        blockers: parseStringList(row.blockers_json),
+        recommendedCommands: parseStringList(row.recommended_commands_json),
+        requiredEvidence: parseStringList(row.required_evidence_json),
+        createdAt: row.created_at,
+        resolvedAt: row.resolved_at,
+        payload: JSON.parse(row.payload_json)
+    };
+}
+function runtimeCapabilityAdoptionFromRow(row) {
+    return {
+        adoptionId: row.adoption_id,
+        branchSlug: row.branch_slug,
+        lifecycleStage: row.lifecycle_stage,
+        capabilityDomain: row.capability_domain,
+        sourceId: row.source_id,
         status: row.status,
-        proposalPath: row.proposal_path,
-        proposalDigest: row.proposal_digest,
-        proposalPayloadId: row.proposal_payload_id,
-        reasons: Array.isArray(parsed.reasons) ? parsed.reasons.filter((reason) => typeof reason === 'string') : [],
+        reason: row.reason,
+        evidenceRefs: parseStringList(row.evidence_refs_json),
+        finalAuthority: row.final_authority,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
-        payload: parsed.payload ?? null
+        payload: JSON.parse(row.payload_json)
+    };
+}
+function runtimeStageArtifactFromRow(row) {
+    const payload = JSON.parse(row.payload_json);
+    return {
+        ...payload,
+        artifactId: row.artifact_id,
+        branch: row.branch_slug,
+        stage: row.stage,
+        kind: row.artifact_kind,
+        producer: row.producer,
+        ref: row.artifact_ref,
+        hash: row.content_hash,
+        contract: row.contract,
+        targetRef: row.target_ref ? runtimeRefFromStoredRef(row.target_ref, row.target_hash ?? undefined) : undefined,
+        targetHash: row.target_hash ?? undefined,
+        reviewRef: row.review_ref ? runtimeRefFromStoredRef(row.review_ref, row.review_hash ?? undefined) : undefined,
+        reviewHash: row.review_hash ?? undefined,
+        verdict: row.verdict ?? undefined,
+        findingCount: row.finding_count ?? undefined,
+        blockingCount: row.blocking_count ?? undefined,
+        recommendation: row.recommendation ?? undefined,
+        frontmatter: JSON.parse(row.frontmatter_json),
+        registeredAt: row.registered_at
     };
 }
+function runtimeStageCollaborationContractFromRow(row) {
+    const payload = JSON.parse(row.payload_json);
+    return {
+        ...payload,
+        contractId: row.contract_id,
+        branch: row.branch_slug,
+        stage: row.stage,
+        ref: row.contract_ref,
+        hash: row.content_hash,
+        contract: row.contract_version,
+        producer: row.producer,
+        workOrderId: row.work_order_id,
+        status: row.status,
+        validationErrors: JSON.parse(row.validation_errors_json),
+        selectedAgents: JSON.parse(row.selected_agents_json),
+        selectedSkills: JSON.parse(row.selected_skills_json),
+        selectedMaterialPacks: JSON.parse(row.selected_materials_json),
+        evidenceContracts: JSON.parse(row.evidence_contracts_json),
+        checkpointPlan: JSON.parse(row.checkpoint_plan_json),
+        reworkPlan: JSON.parse(row.rework_plan_json),
+        permissionProjection: JSON.parse(row.permission_projection_json),
+        frontmatter: JSON.parse(row.frontmatter_json),
+        registeredAt: row.registered_at
+    };
+}
+function runtimeRefFromStoredRef(ref, hash) {
+    const kind = ref.startsWith('specs/') ? 'document' : ref.startsWith('.sdd/runs/') ? 'artifact' : ref.startsWith('projection:') ? 'projection' : 'external';
+    return hash ? { kind, ref, hash } : { kind, ref };
+}
 function runtimeDurableGapFromRow(row) {
     return {
         gapId: row.gap_id,