sdd-agent-platform 0.4.0 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/storage/runtime-store.ts

@@ -3,11 +3,17 @@ import { mkdir, readFile } from 'node:fs/promises';
 import { getRuntimeStorePath, getSddDir } from '../runtime-paths.js';
 import { exists } from './json-io.js';
 import type { InvocationLedgerEntry, RuntimeEvent, RunState } from '../run-state/model.js';
-import { RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION, type RuntimeProjectionEnvelope, type RuntimeProjectionStaleness } from '../contracts.js';
+import { INVOCATION_LEDGER_CONTRACT_VERSION, RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION, type RuntimeProjectionEnvelope, type RuntimeProjectionStaleness } from '../contracts.js';
+import type { AgentExecutionRecord, TeamSessionRecord } from '../router/agent-runtime.js';
+import type { ResidentWorkerRuntimeRecord } from '../execution/resident-worker.js';
+import { assertAdvisoryAssessment, assertValidFanInEvidenceSet, assertValidStageRoleResult, type FanInEvidenceSetRecord, type LlmAdvisorAssessmentRecord, type StageRoleResultRecord, type StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
+import type { WorkflowGateDecision, WorkflowGateDecisionKind } from '../workflow-gate/types.js';
+import type { RegisteredStageArtifact } from '../stage-artifacts.js';
+import type { RegisteredStageCollaborationContract } from '../stage-collaboration-contracts.js';
 
 
-export const RUNTIME_STORE_SCHEMA_VERSION = 2;
-export const RUNTIME_STORE_CONTRACT_VERSION = 'phase-7.2-runtime-store-v2';
+export const RUNTIME_STORE_SCHEMA_VERSION = 12;
+export const RUNTIME_STORE_CONTRACT_VERSION = 'phase-9.1-stage-collaboration-contracts-runtime-v12';
 
 export type RuntimeStoreIssueCode = 'STORE_UNAVAILABLE' | 'SCHEMA_MISMATCH' | 'LEGACY_IMPORT_FAILED';
 
@@ -43,6 +49,224 @@ export interface RuntimeStoreDoctorCheck {
   action?: string;
 }
 
+export type RuntimeArtifactPayloadStatus = 'active' | 'candidate' | 'partial' | 'active_attempt' | 'rejected' | 'superseded' | 'quarantined' | 'stale';
+
+export interface RuntimeArtifactPayloadRecord {
+  payloadId: string;
+  runId: string;
+  sourceRunId: string;
+  branchSlug: string;
+  taskId: string | null;
+  logicalRef: string;
+  physicalPayloadPath: string;
+  artifactRole: string;
+  digest: string;
+  sequence: number;
+  status: RuntimeArtifactPayloadStatus;
+  supersedes: string | null;
+  createdAt: string;
+  payload: unknown;
+}
+
+export type RuntimeEvidenceSetScopeKind = 'task' | 'batch' | 'wave' | 'ship';
+export type RuntimeEvidenceSetStatus = 'candidate' | 'accepted' | 'partial' | 'rejected' | 'superseded' | 'quarantined' | 'stale';
+
+export interface RuntimeEvidenceSetItemRecord {
+  evidenceSetId: string;
+  payloadId: string;
+  logicalRef: string;
+  role: string;
+  required: boolean;
+  digestAtSelection: string;
+}
+
+export interface RuntimeEvidenceSetRecord {
+  evidenceSetId: string;
+  branchSlug: string;
+  scopeKind: RuntimeEvidenceSetScopeKind;
+  scopeId: string;
+  sourceRunId: string | null;
+  documentContractHashes: Record<string, string | null>;
+  gateDecisionId: string | null;
+  status: RuntimeEvidenceSetStatus;
+  createdAt: string;
+  items: RuntimeEvidenceSetItemRecord[];
+  payload: unknown;
+}
+
+export interface RuntimeSelectionPointerRecord {
+  branchSlug: string;
+  scopeKind: RuntimeEvidenceSetScopeKind;
+  scopeId: string;
+  selectedEvidenceSetId: string;
+  selectedAt: string;
+  selectedByGateDecisionId: string | null;
+  reason: string;
+}
+
+export interface RuntimeResolvedEvidenceSelection {
+  source: 'selection_pointer' | 'candidate_payloads' | 'legacy_active_payloads' | 'none';
+  evidenceSet: RuntimeEvidenceSetRecord | null;
+  pointer: RuntimeSelectionPointerRecord | null;
+  payloads: RuntimeArtifactPayloadRecord[];
+}
+
+
+export type RuntimeDurableGapSeverity = 'info' | 'warning' | 'blocking';
+export type RuntimeDurableGapStatus = 'open' | 'acknowledged' | 'resolved' | 'waived' | 'superseded';
+export type RuntimeDurableGapSource = 'runtime' | 'gate_policy' | 'doctor' | 'validator' | 'agent' | 'team' | 'llm_advisor' | 'import';
+
+export interface RuntimeDurableGapRecord {
+  gapId: string;
+  partition: string;
+  taskId: string | null;
+  runId: string | null;
+  stage: string | null;
+  gate: string | null;
+  source: RuntimeDurableGapSource;
+  category: string;
+  severity: RuntimeDurableGapSeverity;
+  status: RuntimeDurableGapStatus;
+  message: string;
+  recommendation: string | null;
+  evidenceRefs: string[];
+  proposalRefs: string[];
+  sourceRefs: string[];
+  createdAt: string;
+  updatedAt: string;
+  closedAt: string | null;
+  payload: unknown;
+}
+
+export type RuntimeValidationWaveStatus = 'RUNNING' | 'PASS' | 'FAIL' | 'BLOCKED';
+export type RuntimeValidationEnvironmentStatus = 'active' | 'completed' | 'failed' | 'blocked';
+
+export interface RuntimeValidationEnvironmentSessionRecord {
+  sessionId: string;
+  partition: string;
+  runId: string | null;
+  waveRunId: string | null;
+  status: RuntimeValidationEnvironmentStatus;
+  reuseKey: string;
+  createdAt: string;
+  updatedAt: string;
+  payload: unknown;
+}
+
+export interface RuntimeValidationWaveRunRecord {
+  waveRunId: string;
+  partition: string;
+  runId: string | null;
+  taskIds: string[];
+  status: RuntimeValidationWaveStatus;
+  environmentSessionId: string;
+  startedAt: string;
+  completedAt: string;
+  payload: unknown;
+}
+
+export interface RuntimeAcceptanceEvidenceMapRecord {
+  mapId: string;
+  waveRunId: string;
+  testRunId: string;
+  partition: string;
+  runId: string;
+  taskId: string;
+  acceptanceRef: string;
+  status: string;
+  evidenceRefs: string[];
+  gaps: string[];
+  createdAt: string;
+  payload: unknown;
+}
+
+export type RuntimeValidationCacheEntryStatus = 'valid' | 'stale' | 'superseded';
+
+export interface RuntimeValidationCacheEntryRecord {
+  cacheKey: string;
+  branchSlug: string;
+  command: string;
+  status: RuntimeValidationCacheEntryStatus;
+  sourceTestRunId: string;
+  sourceRunId: string;
+  sourceEvidenceSetId: string | null;
+  outputArtifact: string | null;
+  stdoutDigest: string;
+  stderrDigest: string;
+  createdAt: string;
+  lastUsedAt: string;
+  payload: unknown;
+}
+
+export interface RuntimeValidationCacheUseRecord {
+  useId: string;
+  cacheKey: string;
+  branchSlug: string;
+  testRunId: string;
+  runId: string;
+  taskId: string;
+  sourceTestRunId: string;
+  sourceEvidenceSetId: string | null;
+  reusedAt: string;
+  mappedTaskIds: string[];
+  reason: string;
+  payload: unknown;
+}
+
+export type RuntimeRepairType = 'contract_repair' | 'implementation_repair' | 'validation_command_repair' | 'artifact_repair' | 'environment_repair' | 'gate_policy_repair' | 'migration_repair';
+export type RuntimeRepairStatus = 'open' | 'in_progress' | 'resolved' | 'superseded';
+
+export interface RuntimeRepairRecord {
+  repairId: string;
+  branchSlug: string;
+  taskId: string | null;
+  repairType: RuntimeRepairType;
+  repairOfRunId: string | null;
+  repairOfGateDecisionId: string | null;
+  status: RuntimeRepairStatus;
+  affectedTasks: string[];
+  blockers: string[];
+  recommendedCommands: string[];
+  requiredEvidence: string[];
+  createdAt: string;
+  resolvedAt: string | null;
+  payload: unknown;
+}
+
+export type RuntimeCapabilityAdoptionStage = 'spec' | 'plan' | 'tasks' | 'verifies' | 'do' | 'test' | 'goal-verify' | 'ship';
+export type RuntimeCapabilityAdoptionStatus = 'adopted' | 'rejected' | 'unresolved';
+export type RuntimeCapabilityAdoptionAuthority = 'sdd_contract' | 'sdd_gate';
+
+export interface RuntimeCapabilityAdoptionRecord {
+  adoptionId: string;
+  branchSlug: string;
+  lifecycleStage: RuntimeCapabilityAdoptionStage;
+  capabilityDomain: string;
+  sourceId: string | null;
+  status: RuntimeCapabilityAdoptionStatus;
+  reason: string;
+  evidenceRefs: string[];
+  finalAuthority: RuntimeCapabilityAdoptionAuthority;
+  createdAt: string;
+  updatedAt: string;
+  payload: unknown;
+}
+
+export interface RuntimeStageArtifactFilter {
+  branchSlug?: string | null;
+  stage?: string | null;
+  artifactKind?: string | null;
+  producer?: string | null;
+  artifactRef?: string | null;
+}
+
+export interface RuntimeStageCollaborationContractFilter {
+  branchSlug?: string | null;
+  stage?: string | null;
+  status?: RegisteredStageCollaborationContract['status'] | null;
+  contractRef?: string | null;
+}
+
 
 let runtimeStoreConstructorPromise: Promise<RuntimeStoreConstructor> | null = null;
 
@@ -108,6 +332,8 @@ function initializeRuntimeStoreSchema(db: RuntimeStoreDatabase): void {
   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);
@@ -125,7 +351,29 @@ 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 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);
+CREATE TABLE IF NOT EXISTS llm_advisor_assessments (assessment_id TEXT PRIMARY KEY, session_id TEXT, partition TEXT NOT NULL, run_id TEXT, task_id TEXT, kind TEXT NOT NULL, concern TEXT NOT NULL, advisory_only INTEGER NOT NULL, created_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 fan_in_evidence_sets (fan_in_id TEXT PRIMARY KEY, partition TEXT NOT NULL, run_id TEXT, task_id TEXT, stage TEXT NOT NULL, gate_input_only INTEGER NOT NULL, created_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 workflow_gate_decisions (decision_id TEXT PRIMARY KEY, input_hash TEXT NOT NULL, partition TEXT NOT NULL, run_id TEXT, task_id TEXT, decision_kind TEXT NOT NULL, status TEXT NOT NULL, decided_by TEXT NOT NULL, generated_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_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);
@@ -134,6 +382,31 @@ CREATE INDEX IF NOT EXISTS idx_evidence_attachments_branch_created ON evidence_a
 CREATE INDEX IF NOT EXISTS idx_evidence_attachments_run_path ON evidence_attachments(run_id, relative_path);
 CREATE INDEX IF NOT EXISTS idx_test_runs_run_task ON test_runs(run_id, task_id, completed_at);
 CREATE INDEX IF NOT EXISTS idx_test_steps_test_run ON test_steps(test_run_id, status);
+CREATE INDEX IF NOT EXISTS idx_agent_executions_run_task ON agent_executions(run_id, task_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_team_sessions_run_task ON team_sessions(run_id, task_id, created_at);
+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_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);
+CREATE INDEX IF NOT EXISTS idx_stage_role_results_partition_task ON stage_role_results(partition, task_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_llm_advisor_assessments_partition_task ON llm_advisor_assessments(partition, task_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_fan_in_evidence_sets_partition_task ON fan_in_evidence_sets(partition, task_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_workflow_gate_decisions_partition_task ON workflow_gate_decisions(partition, task_id, decision_kind, generated_at);
+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();
@@ -141,6 +414,43 @@ CREATE INDEX IF NOT EXISTS idx_test_steps_test_run ON test_steps(test_run_id, st
   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: RuntimeStoreDatabase, currentVersion: number): void {
+  if (currentVersion === 0 || currentVersion >= RUNTIME_STORE_SCHEMA_VERSION) {
+    return;
+  }
+  if (currentVersion < 12) {
+    migrateNullableOutputArtifactColumns(db);
+  }
+}
+
+function migrateNullableOutputArtifactColumns(db: RuntimeStoreDatabase): void {
+  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: RuntimeStoreDatabase, tableName: string, columnDefinitionSql: string, columnsSql: string): void {
+  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: RuntimeStoreDatabase, tableName: string, columnName: string): boolean {
+  const rows = db.prepare(`PRAGMA table_info(${tableName})`).all() as Array<{ name?: string; notnull?: number }>;
+  const column = rows.find((row) => row.name === columnName);
+  return (column?.notnull ?? 0) === 1;
+}
+
 function readRuntimeStoreSchemaVersion(db: RuntimeStoreDatabase): number {
   const row = db.prepare('PRAGMA user_version').get() as { user_version?: unknown } | undefined;
   return typeof row?.user_version === 'number' ? row.user_version : 0;
@@ -209,6 +519,161 @@ export async function listRuntimeRunStates(projectRoot: string): Promise<RunStat
   });
 }
 
+export async function recordRuntimeAgentExecution(projectRoot: string, record: AgentExecutionRecord): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO agent_executions (execution_id, run_id, task_id, profile, status, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.executionId, record.runId, record.taskId, record.profile, record.status, record.createdAt, record.updatedAt, JSON.stringify(record));
+  });
+}
+
+export async function listRuntimeAgentExecutions(projectRoot: string, runId: string): Promise<AgentExecutionRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const rows = db.prepare('SELECT payload_json FROM agent_executions WHERE run_id = ? ORDER BY created_at ASC, execution_id ASC').all(runId) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as AgentExecutionRecord);
+  });
+}
+
+export async function recordRuntimeTeamSession(projectRoot: string, record: TeamSessionRecord): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO team_sessions (team_id, run_id, task_id, status, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?)')
+      .run(record.teamId, record.runId, record.taskId, record.status, record.createdAt, record.updatedAt, JSON.stringify(record));
+  });
+}
+
+export async function listRuntimeTeamSessions(projectRoot: string, runId: string): Promise<TeamSessionRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const rows = db.prepare('SELECT payload_json FROM team_sessions WHERE run_id = ? ORDER BY created_at ASC, team_id ASC').all(runId) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as TeamSessionRecord);
+  });
+}
+
+export async function recordRuntimeStageTeamSession(projectRoot: string, record: StageTeamSessionRecord): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO stage_team_sessions (session_id, partition, run_id, task_id, stage, lifecycle_profile, status, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.sessionId, record.partition, record.runId, record.taskId, record.stage, record.lifecycleProfile, record.status, record.createdAt, record.updatedAt, JSON.stringify(record));
+  });
+}
+
+export async function listRuntimeStageTeamSessions(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null } = {}): Promise<StageTeamSessionRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    appendRuntimeScopeClauses(clauses, params, input);
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT payload_json FROM stage_team_sessions${where} ORDER BY updated_at DESC, session_id ASC`).all(...params) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as StageTeamSessionRecord);
+  });
+}
+
+export async function recordRuntimeStageRoleResult(projectRoot: string, record: StageRoleResultRecord): Promise<void> {
+  assertValidStageRoleResult(record);
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO stage_role_results (result_id, session_id, partition, run_id, task_id, role_id, agent_id, output_kind, authority_ceiling, status, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.resultId, record.sessionId, record.partition, record.runId, record.taskId, record.roleId, record.agentId, record.outputKind, record.authorityCeiling, record.status, record.createdAt, JSON.stringify(record));
+  });
+}
+
+export async function listRuntimeStageRoleResults(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null; sessionId?: string | null } = {}): Promise<StageRoleResultRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    appendRuntimeScopeClauses(clauses, params, input);
+    if (input.sessionId) {
+      clauses.push('session_id = ?');
+      params.push(input.sessionId);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT payload_json FROM stage_role_results${where} ORDER BY created_at ASC, result_id ASC`).all(...params) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as StageRoleResultRecord);
+  });
+}
+
+export async function recordRuntimeLlmAdvisorAssessment(projectRoot: string, record: LlmAdvisorAssessmentRecord): Promise<void> {
+  assertAdvisoryAssessment(record);
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO llm_advisor_assessments (assessment_id, session_id, partition, run_id, task_id, kind, concern, advisory_only, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.assessmentId, record.sessionId, record.partition, record.runId, record.taskId, record.kind, record.concern, record.advisoryOnly ? 1 : 0, record.createdAt, JSON.stringify(record));
+  });
+}
+
+export async function listRuntimeLlmAdvisorAssessments(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null; sessionId?: string | null } = {}): Promise<LlmAdvisorAssessmentRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    appendRuntimeScopeClauses(clauses, params, input);
+    if (input.sessionId) {
+      clauses.push('session_id = ?');
+      params.push(input.sessionId);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT payload_json FROM llm_advisor_assessments${where} ORDER BY created_at ASC, assessment_id ASC`).all(...params) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as LlmAdvisorAssessmentRecord);
+  });
+}
+
+export async function recordRuntimeFanInEvidenceSet(projectRoot: string, record: FanInEvidenceSetRecord): Promise<void> {
+  assertValidFanInEvidenceSet(record);
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO fan_in_evidence_sets (fan_in_id, partition, run_id, task_id, stage, gate_input_only, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.fanInId, record.partition, record.runId, record.taskId, record.stage, record.gateInputOnly ? 1 : 0, record.createdAt, JSON.stringify(record));
+  });
+}
+
+export async function listRuntimeFanInEvidenceSets(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null } = {}): Promise<FanInEvidenceSetRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    appendRuntimeScopeClauses(clauses, params, input);
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT payload_json FROM fan_in_evidence_sets${where} ORDER BY created_at ASC, fan_in_id ASC`).all(...params) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as FanInEvidenceSetRecord);
+  });
+}
+
+export async function recordRuntimeWorkflowGateDecision(projectRoot: string, decision: WorkflowGateDecision): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO workflow_gate_decisions (decision_id, input_hash, partition, run_id, task_id, decision_kind, status, decided_by, generated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(decision.decisionId, decision.inputHash, decision.partition, decision.runId, decision.taskId, decision.decisionKind, decision.status, decision.decidedBy, decision.generatedAt, JSON.stringify(decision));
+  });
+}
+
+export async function listRuntimeWorkflowGateDecisions(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null; decisionKind?: WorkflowGateDecisionKind | null } = {}): Promise<WorkflowGateDecision[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    appendRuntimeScopeClauses(clauses, params, input);
+    if (input.decisionKind) {
+      clauses.push('decision_kind = ?');
+      params.push(input.decisionKind);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT payload_json FROM workflow_gate_decisions${where} ORDER BY generated_at DESC, decision_id ASC`).all(...params) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as WorkflowGateDecision);
+  });
+}
+
+
+export async function recordRuntimeWorkerRuntime(projectRoot: string, record: ResidentWorkerRuntimeRecord): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO worker_runtimes (runtime_id, run_id, task_id, status, claimed_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?)')
+      .run(record.runtimeId, record.runId, record.taskId, record.status, record.claimedAt, record.updatedAt, JSON.stringify(record));
+  });
+}
+
+export async function readRuntimeWorkerRuntime(projectRoot: string, runId: string, runtimeId: string): Promise<ResidentWorkerRuntimeRecord | null> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const row = db.prepare('SELECT payload_json FROM worker_runtimes WHERE run_id = ? AND runtime_id = ?').get(runId, runtimeId) as { payload_json?: string } | undefined;
+    return row?.payload_json ? JSON.parse(row.payload_json) as ResidentWorkerRuntimeRecord : null;
+  });
+}
+
+export async function listRuntimeWorkerRuntimes(projectRoot: string, runId: string): Promise<ResidentWorkerRuntimeRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const rows = db.prepare('SELECT payload_json FROM worker_runtimes WHERE run_id = ? ORDER BY updated_at ASC, runtime_id ASC').all(runId) as Array<{ payload_json: string }>;
+    return rows.map((row) => JSON.parse(row.payload_json) as ResidentWorkerRuntimeRecord);
+  });
+}
+
 export async function recordRuntimeActivity(projectRoot: string, entry: InvocationLedgerEntry): Promise<void> {
   await withRuntimeStore(projectRoot, ({ db }) => {
     db.prepare('INSERT OR REPLACE INTO activities (activity_id, run_id, task_id, branch, kind, ref, status, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
@@ -232,6 +697,277 @@ export async function recordRuntimeEvidenceAttachment(projectRoot: string, input
   });
 }
 
+export async function recordRuntimeStageArtifact(projectRoot: string, record: RegisteredStageArtifact): Promise<RegisteredStageArtifact> {
+  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: string, filter: RuntimeStageArtifactFilter = {}): Promise<RegisteredStageArtifact[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeStageArtifactRow[];
+    return rows.map(runtimeStageArtifactFromRow);
+  });
+}
+
+export async function readRuntimeStageArtifact(projectRoot: string, artifactId: string): Promise<RegisteredStageArtifact | null> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const row = db.prepare('SELECT * FROM stage_artifacts WHERE artifact_id = ?').get(artifactId) as RuntimeStageArtifactRow | undefined;
+    return row ? runtimeStageArtifactFromRow(row) : null;
+  });
+}
+
+export async function recordRuntimeStageCollaborationContract(projectRoot: string, record: RegisteredStageCollaborationContract): Promise<RegisteredStageCollaborationContract> {
+  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: string, filter: RuntimeStageCollaborationContractFilter = {}): Promise<RegisteredStageCollaborationContract[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeStageCollaborationContractRow[];
+    return rows.map(runtimeStageCollaborationContractFromRow);
+  });
+}
+
+export async function readRuntimeStageCollaborationContract(projectRoot: string, contractId: string): Promise<RegisteredStageCollaborationContract | null> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const row = db.prepare('SELECT * FROM stage_collaboration_contracts WHERE contract_id = ?').get(contractId) as RuntimeStageCollaborationContractRow | undefined;
+    return row ? runtimeStageCollaborationContractFromRow(row) : null;
+  });
+}
+
+export async function recordRuntimeArtifactPayload(projectRoot: string, input: Omit<RuntimeArtifactPayloadRecord, 'sequence' | 'supersedes' | 'createdAt'> & { sequence?: number; supersedes?: string | null; createdAt?: string }): Promise<RuntimeArtifactPayloadRecord> {
+  const createdAt = input.createdAt ?? new Date().toISOString();
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const sequence = input.sequence ?? nextArtifactPayloadSequence(db, input.branchSlug, input.taskId, input.logicalRef);
+    const activePayload = input.status === 'active'
+      ? db.prepare('SELECT payload_id FROM artifact_payloads WHERE branch_slug = ? AND ((task_id IS NULL AND ? IS NULL) OR task_id = ?) AND logical_ref = ? AND status = ? ORDER BY sequence DESC LIMIT 1').get(input.branchSlug, input.taskId, input.taskId, input.logicalRef, 'active') as { payload_id?: string } | undefined
+      : undefined;
+    const supersedes = input.supersedes ?? activePayload?.payload_id ?? null;
+    if (input.status === 'active') {
+      db.prepare('UPDATE artifact_payloads SET status = ? WHERE branch_slug = ? AND ((task_id IS NULL AND ? IS NULL) OR task_id = ?) AND logical_ref = ? AND status = ?')
+        .run('superseded', input.branchSlug, input.taskId, input.taskId, input.logicalRef, 'active');
+    }
+
+    const record: RuntimeArtifactPayloadRecord = {
+      ...input,
+      sequence,
+      supersedes,
+      createdAt
+    };
+    db.prepare('INSERT OR REPLACE INTO artifact_payloads (payload_id, run_id, source_run_id, branch_slug, task_id, logical_ref, physical_payload_path, artifact_role, digest, sequence, status, supersedes, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.payloadId, record.runId, record.sourceRunId, record.branchSlug, record.taskId, record.logicalRef, record.physicalPayloadPath, record.artifactRole, record.digest, record.sequence, record.status, record.supersedes, record.createdAt, JSON.stringify(record.payload));
+    return record;
+  });
+}
+
+export async function resolveRuntimeArtifactPayload(projectRoot: string, runId: string, logicalRef: string): Promise<RuntimeArtifactPayloadRecord | null> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const row = db.prepare('SELECT * FROM artifact_payloads WHERE run_id = ? AND logical_ref = ? ORDER BY CASE status WHEN \'active\' THEN 0 WHEN \'candidate\' THEN 1 WHEN \'superseded\' THEN 2 ELSE 3 END ASC, sequence DESC').get(runId, logicalRef) as RuntimeArtifactPayloadRow | undefined;
+    return row ? runtimeArtifactPayloadFromRow(row) : null;
+  });
+}
+
+export async function listRuntimeArtifactPayloads(projectRoot: string, input: { runId?: string | null; branchSlug?: string | null; taskId?: string | null; logicalRef?: string | null; status?: RuntimeArtifactPayloadStatus | null } = {}): Promise<RuntimeArtifactPayloadRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    if (input.runId) {
+      clauses.push('run_id = ?');
+      params.push(input.runId);
+    }
+    if (input.branchSlug) {
+      clauses.push('branch_slug = ?');
+      params.push(input.branchSlug);
+    }
+    if (input.taskId) {
+      clauses.push('task_id = ?');
+      params.push(input.taskId);
+    }
+    if (input.logicalRef) {
+      clauses.push('logical_ref = ?');
+      params.push(input.logicalRef);
+    }
+    if (input.status) {
+      clauses.push('status = ?');
+      params.push(input.status);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT * FROM artifact_payloads${where} ORDER BY created_at DESC, sequence DESC`).all(...params) as RuntimeArtifactPayloadRow[];
+    return rows.map(runtimeArtifactPayloadFromRow);
+  });
+}
+
+export async function createRuntimeEvidenceSet(projectRoot: string, input: Omit<RuntimeEvidenceSetRecord, 'createdAt'> & { createdAt?: string }): Promise<RuntimeEvidenceSetRecord> {
+  const createdAt = input.createdAt ?? new Date().toISOString();
+  const record: RuntimeEvidenceSetRecord = { ...input, createdAt };
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    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 updateRuntimeSelectionPointer(projectRoot: string, pointer: RuntimeSelectionPointerRecord): Promise<RuntimeSelectionPointerRecord> {
+  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) as { selected_evidence_set_id?: string } | undefined;
+    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 resolveRuntimeSelectedEvidence(projectRoot: string, input: { branchSlug: string; scopeKind: RuntimeEvidenceSetScopeKind; scopeId: string; fallbackRunIds?: string[]; fallbackTaskIds?: string[]; fallbackLogicalRefPrefixes?: string[]; allowCandidateFallback?: boolean }): Promise<RuntimeResolvedEvidenceSelection> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const pointerRow = db.prepare('SELECT * FROM selection_pointers WHERE branch_slug = ? AND scope_kind = ? AND scope_id = ?').get(input.branchSlug, input.scopeKind, input.scopeId) as RuntimeSelectionPointerRow | undefined;
+    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: string, input: Omit<RuntimeDurableGapRecord, 'createdAt' | 'updatedAt' | 'closedAt'> & { createdAt?: string; updatedAt?: string; closedAt?: string | null }): Promise<RuntimeDurableGapRecord> {
+  const createdAt = input.createdAt ?? new Date().toISOString();
+  const updatedAt = input.updatedAt ?? createdAt;
+  const record: RuntimeDurableGapRecord = {
+    ...input,
+    createdAt,
+    updatedAt,
+    closedAt: input.closedAt ?? (terminalGapStatus(input.status) ? updatedAt : null)
+  };
+  assertDurableGapStatusAuthority(record.source, record.status);
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO durable_gaps (gap_id, partition, task_id, run_id, stage, gate_name, source, category, severity, status, message, recommendation, evidence_refs_json, proposal_refs_json, source_refs_json, created_at, updated_at, closed_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.gapId, record.partition, record.taskId, record.runId, record.stage, record.gate, record.source, record.category, record.severity, record.status, record.message, record.recommendation, JSON.stringify(record.evidenceRefs), JSON.stringify(record.proposalRefs), JSON.stringify(record.sourceRefs), record.createdAt, record.updatedAt, record.closedAt, JSON.stringify(record.payload));
+  });
+  return record;
+}
+
+export async function updateRuntimeDurableGapStatus(projectRoot: string, input: { gapId: string; status: RuntimeDurableGapStatus; source: RuntimeDurableGapSource; payload?: unknown; updatedAt?: string }): Promise<RuntimeDurableGapRecord | null> {
+  assertDurableGapStatusAuthority(input.source, input.status);
+  const updatedAt = input.updatedAt ?? new Date().toISOString();
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const row = db.prepare('SELECT * FROM durable_gaps WHERE gap_id = ?').get(input.gapId) as RuntimeDurableGapRow | undefined;
+    if (!row) {
+      return null;
+    }
+    const existing = runtimeDurableGapFromRow(row);
+    const payload = input.payload ?? existing.payload;
+    const closedAt = terminalGapStatus(input.status) ? updatedAt : null;
+    db.prepare('UPDATE durable_gaps SET status = ?, source = ?, updated_at = ?, closed_at = ?, payload_json = ? WHERE gap_id = ?')
+      .run(input.status, input.source, updatedAt, closedAt, JSON.stringify(payload), input.gapId);
+    return {
+      ...existing,
+      source: input.source,
+      status: input.status,
+      updatedAt,
+      closedAt,
+      payload
+    };
+  });
+}
+
+export async function listRuntimeDurableGaps(projectRoot: string, input: { partition?: string | null; taskId?: string | null; runId?: string | null; status?: RuntimeDurableGapStatus | 'open_terminal' | null; severity?: RuntimeDurableGapSeverity | null } = {}): Promise<RuntimeDurableGapRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    if (input.partition) {
+      clauses.push('partition = ?');
+      params.push(input.partition);
+    }
+    if (input.taskId) {
+      clauses.push('task_id = ?');
+      params.push(input.taskId);
+    }
+    if (input.runId) {
+      clauses.push('run_id = ?');
+      params.push(input.runId);
+    }
+    if (input.status === 'open_terminal') {
+      clauses.push("status IN ('open', 'acknowledged')");
+    } else if (input.status) {
+      clauses.push('status = ?');
+      params.push(input.status);
+    }
+    if (input.severity) {
+      clauses.push('severity = ?');
+      params.push(input.severity);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT * FROM durable_gaps${where} ORDER BY updated_at DESC, gap_id ASC`).all(...params) as RuntimeDurableGapRow[];
+    return rows.map(runtimeDurableGapFromRow);
+  });
+}
+
 export async function recordRuntimeProjection(projectRoot: string, projectionType: string, scopeKey: string, payload: unknown): Promise<void> {
   const now = new Date().toISOString();
   await withRuntimeStore(projectRoot, ({ db }) => {
@@ -351,13 +1087,13 @@ export interface RuntimeTestStepRecord {
   status: string;
   exitCode: number | null;
   durationMs: number;
-  outputArtifact: string;
+  outputArtifact: string | null;
   payload: unknown;
 }
 
 export async function recordRuntimeTestRun(projectRoot: string, record: RuntimeTestRunRecord): Promise<void> {
   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));
   });
 }
@@ -369,6 +1105,24 @@ export async function recordRuntimeTestStep(projectRoot: string, record: Runtime
   });
 }
 
+export async function listRuntimeTestSteps(projectRoot: string, input: { runId?: string | null; testRunId?: string | null } = {}): Promise<RuntimeTestStepRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeTestStepRow[];
+    return rows.map(runtimeTestStepFromRow);
+  });
+}
+
 export async function listRuntimeTestRuns(projectRoot: string, runId?: string | null): Promise<RuntimeTestRunRecord[]> {
   return withRuntimeStore(projectRoot, ({ db }) => {
     const rows = runId
@@ -387,6 +1141,371 @@ export async function listRuntimeTestRuns(projectRoot: string, runId?: string |
   });
 }
 
+export async function recordRuntimeValidationCacheEntry(projectRoot: string, record: RuntimeValidationCacheEntryRecord): Promise<void> {
+  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: string, input: { branchSlug: string; cacheKey: string }): Promise<RuntimeValidationCacheEntryRecord | null> {
+  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') as RuntimeValidationCacheEntryRow | undefined;
+    return row ? runtimeValidationCacheEntryFromRow(row) : null;
+  });
+}
+
+export async function listRuntimeValidationCacheEntries(projectRoot: string, input: { branchSlug?: string | null; status?: RuntimeValidationCacheEntryStatus | null } = {}): Promise<RuntimeValidationCacheEntryRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeValidationCacheEntryRow[];
+    return rows.map(runtimeValidationCacheEntryFromRow);
+  });
+}
+
+export async function recordRuntimeValidationCacheUse(projectRoot: string, record: RuntimeValidationCacheUseRecord): Promise<void> {
+  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: string, input: { branchSlug?: string | null; runId?: string | null; taskId?: string | null } = {}): Promise<RuntimeValidationCacheUseRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeValidationCacheUseRow[];
+    return rows.map(runtimeValidationCacheUseFromRow);
+  });
+}
+
+export async function recordRuntimeRepair(projectRoot: string, record: RuntimeRepairRecord): Promise<void> {
+  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: string, input: { branchSlug?: string | null; taskId?: string | null; status?: RuntimeRepairStatus | null } = {}): Promise<RuntimeRepairRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeRepairRow[];
+    return rows.map(runtimeRepairFromRow);
+  });
+}
+
+export async function recordRuntimeCapabilityAdoption(projectRoot: string, record: RuntimeCapabilityAdoptionRecord): Promise<void> {
+  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: string, input: { branchSlug?: string | null; lifecycleStage?: RuntimeCapabilityAdoptionStage | null; capabilityDomain?: string | null; status?: RuntimeCapabilityAdoptionStatus | null } = {}): Promise<RuntimeCapabilityAdoptionRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    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) as RuntimeCapabilityAdoptionRow[];
+    return rows.map(runtimeCapabilityAdoptionFromRow);
+  });
+}
+
+export async function recordRuntimeValidationEnvironmentSession(projectRoot: string, record: RuntimeValidationEnvironmentSessionRecord): Promise<void> {
+  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 (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.sessionId, record.partition, record.runId, record.waveRunId, record.status, record.reuseKey, record.createdAt, record.updatedAt, JSON.stringify(record.payload));
+  });
+}
+
+export async function listRuntimeValidationEnvironmentSessions(projectRoot: string, input: { partition?: string | null; runId?: string | null; waveRunId?: string | null } = {}): Promise<RuntimeValidationEnvironmentSessionRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    if (input.partition) {
+      clauses.push('partition = ?');
+      params.push(input.partition);
+    }
+    if (input.runId) {
+      clauses.push('run_id = ?');
+      params.push(input.runId);
+    }
+    if (input.waveRunId) {
+      clauses.push('wave_run_id = ?');
+      params.push(input.waveRunId);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT session_id, partition, run_id, wave_run_id, status, reuse_key, created_at, updated_at, payload_json FROM validation_environment_sessions${where} ORDER BY updated_at DESC, session_id ASC`).all(...params) as Array<{ session_id: string; partition: string; run_id: string | null; wave_run_id: string | null; status: RuntimeValidationEnvironmentStatus; reuse_key: string; created_at: string; updated_at: string; payload_json: string }>;
+    return rows.map((row) => ({ sessionId: row.session_id, partition: row.partition, runId: row.run_id, waveRunId: row.wave_run_id, status: row.status, reuseKey: row.reuse_key, createdAt: row.created_at, updatedAt: row.updated_at, payload: JSON.parse(row.payload_json) }));
+  });
+}
+
+export async function recordRuntimeValidationWaveRun(projectRoot: string, record: RuntimeValidationWaveRunRecord): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO validation_wave_runs (wave_run_id, partition, run_id, task_ids_json, status, environment_session_id, started_at, completed_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.waveRunId, record.partition, record.runId, JSON.stringify(record.taskIds), record.status, record.environmentSessionId, record.startedAt, record.completedAt, JSON.stringify(record.payload));
+  });
+}
+
+export async function listRuntimeValidationWaveRuns(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null; waveRunId?: string | null } = {}): Promise<RuntimeValidationWaveRunRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    if (input.partition) {
+      clauses.push('partition = ?');
+      params.push(input.partition);
+    }
+    if (input.runId) {
+      clauses.push('run_id = ?');
+      params.push(input.runId);
+    }
+    if (input.waveRunId) {
+      clauses.push('wave_run_id = ?');
+      params.push(input.waveRunId);
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db.prepare(`SELECT wave_run_id, partition, run_id, task_ids_json, status, environment_session_id, started_at, completed_at, payload_json FROM validation_wave_runs${where} ORDER BY completed_at DESC, wave_run_id ASC`).all(...params) as Array<{ wave_run_id: string; partition: string; run_id: string | null; task_ids_json: string; status: RuntimeValidationWaveStatus; environment_session_id: string; started_at: string; completed_at: string; payload_json: string }>;
+    return rows
+      .map((row) => ({ waveRunId: row.wave_run_id, partition: row.partition, runId: row.run_id, taskIds: JSON.parse(row.task_ids_json) as string[], status: row.status, environmentSessionId: row.environment_session_id, startedAt: row.started_at, completedAt: row.completed_at, payload: JSON.parse(row.payload_json) }))
+      .filter((record) => !input.taskId || record.taskIds.includes(input.taskId));
+  });
+}
+
+export async function recordRuntimeAcceptanceEvidenceMap(projectRoot: string, record: RuntimeAcceptanceEvidenceMapRecord): Promise<void> {
+  await withRuntimeStore(projectRoot, ({ db }) => {
+    db.prepare('INSERT OR REPLACE INTO acceptance_evidence_maps (map_id, wave_run_id, test_run_id, partition, run_id, task_id, acceptance_ref, status, evidence_refs_json, gaps_json, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(record.mapId, record.waveRunId, record.testRunId, record.partition, record.runId, record.taskId, record.acceptanceRef, record.status, JSON.stringify(record.evidenceRefs), JSON.stringify(record.gaps), record.createdAt, JSON.stringify(record.payload));
+  });
+}
+
+export async function listRuntimeAcceptanceEvidenceMaps(projectRoot: string, input: { partition?: string | null; runId?: string | null; taskId?: string | null; waveRunId?: string | null; testRunId?: string | null } = {}): Promise<RuntimeAcceptanceEvidenceMapRecord[]> {
+  return withRuntimeStore(projectRoot, ({ db }) => {
+    const clauses: string[] = [];
+    const params: string[] = [];
+    if (input.partition) {
+      clauses.push('partition = ?');
+      params.push(input.partition);
+    }
+    if (input.runId) {
+      clauses.push('run_id = ?');
+      params.push(input.runId);
+    }
+    if (input.taskId) {
+      clauses.push('task_id = ?');
+      params.push(input.taskId);
+    }
+    if (input.waveRunId) {
+      clauses.push('wave_run_id = ?');
+      params.push(input.waveRunId);
+    }
+    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 map_id, wave_run_id, test_run_id, partition, run_id, task_id, acceptance_ref, status, evidence_refs_json, gaps_json, created_at, payload_json FROM acceptance_evidence_maps${where} ORDER BY created_at DESC, map_id ASC`).all(...params) as Array<{ map_id: string; wave_run_id: string; test_run_id: string; partition: string; run_id: string; task_id: string; acceptance_ref: string; status: string; evidence_refs_json: string; gaps_json: string; created_at: string; payload_json: string }>;
+    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) as string[], gaps: JSON.parse(row.gaps_json) as string[], createdAt: row.created_at, payload: JSON.parse(row.payload_json) }));
+  });
+}
+
+interface RuntimeEvidenceSetRow {
+  evidence_set_id: string;
+  branch_slug: string;
+  scope_kind: RuntimeEvidenceSetScopeKind;
+  scope_id: string;
+  source_run_id: string | null;
+  document_contract_hashes_json: string;
+  gate_decision_id: string | null;
+  status: RuntimeEvidenceSetStatus;
+  created_at: string;
+  payload_json: string;
+}
+
+interface RuntimeEvidenceSetItemRow {
+  evidence_set_id: string;
+  payload_id: string;
+  logical_ref: string;
+  role: string;
+  required: number;
+  digest_at_selection: string;
+}
+
+interface RuntimeSelectionPointerRow {
+  branch_slug: string;
+  scope_kind: RuntimeEvidenceSetScopeKind;
+  scope_id: string;
+  selected_evidence_set_id: string;
+  selected_at: string;
+  selected_by_gate_decision_id: string | null;
+  reason: string;
+}
+
+function runtimeEvidenceSetFromDb(db: RuntimeStoreDatabase, evidenceSetId: string): RuntimeEvidenceSetRecord | null {
+  const row = db.prepare('SELECT * FROM evidence_sets WHERE evidence_set_id = ?').get(evidenceSetId) as RuntimeEvidenceSetRow | undefined;
+  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) as RuntimeEvidenceSetItemRow[];
+  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) as Record<string, string | null>,
+    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: RuntimeStoreDatabase, evidenceSet: RuntimeEvidenceSetRecord): RuntimeArtifactPayloadRecord[] {
+  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) as RuntimeArtifactPayloadRow[];
+  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: RuntimeSelectionPointerRow): RuntimeSelectionPointerRecord {
+  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: RuntimeStoreDatabase, pointer: RuntimeSelectionPointerRecord): void {
+  const evidenceSet = db.prepare('SELECT source_run_id FROM evidence_sets WHERE evidence_set_id = ?').get(pointer.selectedEvidenceSetId) as { source_run_id?: string | null } | undefined;
+  if (!evidenceSet?.source_run_id) {
+    return;
+  }
+  const entry: InvocationLedgerEntry = {
+    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: RuntimeEvidenceSetRecord, fallbackRunIds?: string[]): boolean {
+  if (!fallbackRunIds || fallbackRunIds.length === 0) {
+    return true;
+  }
+  return Boolean(evidenceSet.sourceRunId && fallbackRunIds.includes(evidenceSet.sourceRunId));
+}
+
+function legacyFallbackPayloads(db: RuntimeStoreDatabase, input: { branchSlug: string; fallbackRunIds?: string[]; fallbackTaskIds?: string[]; fallbackLogicalRefPrefixes?: string[] }): RuntimeArtifactPayloadRecord[] {
+  const clauses = ['status = ?', 'branch_slug = ?'];
+  const params: string[] = ['active', input.branchSlug];
+  const scopeClauses: string[] = [];
+  const scopeParams: string[] = [];
+  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) as RuntimeArtifactPayloadRow[];
+  return rows.map(runtimeArtifactPayloadFromRow);
+}
+
 export async function recordLegacyImportFailure(projectRoot: string, runId: string, entityType: string, error: unknown): Promise<void> {
   try {
     await withRuntimeStore(projectRoot, ({ db }) => {
@@ -405,10 +1524,10 @@ export async function inspectRuntimeStoreEvidence(projectRoot: string): Promise<
       const integrityRow = db.prepare('PRAGMA integrity_check').get() as { integrity_check?: string } | undefined;
       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: RuntimeStoreDoctorCheck[] = [{ 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() as { count?: number } | undefined;
@@ -423,7 +1542,7 @@ export async function inspectRuntimeStoreEvidence(projectRoot: string): Promise<
       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.' });
@@ -434,6 +1553,373 @@ export async function inspectRuntimeStoreEvidence(projectRoot: string): Promise<
   }
 }
 
+interface RuntimeArtifactPayloadRow {
+  payload_id: string;
+  run_id: string;
+  source_run_id: string;
+  branch_slug: string;
+  task_id: string | null;
+  logical_ref: string;
+  physical_payload_path: string;
+  artifact_role: string;
+  digest: string;
+  sequence: number;
+  status: RuntimeArtifactPayloadStatus;
+  supersedes: string | null;
+  created_at: string;
+  payload_json: string;
+}
+
+function nextArtifactPayloadSequence(db: RuntimeStoreDatabase, branchSlug: string, taskId: string | null, logicalRef: string): number {
+  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) as { sequence?: number | null } | undefined;
+  return (row?.sequence ?? 0) + 1;
+}
+
+interface RuntimeTestStepRow {
+  test_step_id: string;
+  test_run_id: string;
+  run_id: string;
+  task_id: string;
+  command: string;
+  status: string;
+  exit_code: number | null;
+  duration_ms: number;
+  output_artifact: string | null;
+  payload_json: string;
+}
+
+function runtimeTestStepFromRow(row: RuntimeTestStepRow): RuntimeTestStepRecord {
+  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: RuntimeArtifactPayloadRow): RuntimeArtifactPayloadRecord {
+  return {
+    payloadId: row.payload_id,
+    runId: row.run_id,
+    sourceRunId: row.source_run_id,
+    branchSlug: row.branch_slug,
+    taskId: row.task_id,
+    logicalRef: row.logical_ref,
+    physicalPayloadPath: row.physical_payload_path,
+    artifactRole: row.artifact_role,
+    digest: row.digest,
+    sequence: row.sequence,
+    status: row.status,
+    supersedes: row.supersedes,
+    createdAt: row.created_at,
+    payload: JSON.parse(row.payload_json)
+  };
+}
+
+
+interface RuntimeValidationCacheEntryRow {
+  cache_key: string;
+  branch_slug: string;
+  command: string;
+  status: RuntimeValidationCacheEntryStatus;
+  source_test_run_id: string;
+  source_run_id: string;
+  source_evidence_set_id: string | null;
+  output_artifact: string | null;
+  stdout_digest: string;
+  stderr_digest: string;
+  created_at: string;
+  last_used_at: string;
+  payload_json: string;
+}
+
+function runtimeValidationCacheEntryFromRow(row: RuntimeValidationCacheEntryRow): RuntimeValidationCacheEntryRecord {
+  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)
+  };
+}
+
+interface RuntimeValidationCacheUseRow {
+  use_id: string;
+  cache_key: string;
+  branch_slug: string;
+  test_run_id: string;
+  run_id: string;
+  task_id: string;
+  source_test_run_id: string;
+  source_evidence_set_id: string | null;
+  reused_at: string;
+  mapped_task_ids_json: string;
+  reason: string;
+  payload_json: string;
+}
+
+function runtimeValidationCacheUseFromRow(row: RuntimeValidationCacheUseRow): RuntimeValidationCacheUseRecord {
+  return {
+    useId: row.use_id,
+    cacheKey: row.cache_key,
+    branchSlug: row.branch_slug,
+    testRunId: row.test_run_id,
+    runId: row.run_id,
+    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)
+  };
+}
+
+interface RuntimeRepairRow {
+  repair_id: string;
+  branch_slug: string;
+  task_id: string | null;
+  repair_type: RuntimeRepairType;
+  repair_of_run_id: string | null;
+  repair_of_gate_decision_id: string | null;
+  status: RuntimeRepairStatus;
+  affected_tasks_json: string;
+  blockers_json: string;
+  recommended_commands_json: string;
+  required_evidence_json: string;
+  created_at: string;
+  resolved_at: string | null;
+  payload_json: string;
+}
+
+function runtimeRepairFromRow(row: RuntimeRepairRow): RuntimeRepairRecord {
+  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)
+  };
+}
+
+interface RuntimeCapabilityAdoptionRow {
+  adoption_id: string;
+  branch_slug: string;
+  lifecycle_stage: RuntimeCapabilityAdoptionStage;
+  capability_domain: string;
+  source_id: string | null;
+  status: RuntimeCapabilityAdoptionStatus;
+  reason: string;
+  evidence_refs_json: string;
+  final_authority: RuntimeCapabilityAdoptionAuthority;
+  created_at: string;
+  updated_at: string;
+  payload_json: string;
+}
+
+function runtimeCapabilityAdoptionFromRow(row: RuntimeCapabilityAdoptionRow): RuntimeCapabilityAdoptionRecord {
+  return {
+    adoptionId: row.adoption_id,
+    branchSlug: row.branch_slug,
+    lifecycleStage: row.lifecycle_stage,
+    capabilityDomain: row.capability_domain,
+    sourceId: row.source_id,
+    status: row.status,
+    reason: row.reason,
+    evidenceRefs: parseStringList(row.evidence_refs_json),
+    finalAuthority: row.final_authority,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    payload: JSON.parse(row.payload_json)
+  };
+}
+
+interface RuntimeStageArtifactRow {
+  artifact_id: string;
+  branch_slug: string;
+  stage: RegisteredStageArtifact['stage'];
+  artifact_kind: RegisteredStageArtifact['kind'];
+  producer: RegisteredStageArtifact['producer'];
+  artifact_ref: string;
+  content_hash: string;
+  contract: string;
+  target_ref: string | null;
+  target_hash: string | null;
+  review_ref: string | null;
+  review_hash: string | null;
+  verdict: RegisteredStageArtifact['verdict'] | null;
+  finding_count: number | null;
+  blocking_count: number | null;
+  recommendation: RegisteredStageArtifact['recommendation'] | null;
+  frontmatter_json: string;
+  registered_at: string;
+  payload_json: string;
+}
+
+function runtimeStageArtifactFromRow(row: RuntimeStageArtifactRow): RegisteredStageArtifact {
+  const payload = JSON.parse(row.payload_json) as RegisteredStageArtifact;
+  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) as Record<string, unknown>,
+    registeredAt: row.registered_at
+  };
+}
+
+interface RuntimeStageCollaborationContractRow {
+  contract_id: string;
+  branch_slug: string;
+  stage: RegisteredStageCollaborationContract['stage'];
+  contract_ref: string;
+  content_hash: string;
+  contract_version: string;
+  producer: RegisteredStageCollaborationContract['producer'];
+  work_order_id: string | null;
+  status: RegisteredStageCollaborationContract['status'];
+  validation_errors_json: string;
+  selected_agents_json: string;
+  selected_skills_json: string;
+  selected_materials_json: string;
+  evidence_contracts_json: string;
+  checkpoint_plan_json: string;
+  rework_plan_json: string;
+  permission_projection_json: string;
+  frontmatter_json: string;
+  registered_at: string;
+  payload_json: string;
+}
+
+function runtimeStageCollaborationContractFromRow(row: RuntimeStageCollaborationContractRow): RegisteredStageCollaborationContract {
+  const payload = JSON.parse(row.payload_json) as RegisteredStageCollaborationContract;
+  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) as string[],
+    selectedAgents: JSON.parse(row.selected_agents_json) as string[],
+    selectedSkills: JSON.parse(row.selected_skills_json) as string[],
+    selectedMaterialPacks: JSON.parse(row.selected_materials_json) as string[],
+    evidenceContracts: JSON.parse(row.evidence_contracts_json) as string[],
+    checkpointPlan: JSON.parse(row.checkpoint_plan_json) as string[],
+    reworkPlan: JSON.parse(row.rework_plan_json) as RegisteredStageCollaborationContract['reworkPlan'],
+    permissionProjection: JSON.parse(row.permission_projection_json) as RegisteredStageCollaborationContract['permissionProjection'],
+    frontmatter: JSON.parse(row.frontmatter_json) as Record<string, unknown>,
+    registeredAt: row.registered_at
+  };
+}
+
+function runtimeRefFromStoredRef(ref: string, hash?: string): { kind: 'document' | 'artifact' | 'projection' | 'external'; ref: string; hash?: string } {
+  const kind = ref.startsWith('specs/') ? 'document' : ref.startsWith('.sdd/runs/') ? 'artifact' : ref.startsWith('projection:') ? 'projection' : 'external';
+  return hash ? { kind, ref, hash } : { kind, ref };
+}
+
+interface RuntimeDurableGapRow {
+  gap_id: string;
+  partition: string;
+  task_id: string | null;
+  run_id: string | null;
+  stage: string | null;
+  gate_name: string | null;
+  source: RuntimeDurableGapSource;
+  category: string;
+  severity: RuntimeDurableGapSeverity;
+  status: RuntimeDurableGapStatus;
+  message: string;
+  recommendation: string | null;
+  evidence_refs_json: string;
+  proposal_refs_json: string;
+  source_refs_json: string;
+  created_at: string;
+  updated_at: string;
+  closed_at: string | null;
+  payload_json: string;
+}
+
+function runtimeDurableGapFromRow(row: RuntimeDurableGapRow): RuntimeDurableGapRecord {
+  return {
+    gapId: row.gap_id,
+    partition: row.partition,
+    taskId: row.task_id,
+    runId: row.run_id,
+    stage: row.stage,
+    gate: row.gate_name,
+    source: row.source,
+    category: row.category,
+    severity: row.severity,
+    status: row.status,
+    message: row.message,
+    recommendation: row.recommendation,
+    evidenceRefs: parseStringList(row.evidence_refs_json),
+    proposalRefs: parseStringList(row.proposal_refs_json),
+    sourceRefs: parseStringList(row.source_refs_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    closedAt: row.closed_at,
+    payload: JSON.parse(row.payload_json)
+  };
+}
+
+function assertDurableGapStatusAuthority(source: RuntimeDurableGapSource, status: RuntimeDurableGapStatus): void {
+  if (terminalGapStatus(status) && source !== 'runtime' && source !== 'gate_policy' && source !== 'doctor') {
+    throw new Error(`Durable gap terminal status ${status} cannot be written by ${source}.`);
+  }
+}
+
+function terminalGapStatus(status: RuntimeDurableGapStatus): boolean {
+  return status === 'resolved' || status === 'waived' || status === 'superseded';
+}
+
+function parseStringList(raw: string): string[] {
+  const parsed = JSON.parse(raw) as unknown;
+  return Array.isArray(parsed) ? parsed.filter((item): item is string => typeof item === 'string') : [];
+}
+
 interface RuntimeProjectionRow {
   projection_type: string;
   scope_key: string;
@@ -463,6 +1949,21 @@ function asRuntimeProjectionEnvelope<TPayload>(payload: unknown): RuntimeProject
   return candidate.contract === RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION ? candidate as RuntimeProjectionEnvelope<TPayload> : null;
 }
 
+function appendRuntimeScopeClauses(clauses: string[], params: string[], input: { partition?: string | null; runId?: string | null; taskId?: string | null }): void {
+  if (input.partition) {
+    clauses.push('partition = ?');
+    params.push(input.partition);
+  }
+  if (input.runId) {
+    clauses.push('run_id = ?');
+    params.push(input.runId);
+  }
+  if (input.taskId) {
+    clauses.push('task_id = ?');
+    params.push(input.taskId);
+  }
+}
+
 export function runtimeScopedId(...parts: string[]): string {
   return createHash('sha256').update(parts.join('\0'), 'utf8').digest('hex').slice(0, 32);
 }