sdd-agent-platform 0.3.0 → 0.4.1

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

@@ -0,0 +1,859 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile } from 'node:fs/promises';
+import { getRuntimeStorePath, getSddDir } from '../runtime-paths.js';
+import { exists } from './json-io.js';
+import { RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION } from '../contracts.js';
+import { assertAdvisoryAssessment, assertValidFanInEvidenceSet, assertValidStageRoleResult } from '../execution/stage-team-runtime.js';
+export const RUNTIME_STORE_SCHEMA_VERSION = 6;
+export const RUNTIME_STORE_CONTRACT_VERSION = 'phase-8.17-validation-wave-runtime-v6';
+export class RuntimeStoreError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message);
+        this.code = code;
+        this.name = 'RuntimeStoreError';
+        this.cause = options?.cause;
+    }
+}
+let runtimeStoreConstructorPromise = null;
+export async function withRuntimeStore(projectRoot, fn) {
+    const store = await openRuntimeStore(projectRoot);
+    try {
+        return await fn(store);
+    }
+    finally {
+        store.db.close();
+    }
+}
+async function loadRuntimeStoreConstructor() {
+    runtimeStoreConstructorPromise ??= importNodeSqlite()
+        .then((sqlite) => sqlite.DatabaseSync)
+        .catch((error) => {
+        throw new RuntimeStoreError('STORE_UNAVAILABLE', `node:sqlite is unavailable: ${messageFromError(error)}`, { cause: error });
+    });
+    return runtimeStoreConstructorPromise;
+}
+async function importNodeSqlite() {
+    const emitWarning = process.emitWarning;
+    const forwardWarning = emitWarning;
+    process.emitWarning = ((warning, ...args) => {
+        const message = warning instanceof Error ? warning.message : warning;
+        if (typeof message === 'string' && message.includes('SQLite is an experimental feature')) {
+            return;
+        }
+        return forwardWarning.call(process, warning, ...args);
+    });
+    try {
+        return await import('node:sqlite');
+    }
+    finally {
+        process.emitWarning = emitWarning;
+    }
+}
+async function openRuntimeStore(projectRoot) {
+    await mkdir(getSddDir(projectRoot), { recursive: true });
+    const DatabaseSync = await loadRuntimeStoreConstructor();
+    const storePath = getRuntimeStorePath(projectRoot);
+    let db;
+    try {
+        db = new DatabaseSync(storePath);
+    }
+    catch (error) {
+        throw new RuntimeStoreError('STORE_UNAVAILABLE', `Cannot open runtime store ${storePath}: ${messageFromError(error)}`, { cause: error });
+    }
+    try {
+        db.exec('PRAGMA foreign_keys = ON');
+        db.exec('PRAGMA busy_timeout = 5000');
+        db.exec('PRAGMA journal_mode = WAL');
+        initializeRuntimeStoreSchema(db);
+        return { path: storePath, db };
+    }
+    catch (error) {
+        db.close();
+        throw new RuntimeStoreError('SCHEMA_MISMATCH', `Cannot initialize runtime store ${storePath}: ${messageFromError(error)}`, { cause: error });
+    }
+}
+function initializeRuntimeStoreSchema(db) {
+    const currentVersion = readRuntimeStoreSchemaVersion(db);
+    if (currentVersion > RUNTIME_STORE_SCHEMA_VERSION) {
+        throw new RuntimeStoreError('SCHEMA_MISMATCH', `Runtime store schema ${currentVersion} is newer than supported schema ${RUNTIME_STORE_SCHEMA_VERSION}.`);
+    }
+    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);
+CREATE TABLE IF NOT EXISTS events (event_id INTEGER PRIMARY KEY AUTOINCREMENT, run_id TEXT NOT NULL, event_time TEXT NOT NULL, event_name TEXT NOT NULL, event_hash TEXT NOT NULL, event_json TEXT NOT NULL, source TEXT NOT NULL DEFAULT 'runtime', FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE, UNIQUE(run_id, event_hash));
+CREATE TABLE IF NOT EXISTS attempts (attempt_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT, status TEXT, payload_json TEXT NOT NULL, updated_at TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS activities (activity_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT, branch TEXT, kind TEXT NOT NULL, ref TEXT NOT NULL, status TEXT, 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 artifacts (artifact_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, path TEXT NOT NULL, kind TEXT NOT NULL, task_id TEXT, agent TEXT, content_hash TEXT NOT NULL, bytes INTEGER 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 CASCADE, UNIQUE(run_id, path, content_hash));
+CREATE TABLE IF NOT EXISTS artifact_ingestions (ingestion_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, delegation_id TEXT NOT NULL, task_id TEXT NOT NULL, agent TEXT NOT NULL, artifact_path TEXT NOT NULL, status TEXT NOT NULL, result_status TEXT, ingested_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 policy_decisions (decision_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT, acceptance_id TEXT, status TEXT NOT NULL, issue_codes 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 evidence_claims (claim_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, partition TEXT, task_id TEXT NOT NULL, acceptance_id TEXT NOT NULL, coverage_status TEXT NOT NULL, source_artifact TEXT NOT NULL, is_derived INTEGER 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 evidence_attachments (evidence_id TEXT PRIMARY KEY, branch_slug TEXT NOT NULL, run_id TEXT, task_id TEXT, kind TEXT NOT NULL, relative_path TEXT NOT NULL, content_hash TEXT NOT NULL, bytes INTEGER NOT NULL, created_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE, UNIQUE(branch_slug, relative_path, content_hash));
+CREATE TABLE IF NOT EXISTS gaps (gap_id TEXT PRIMARY KEY, run_id TEXT, task_id TEXT, severity TEXT NOT NULL, payload_json TEXT NOT NULL, created_at TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS recovery_actions (action_id TEXT PRIMARY KEY, run_id TEXT, task_id TEXT, status TEXT NOT NULL, payload_json TEXT NOT NULL, created_at TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS source_snapshots (snapshot_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, partition TEXT, spec_hash TEXT, plan_hash TEXT, tasks_hash TEXT, 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 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 agent_executions (execution_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT NOT NULL, profile TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS team_sessions (team_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, task_id TEXT, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS worker_runtimes (runtime_id TEXT NOT NULL, run_id TEXT NOT NULL, task_id TEXT NOT NULL, status TEXT NOT NULL, claimed_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, PRIMARY KEY(run_id, runtime_id), FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS artifact_payloads (payload_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, source_run_id TEXT NOT NULL, branch_slug TEXT NOT NULL, task_id TEXT, logical_ref TEXT NOT NULL, physical_payload_path TEXT NOT NULL, artifact_role TEXT NOT NULL, digest TEXT NOT NULL, sequence INTEGER NOT NULL, status TEXT NOT NULL, supersedes TEXT, created_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE, UNIQUE(branch_slug, physical_payload_path), UNIQUE(run_id, logical_ref, digest));
+CREATE TABLE IF NOT EXISTS sync_back_decisions (decision_id TEXT PRIMARY KEY, run_id TEXT NOT NULL, branch TEXT NOT NULL, task_id TEXT, status TEXT NOT NULL, proposal_path TEXT, proposal_digest TEXT, proposal_payload_id TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, payload_json TEXT NOT NULL, FOREIGN KEY(run_id) REFERENCES runs(run_id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS 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 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);
+CREATE INDEX IF NOT EXISTS idx_evidence_claims_run_task ON evidence_claims(run_id, task_id, acceptance_id);
+CREATE INDEX IF NOT EXISTS idx_evidence_attachments_branch_created ON evidence_attachments(branch_slug, created_at);
+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_sync_back_decisions_run_task ON sync_back_decisions(run_id, task_id, updated_at);
+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);
+`);
+    db.exec(`PRAGMA user_version = ${RUNTIME_STORE_SCHEMA_VERSION}`);
+    const now = new Date().toISOString();
+    db.prepare('INSERT OR REPLACE INTO runtime_meta (key, value, updated_at) VALUES (?, ?, ?)').run('contract', RUNTIME_STORE_CONTRACT_VERSION, now);
+    db.prepare('INSERT OR REPLACE INTO runtime_meta (key, value, updated_at) VALUES (?, ?, ?)').run('schema_version', String(RUNTIME_STORE_SCHEMA_VERSION), now);
+}
+function readRuntimeStoreSchemaVersion(db) {
+    const row = db.prepare('PRAGMA user_version').get();
+    return typeof row?.user_version === 'number' ? row.user_version : 0;
+}
+export async function recordRuntimeEvent(projectRoot, event, source = 'runtime') {
+    const eventJson = JSON.stringify(event);
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR IGNORE INTO events (run_id, event_time, event_name, event_hash, event_json, source) VALUES (?, ?, ?, ?, ?, ?)')
+            .run(event.runId, event.time, event.event, hashDocumentContent(eventJson), eventJson, source);
+    });
+}
+export async function importLegacyRunEventsIfNeeded(projectRoot, runId, eventPath) {
+    if (!await exists(eventPath)) {
+        return;
+    }
+    try {
+        const raw = await readFile(eventPath, 'utf8');
+        const contentHash = hashDocumentContent(raw);
+        await withRuntimeStore(projectRoot, ({ db }) => {
+            const legacy = db.prepare('SELECT content_hash FROM legacy_imports WHERE run_id = ? AND entity_type = ?').get(runId, 'events');
+            if (legacy?.content_hash === contentHash) {
+                return;
+            }
+            for (const line of raw.split(/\r?\n/).filter((item) => item.trim().length > 0)) {
+                const event = JSON.parse(line);
+                const eventJson = JSON.stringify(event);
+                db.prepare('INSERT OR IGNORE INTO events (run_id, event_time, event_name, event_hash, event_json, source) VALUES (?, ?, ?, ?, ?, ?)')
+                    .run(event.runId, event.time, event.event, hashDocumentContent(eventJson), eventJson, 'legacy');
+            }
+            db.prepare('INSERT OR REPLACE INTO legacy_imports (import_id, run_id, entity_type, content_hash, imported_at, status, issue) VALUES (?, ?, ?, ?, ?, ?, ?)')
+                .run(legacyImportId(runId, 'events'), runId, 'events', contentHash, new Date().toISOString(), 'imported', null);
+        });
+    }
+    catch (error) {
+        await recordLegacyImportFailure(projectRoot, runId, 'events', error);
+        throw new RuntimeStoreError('LEGACY_IMPORT_FAILED', `Cannot import legacy events for ${runId}: ${messageFromError(error)}`, { cause: error });
+    }
+}
+export async function readRuntimeRunEvents(projectRoot, runId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const rows = db.prepare('SELECT event_json FROM events WHERE run_id = ? ORDER BY event_time ASC, event_id ASC').all(runId);
+        return rows.map((row) => JSON.parse(row.event_json));
+    });
+}
+export async function upsertRuntimeRunState(projectRoot, state, serializedState) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare(`INSERT INTO runs (run_id, status, phase, current_task, partition, git_branch, task_id, created_at, updated_at, state_json, state_hash) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id) DO UPDATE SET status=excluded.status, phase=excluded.phase, current_task=excluded.current_task, partition=excluded.partition, git_branch=excluded.git_branch, task_id=excluded.task_id, updated_at=excluded.updated_at, state_json=excluded.state_json, state_hash=excluded.state_hash`)
+            .run(state.runId, state.status, state.phase, state.currentTask, state.partition, state.gitBranch, state.taskId, state.createdAt, state.updatedAt, serializedState, hashDocumentContent(serializedState));
+    });
+}
+export async function readRuntimeRunState(projectRoot, runId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const row = db.prepare('SELECT state_json FROM runs WHERE run_id = ?').get(runId);
+        return row?.state_json ? JSON.parse(row.state_json) : null;
+    });
+}
+export async function listRuntimeRunStates(projectRoot) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const rows = db.prepare('SELECT state_json FROM runs ORDER BY updated_at DESC, run_id DESC').all();
+        return rows.map((row) => JSON.parse(row.state_json));
+    });
+}
+export async function recordRuntimeAgentExecution(projectRoot, record) {
+    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, runId) {
+    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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeTeamSession(projectRoot, record) {
+    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, runId) {
+    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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeStageTeamSession(projectRoot, record) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeStageRoleResult(projectRoot, record) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeLlmAdvisorAssessment(projectRoot, record) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeFanInEvidenceSet(projectRoot, record) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeWorkflowGateDecision(projectRoot, decision) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeWorkerRuntime(projectRoot, record) {
+    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, runId, runtimeId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const row = db.prepare('SELECT payload_json FROM worker_runtimes WHERE run_id = ? AND runtime_id = ?').get(runId, runtimeId);
+        return row?.payload_json ? JSON.parse(row.payload_json) : null;
+    });
+}
+export async function listRuntimeWorkerRuntimes(projectRoot, runId) {
+    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);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeActivity(projectRoot, entry) {
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(entry.entryId, entry.runId, entry.taskId ?? null, entry.branch ?? null, entry.kind, entry.ref, entry.status ?? null, entry.timestamp, JSON.stringify(entry));
+    });
+}
+export async function readRuntimeActivities(projectRoot, runId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const rows = db.prepare('SELECT payload_json FROM activities WHERE run_id = ? ORDER BY created_at ASC, activity_id ASC').all(runId);
+        return rows.map((row) => JSON.parse(row.payload_json));
+    });
+}
+export async function recordRuntimeEvidenceAttachment(projectRoot, input) {
+    const now = new Date().toISOString();
+    const payloadJson = JSON.stringify(input.payload ?? { relativePath: input.relativePath, kind: input.kind });
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO evidence_attachments (evidence_id, branch_slug, run_id, task_id, kind, relative_path, content_hash, bytes, created_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(runtimeScopedId(input.branchSlug, input.runId ?? 'none', input.relativePath, input.contentHash), input.branchSlug, input.runId ?? null, input.taskId ?? null, input.kind, input.relativePath, input.contentHash, input.bytes, now, payloadJson);
+    });
+}
+export async function recordRuntimeArtifactPayload(projectRoot, input) {
+    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')
+            : 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 = {
+            ...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, runId, logicalRef) {
+    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);
+        return row ? runtimeArtifactPayloadFromRow(row) : null;
+    });
+}
+export async function listRuntimeArtifactPayloads(projectRoot, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map(runtimeArtifactPayloadFromRow);
+    });
+}
+export async function recordRuntimeSyncBackDecision(projectRoot, record) {
+    const payloadJson = JSON.stringify({ payload: record.payload, reasons: record.reasons });
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO sync_back_decisions (decision_id, run_id, branch, task_id, status, proposal_path, proposal_digest, proposal_payload_id, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.decisionId, record.runId, record.branch, record.taskId, record.status, record.proposalPath, record.proposalDigest, record.proposalPayloadId, record.createdAt, record.updatedAt, payloadJson);
+    });
+}
+export async function readRuntimeSyncBackDecision(projectRoot, runId, taskId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const row = taskId
+            ? db.prepare('SELECT * FROM sync_back_decisions WHERE run_id = ? AND task_id = ? ORDER BY updated_at DESC LIMIT 1').get(runId, taskId)
+            : db.prepare('SELECT * FROM sync_back_decisions WHERE run_id = ? ORDER BY updated_at DESC LIMIT 1').get(runId);
+        return row ? runtimeSyncBackDecisionFromRow(row) : null;
+    });
+}
+export async function listRuntimeSyncBackDecisions(projectRoot, runId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const rows = db.prepare('SELECT * FROM sync_back_decisions WHERE run_id = ? ORDER BY updated_at DESC, decision_id ASC').all(runId);
+        return rows.map(runtimeSyncBackDecisionFromRow);
+    });
+}
+export async function recordRuntimeDurableGap(projectRoot, input) {
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const updatedAt = input.updatedAt ?? createdAt;
+    const record = {
+        ...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, input) {
+    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);
+        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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map(runtimeDurableGapFromRow);
+    });
+}
+export async function recordRuntimeProjection(projectRoot, projectionType, scopeKey, payload) {
+    const now = new Date().toISOString();
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO projections (projection_id, projection_type, scope_key, generated_at, payload_json) VALUES (?, ?, ?, ?, ?)')
+            .run(runtimeScopedId(projectionType, scopeKey), projectionType, scopeKey, now, JSON.stringify(payload));
+    });
+}
+export function buildRuntimeProjectionEnvelope(input) {
+    return {
+        contract: RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION,
+        projectionType: input.projectionType,
+        scopeKey: input.scopeKey,
+        id: runtimeScopedId(input.projectionType, input.scopeKey, input.inputHash, input.producerVersion),
+        inputHash: input.inputHash,
+        producer: input.producer,
+        producerVersion: input.producerVersion,
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        payload: input.payload
+    };
+}
+export async function recordRuntimeProjectionEnvelope(projectRoot, input) {
+    const candidate = buildRuntimeProjectionEnvelope(input);
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const previous = readRuntimeProjectionRecordFromDb(db, input.projectionType, input.scopeKey);
+        const existingEnvelope = asRuntimeProjectionEnvelope(previous?.payload);
+        const staleness = runtimeProjectionStaleness(existingEnvelope, input);
+        if (existingEnvelope && staleness === 'fresh' && JSON.stringify(existingEnvelope.payload) === JSON.stringify(input.payload)) {
+            return { envelope: existingEnvelope, previous, staleness, status: 'unchanged' };
+        }
+        db.prepare('INSERT OR REPLACE INTO projections (projection_id, projection_type, scope_key, generated_at, payload_json) VALUES (?, ?, ?, ?, ?)')
+            .run(runtimeScopedId(input.projectionType, input.scopeKey), input.projectionType, input.scopeKey, candidate.generatedAt, JSON.stringify(candidate));
+        return { envelope: candidate, previous, staleness, status: previous ? 'updated' : 'created' };
+    });
+}
+export async function readRuntimeProjection(projectRoot, projectionType, scopeKey) {
+    return withRuntimeStore(projectRoot, ({ db }) => readRuntimeProjectionRecordFromDb(db, projectionType, scopeKey));
+}
+export async function readRuntimeProjectionEnvelope(projectRoot, projectionType, scopeKey) {
+    const record = await readRuntimeProjection(projectRoot, projectionType, scopeKey);
+    return asRuntimeProjectionEnvelope(record?.payload);
+}
+export function runtimeProjectionStaleness(envelope, freshness) {
+    if (!envelope) {
+        return 'unknown';
+    }
+    if (envelope.contract !== RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION || envelope.producerVersion !== freshness.producerVersion) {
+        return 'incompatible';
+    }
+    return envelope.inputHash === freshness.inputHash ? 'fresh' : 'stale';
+}
+export async function listRuntimeProjections(projectRoot, projectionTypes) {
+    if (projectionTypes.length === 0) {
+        return [];
+    }
+    const placeholders = projectionTypes.map(() => '?').join(', ');
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const rows = db.prepare(`SELECT projection_type, scope_key, generated_at, payload_json FROM projections WHERE projection_type IN (${placeholders}) ORDER BY generated_at DESC, projection_type ASC, scope_key ASC`)
+            .all(...projectionTypes);
+        return rows.map(runtimeProjectionRecordFromRow);
+    });
+}
+export async function recordRuntimeTestRun(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO test_runs (test_run_id, run_id, partition, task_id, status, started_at, completed_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.testRunId, record.runId, record.partition, record.taskId, record.status, record.startedAt, record.completedAt, JSON.stringify(record.payload));
+    });
+}
+export async function recordRuntimeTestStep(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO test_steps (test_step_id, test_run_id, run_id, task_id, command, status, exit_code, duration_ms, output_artifact, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(record.stepId, record.testRunId, record.runId, record.taskId, record.command, record.status, record.exitCode, record.durationMs, record.outputArtifact, JSON.stringify(record.payload));
+    });
+}
+export async function listRuntimeTestRuns(projectRoot, runId) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const rows = runId
+            ? db.prepare('SELECT test_run_id, run_id, partition, task_id, status, started_at, completed_at, payload_json FROM test_runs WHERE run_id = ? ORDER BY completed_at DESC').all(runId)
+            : db.prepare('SELECT test_run_id, run_id, partition, task_id, status, started_at, completed_at, payload_json FROM test_runs ORDER BY completed_at DESC').all();
+        return rows.map((row) => ({
+            testRunId: row.test_run_id,
+            runId: row.run_id,
+            partition: row.partition,
+            taskId: row.task_id,
+            status: row.status,
+            startedAt: row.started_at,
+            completedAt: row.completed_at,
+            payload: JSON.parse(row.payload_json)
+        }));
+    });
+}
+export async function recordRuntimeValidationEnvironmentSession(projectRoot, record) {
+    await withRuntimeStore(projectRoot, ({ db }) => {
+        db.prepare('INSERT OR REPLACE INTO validation_environment_sessions (session_id, partition, run_id, wave_run_id, status, reuse_key, created_at, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        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, record) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows
+            .map((row) => ({ waveRunId: row.wave_run_id, partition: row.partition, runId: row.run_id, taskIds: JSON.parse(row.task_ids_json), 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, record) {
+    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, input = {}) {
+    return withRuntimeStore(projectRoot, ({ db }) => {
+        const clauses = [];
+        const params = [];
+        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);
+        return rows.map((row) => ({ mapId: row.map_id, waveRunId: row.wave_run_id, testRunId: row.test_run_id, partition: row.partition, runId: row.run_id, taskId: row.task_id, acceptanceRef: row.acceptance_ref, status: row.status, evidenceRefs: JSON.parse(row.evidence_refs_json), gaps: JSON.parse(row.gaps_json), createdAt: row.created_at, payload: JSON.parse(row.payload_json) }));
+    });
+}
+export async function recordLegacyImportFailure(projectRoot, runId, entityType, error) {
+    try {
+        await withRuntimeStore(projectRoot, ({ db }) => {
+            db.prepare('INSERT OR REPLACE INTO legacy_imports (import_id, run_id, entity_type, content_hash, imported_at, status, issue) VALUES (?, ?, ?, ?, ?, ?, ?)')
+                .run(legacyImportId(runId, entityType), runId, entityType, 'unavailable', new Date().toISOString(), 'failed', messageFromError(error));
+        });
+    }
+    catch {
+        return;
+    }
+}
+export async function inspectRuntimeStoreEvidence(projectRoot) {
+    try {
+        return await withRuntimeStore(projectRoot, ({ path: storePath, db }) => {
+            const versionRow = db.prepare('PRAGMA user_version').get();
+            const integrityRow = db.prepare('PRAGMA integrity_check').get();
+            const schemaVersion = versionRow?.user_version ?? 0;
+            if (schemaVersion !== RUNTIME_STORE_SCHEMA_VERSION) {
+                return [{ level: 'FAIL', check: 'runtime_store', message: `Runtime store schema version ${schemaVersion} does not match expected ${RUNTIME_STORE_SCHEMA_VERSION}.`, action: 'Run a compatible sdd version or rebuild the runtime store from legacy .sdd/runs.' }];
+            }
+            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.' }];
+            }
+            const checks = [{ level: 'PASS', check: 'runtime_store', message: `${RUNTIME_STORE_CONTRACT_VERSION} is available at ${storePath} with schema ${schemaVersion}.` }];
+            const scopeLeak = db.prepare('SELECT COUNT(*) AS count FROM evidence_claims c JOIN runs r ON r.run_id = c.run_id WHERE c.partition IS NOT NULL AND r.partition IS NOT NULL AND c.partition <> r.partition').get();
+            checks.push(((scopeLeak?.count ?? 0) > 0)
+                ? { level: 'FAIL', check: 'runtime_partition_scope', message: `Runtime store has ${scopeLeak?.count ?? 0} cross-partition evidence claim(s).`, action: 'Reingest validator artifacts for the correct run partition; mismatched claims cannot satisfy PASS evidence.' }
+                : { level: 'PASS', check: 'runtime_partition_scope', message: 'Runtime evidence claims match their run partition scope.' });
+            const freshness = db.prepare('SELECT (SELECT MAX(updated_at) FROM runs) AS latest_run, (SELECT MAX(generated_at) FROM projections) AS latest_projection').get();
+            checks.push(freshness?.latest_run && freshness?.latest_projection && freshness.latest_projection < freshness.latest_run
+                ? { level: 'PASS', check: 'runtime_projection_freshness', message: `Latest runtime projection ${freshness.latest_projection} is older than latest run update ${freshness.latest_run}; views can be refreshed on demand.` }
+                : { level: 'PASS', check: 'runtime_projection_freshness', message: freshness?.latest_projection ? 'Runtime projections are current with known run updates.' : 'No runtime projections have been materialized yet.' });
+            const legacy = db.prepare("SELECT status, COUNT(*) AS count FROM legacy_imports GROUP BY status").all();
+            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.' }
+                : 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.' });
+            return checks;
+        });
+    }
+    catch (error) {
+        return [{ level: 'FAIL', check: 'runtime_store', message: `Runtime store unavailable: ${messageFromError(error)}`, action: 'Use a Node runtime with node:sqlite support and writable .sdd/runtime.sqlite.' }];
+    }
+}
+function nextArtifactPayloadSequence(db, branchSlug, taskId, logicalRef) {
+    const row = db.prepare('SELECT MAX(sequence) AS sequence FROM artifact_payloads WHERE branch_slug = ? AND ((task_id IS NULL AND ? IS NULL) OR task_id = ?) AND logical_ref = ?').get(branchSlug, taskId, taskId, logicalRef);
+    return (row?.sequence ?? 0) + 1;
+}
+function runtimeArtifactPayloadFromRow(row) {
+    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)
+    };
+}
+function runtimeSyncBackDecisionFromRow(row) {
+    const parsed = JSON.parse(row.payload_json);
+    return {
+        decisionId: row.decision_id,
+        runId: row.run_id,
+        branch: row.branch,
+        taskId: row.task_id,
+        status: row.status,
+        proposalPath: row.proposal_path,
+        proposalDigest: row.proposal_digest,
+        proposalPayloadId: row.proposal_payload_id,
+        reasons: Array.isArray(parsed.reasons) ? parsed.reasons.filter((reason) => typeof reason === 'string') : [],
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        payload: parsed.payload ?? null
+    };
+}
+function runtimeDurableGapFromRow(row) {
+    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, status) {
+    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) {
+    return status === 'resolved' || status === 'waived' || status === 'superseded';
+}
+function parseStringList(raw) {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
+}
+function readRuntimeProjectionRecordFromDb(db, projectionType, scopeKey) {
+    const row = db.prepare('SELECT projection_type, scope_key, generated_at, payload_json FROM projections WHERE projection_type = ? AND scope_key = ?').get(projectionType, scopeKey);
+    return row ? runtimeProjectionRecordFromRow(row) : null;
+}
+function runtimeProjectionRecordFromRow(row) {
+    return {
+        projectionType: row.projection_type,
+        scopeKey: row.scope_key,
+        generatedAt: row.generated_at,
+        payload: JSON.parse(row.payload_json)
+    };
+}
+function asRuntimeProjectionEnvelope(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const candidate = payload;
+    return candidate.contract === RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION ? candidate : null;
+}
+function appendRuntimeScopeClauses(clauses, params, input) {
+    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) {
+    return createHash('sha256').update(parts.join('\0'), 'utf8').digest('hex').slice(0, 32);
+}
+export function legacyImportId(runId, entityType) {
+    return runtimeScopedId(runId, entityType);
+}
+function hashDocumentContent(raw) {
+    return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+}
+function messageFromError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=runtime-store.js.map