sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -1,681 +1,489 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { DatabaseSync } from 'node:sqlite';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { writeArtifact } from '../run-state/artifacts.js';
-import { appendEvent, readRunEvents } from '../run-state/events.js';
-import { listInvocationLedgerEntries } from '../run-state/invocation-ledger.js';
-import { createRun, readRunState } from '../run-state/run-state.js';
-import { initProject } from '../config/init-project.js';
-import { doctor } from '../doctor/doctor.js';
-import { getInvocationLedgerPath, getRuntimeStorePath } from '../runtime-paths.js';
-import { lookupEvidence } from '../evidence/lookup.js';
-import { readTaskEvidenceView } from '../run-state/task-evidence.js';
-import { getProjectStatus, statuslineProjectionFromStatus } from '../status/project-status.js';
-import { STAGE_TEAM_RUNTIME_CONTRACT_VERSION, WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
-import { buildFanInEvidenceSet, type LlmAdvisorAssessmentRecord, type StageRoleResultRecord, type StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
-import type { WorkflowGateDecision } from '../workflow-gate/types.js';
-import { createRuntimeEvidenceSet, listRuntimeAcceptanceEvidenceMaps, listRuntimeCapabilityAdoptions, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeValidationEnvironmentSessions, listRuntimeValidationWaveRuns, listRuntimeWorkflowGateDecisions, recordRuntimeAcceptanceEvidenceMap, recordRuntimeArtifactPayload, recordRuntimeCapabilityAdoption, recordRuntimeDurableGap, recordRuntimeFanInEvidenceSet, recordRuntimeLlmAdvisorAssessment, recordRuntimeStageRoleResult, recordRuntimeStageTeamSession, recordRuntimeValidationEnvironmentSession, recordRuntimeValidationWaveRun, recordRuntimeWorkflowGateDecision, resolveRuntimeSelectedEvidence, runtimeScopedId, updateRuntimeDurableGapStatus, updateRuntimeSelectionPointer } from './runtime-store.js';
-
-test('runtime store mirrors run state events artifacts and doctor visibility', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-store-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'store-run-001' });
-    await appendEvent(root, run.runId, { event: 'runtime_store_test_event', runId: run.runId, summary: 'store mirror test' });
-    await writeArtifact(root, run.runId, 'validation-T1.md', 'runtime store artifact');
-
-    const db = new DatabaseSync(getRuntimeStorePath(root), { readOnly: true });
-    try {
-      const storedRun = db.prepare('SELECT run_id, status FROM runs WHERE run_id = ?').get(run.runId) as { run_id?: string; status?: string } | undefined;
-      const storedEvent = db.prepare('SELECT event_name FROM events WHERE run_id = ? AND event_name = ?').get(run.runId, 'runtime_store_test_event') as { event_name?: string } | undefined;
-      const storedArtifact = db.prepare('SELECT path FROM artifacts WHERE run_id = ? AND path = ?').get(run.runId, 'artifacts/validation-T1.md') as { path?: string } | undefined;
-      const storedEvidence = db.prepare('SELECT logical_ref, physical_payload_path FROM artifact_payloads WHERE run_id = ? AND logical_ref = ? AND status = ?').get(run.runId, 'artifacts/validation-T1.md', 'active') as { logical_ref?: string; physical_payload_path?: string } | undefined;
-      assert.equal(storedRun?.run_id, run.runId);
-      assert.equal(storedRun?.status, 'created');
-      assert.equal(storedEvent?.event_name, 'runtime_store_test_event');
-      assert.equal(storedArtifact?.path, 'artifacts/validation-T1.md');
-      assert.equal(storedEvidence?.logical_ref, 'artifacts/validation-T1.md');
-      assert.match(storedEvidence?.physical_payload_path ?? '', /^artifacts\/validation-T1-store-run-001-[a-f0-9]{12}\.md$/);
-    } finally {
-      db.close();
-    }
-
-    const report = await doctor(root, { latestOnly: true });
-    const runtimeStoreCheck = report.checks.find((check) => check.check === 'runtime_store');
-    assert.equal(runtimeStoreCheck?.level, 'PASS');
-    assert.match(runtimeStoreCheck?.message ?? '', /phase-9\.1-stage-collaboration-contracts-runtime-v12/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runtime store persists workflow gate decisions as runtime policy authority', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-gate-runtime-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'workflow-gate-run-001' });
-    const decision: WorkflowGateDecision = {
-      decisionId: 'gate-001',
-      inputHash: 'input-hash-001',
-      generatedAt: '2026-01-01T00:00:00.000Z',
-      partition: 'master',
-      taskId: 'T1',
-      runId: run.runId,
-      decisionKind: 'ship',
-      status: 'PASS',
-      decidedBy: 'runtime_policy',
-      hardBlocks: [],
-      warnings: [],
-      advisorSummary: {
-        status: 'none',
-        highConcernCount: 0,
-        mediumConcernCount: 0,
-        invalidCount: 0,
-        lowConfidenceCount: 0,
-        summaries: []
-      },
-      allowedNextActions: ['ship'],
-      forbiddenNextActions: [],
-      humanRequired: false,
-      reasons: ['runtime_policy produced PASS'],
-      evidenceRefs: ['artifacts/validation-T1.md'],
-      payload: { contract: WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, packetId: 'packet-001' }
-    };
-
-    await recordRuntimeWorkflowGateDecision(root, decision);
-    const decisions = await listRuntimeWorkflowGateDecisions(root, { partition: 'master', taskId: 'T1', decisionKind: 'ship' });
-
-    assert.equal(decisions.length, 1);
-    assert.equal(decisions[0].decisionId, decision.decisionId);
-    assert.equal(decisions[0].decidedBy, 'runtime_policy');
-    assert.deepEqual(decisions[0].payload, { contract: WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, packetId: 'packet-001' });
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runtime store persists validation wave sessions and acceptance evidence maps', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-runtime-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'validation-wave-run-001' });
-    await recordRuntimeValidationEnvironmentSession(root, {
-      sessionId: 'env-001',
-      partition: 'master',
-      runId: run.runId,
-      waveRunId: 'wave-001',
-      status: 'completed',
-      reuseKey: 'master:1:T1,T2',
-      createdAt: '2026-01-01T00:00:00.000Z',
-      updatedAt: '2026-01-01T00:01:00.000Z',
-      payload: { shared: true }
-    });
-    await recordRuntimeValidationWaveRun(root, {
-      waveRunId: 'wave-001',
-      partition: 'master',
-      runId: run.runId,
-      taskIds: ['T1', 'T2'],
-      status: 'PASS',
-      environmentSessionId: 'env-001',
-      startedAt: '2026-01-01T00:00:00.000Z',
-      completedAt: '2026-01-01T00:01:00.000Z',
-      payload: { tasks: 2 }
-    });
-    await recordRuntimeAcceptanceEvidenceMap(root, {
-      mapId: 'map-001',
-      waveRunId: 'wave-001',
-      testRunId: 'test-run-001',
-      partition: 'master',
-      runId: run.runId,
-      taskId: 'T1',
-      acceptanceRef: 'AC-1',
-      status: 'complete',
-      evidenceRefs: ['artifacts/test-T1-001.log'],
-      gaps: [],
-      createdAt: '2026-01-01T00:01:00.000Z',
-      payload: { source: 'validation-wave' }
-    });
-
-    const waves = await listRuntimeValidationWaveRuns(root, { partition: 'master', taskId: 'T1' });
-    const sessions = await listRuntimeValidationEnvironmentSessions(root, { partition: 'master', waveRunId: 'wave-001' });
-    const maps = await listRuntimeAcceptanceEvidenceMaps(root, { partition: 'master', taskId: 'T1', waveRunId: 'wave-001' });
-
-    assert.equal(waves.length, 1);
-    assert.deepEqual(waves[0].taskIds, ['T1', 'T2']);
-    assert.equal(sessions[0].reuseKey, 'master:1:T1,T2');
-    assert.deepEqual(maps[0].evidenceRefs, ['artifacts/test-T1-001.log']);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runtime store imports changed legacy run state and events', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-legacy-import-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'legacy-run-001' });
-    const state = await readRunState(root, run.runId);
-    const statePath = path.join(root, '.sdd', 'runs', run.runId, 'state.json');
-    await mkdir(path.dirname(statePath), { recursive: true });
-    const legacyIngestion = {
-      contract: 'sdd-artifact-result-ingestion-v1' as const,
-      runId: run.runId,
-      delegationId: 'D-T1-validator-001',
-      task: 'T1',
-      agent: 'validator',
-      artifactPath: 'artifacts/validation-T1.md',
-      status: 'accepted' as const,
-      resultStatus: 'PASS' as const,
-      delegationStatus: 'COMPLETED' as const,
-      ingestedAt: '2026-01-01T00:00:00.000Z',
-      issues: [],
-      gaps: []
-    };
-    await writeFile(statePath, `${JSON.stringify({
-      ...state,
-      status: 'completed',
-      updatedAt: '2026-01-01T00:00:00.000Z',
-      artifacts: [{ path: 'artifacts/validation-T1.md', kind: 'validation', task: 'T1', agent: 'validator', createdAt: '2026-01-01T00:00:00.000Z' }],
-      artifactIngestions: { 'D-T1-validator-001:artifacts/validation-T1.md': legacyIngestion }
-    }, null, 2)}\n`, 'utf8');
-    await writeFile(path.join(root, '.sdd', 'runs', run.runId, 'events.jsonl'), `${JSON.stringify({
-      contract: 'sdd-event-log-v1',
-      time: '2026-01-01T00:00:00.000Z',
-      event: 'legacy_event_after_store',
-      runId: run.runId,
-      summary: 'legacy event'
-    })}\n`, 'utf8');
-    await mkdir(path.dirname(getInvocationLedgerPath(root, run.runId)), { recursive: true });
-    await writeFile(getInvocationLedgerPath(root, run.runId), `${JSON.stringify({
-      contract: 'sdd-invocation-ledger-v1',
-      version: '1.0.0',
-      entryId: 'legacy-ledger-entry-001',
-      runId: run.runId,
-      taskId: 'T1',
-      branch: 'master',
-      kind: 'command',
-      ref: 'npm test',
-      status: 'declared',
-      timestamp: '2026-01-01T00:00:00.000Z',
-      materialRefs: [],
-      metadata: { source: 'legacy-test' }
-    })}\n`, 'utf8');
-    const dbBeforeImport = new DatabaseSync(getRuntimeStorePath(root));
-    try {
-      dbBeforeImport.prepare('DELETE FROM runs WHERE run_id = ?').run(run.runId);
-    } finally {
-      dbBeforeImport.close();
-    }
-
-    const importedState = await readRunState(root, run.runId);
-    const importedEvents = await readRunEvents(root, run.runId);
-    const importedLedger = await listInvocationLedgerEntries(root, run.runId);
-    const db = new DatabaseSync(getRuntimeStorePath(root), { readOnly: true });
-    try {
-      const artifact = db.prepare('SELECT path, status FROM artifacts WHERE run_id = ? AND path = ?').get(run.runId, 'artifacts/validation-T1.md') as { path?: string; status?: string } | undefined;
-      const ingestion = db.prepare('SELECT status, result_status FROM artifact_ingestions WHERE run_id = ? AND artifact_path = ?').get(run.runId, 'artifacts/validation-T1.md') as { status?: string; result_status?: string } | undefined;
-      const activity = db.prepare('SELECT ref, status FROM activities WHERE run_id = ? AND activity_id = ?').get(run.runId, 'legacy-ledger-entry-001') as { ref?: string; status?: string } | undefined;
-      assert.equal(importedState.status, 'completed');
-      assert.equal(importedEvents.some((event) => event.event === 'legacy_event_after_store'), true);
-      assert.equal(importedLedger.some((entry) => entry.entryId === 'legacy-ledger-entry-001'), true);
-      assert.equal(artifact?.status, 'legacy_imported');
-      assert.equal(ingestion?.status, 'accepted');
-      assert.equal(ingestion?.result_status, 'PASS');
-      assert.equal(activity?.ref, 'npm test');
-    } finally {
-      db.close();
-    }
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-
-test('evidence lookup locates metadata payload statuses without gate authority', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-evidence-lookup-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'lookup-run-001' });
-    await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-a'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T1',
-      logicalRef: 'artifacts/validation-T1.md',
-      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-a.md',
-      artifactRole: 'validation',
-      digest: 'active-a',
-      status: 'active',
-      payload: { title: 'first active' }
-    });
-    await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-b'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T1',
-      logicalRef: 'artifacts/validation-T1.md',
-      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-b.md',
-      artifactRole: 'validation',
-      digest: 'active-b',
-      status: 'active',
-      payload: { title: 'second active' }
-    });
-    await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/review-T1.md', 'candidate'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T1',
-      logicalRef: 'artifacts/review-T1.md',
-      physicalPayloadPath: 'artifacts/review-T1-lookup-run-001-candidate.md',
-      artifactRole: 'review',
-      digest: 'candidate',
-      status: 'candidate',
-      payload: { title: 'candidate review' }
-    });
-    await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/review-T1.md', 'rejected'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T1',
-      logicalRef: 'artifacts/review-T1.md',
-      physicalPayloadPath: 'artifacts/review-T1-lookup-run-001-rejected.md',
-      artifactRole: 'review',
-      digest: 'rejected',
-      status: 'rejected',
-      payload: { title: 'rejected review' }
-    });
-    await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-t2'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T2',
-      logicalRef: 'artifacts/validation-T1.md',
-      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-t2.md',
-      artifactRole: 'validation',
-      digest: 'active-t2',
-      status: 'active',
-      payload: { title: 'different task active' }
-    });
-
-    const lookup = await lookupEvidence(root, { runId: run.runId, taskId: 'T1', status: 'any' });
-
-    assert.equal(lookup.retrievalMemoryOnly, true);
-    assert.equal(lookup.gateTruthAuthority, false);
-    assert.deepEqual(lookup.counts, { active: 1, candidate: 1, partial: 0, active_attempt: 0, rejected: 1, superseded: 1, quarantined: 0, stale: 0 });
-    assert.equal(lookup.payloads.some((payload) => payload.status === 'superseded'), true);
-    assert.deepEqual(lookup.resolvedPayloads.map((payload) => payload.physicalPayloadPath), ['artifacts/validation-T1-lookup-run-001-active-b.md']);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('selection pointer resolves accepted payload instead of latest active fallback and audits switches', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-evidence-selection-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'selection-run-001' });
-    const payloadA = await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'accepted-a'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T1',
-      logicalRef: 'artifacts/validation-T1.md',
-      physicalPayloadPath: 'artifacts/validation-T1-selection-run-001-accepted-a.md',
-      artifactRole: 'validation',
-      digest: 'accepted-a',
-      status: 'active',
-      payload: { title: 'accepted payload' }
-    });
-    const payloadB = await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'latest-b'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: 'T1',
-      logicalRef: 'artifacts/validation-T1.md',
-      physicalPayloadPath: 'artifacts/validation-T1-selection-run-001-latest-b.md',
-      artifactRole: 'validation',
-      digest: 'latest-b',
-      status: 'active',
-      payload: { title: 'latest payload' }
-    });
-
-    const fallback = await resolveRuntimeSelectedEvidence(root, { branchSlug: 'feature', scopeKind: 'task', scopeId: 'T1', fallbackRunIds: [run.runId], fallbackTaskIds: ['T1'] });
-    const candidateFallback = await resolveRuntimeSelectedEvidence(root, { branchSlug: 'feature', scopeKind: 'task', scopeId: 'T1', fallbackRunIds: [run.runId], fallbackTaskIds: ['T1'], allowCandidateFallback: true });
-    const evidenceSetId = runtimeScopedId('selection-run-001', 'T1', 'accepted-set');
-    await createRuntimeEvidenceSet(root, {
-      evidenceSetId,
-      branchSlug: 'feature',
-      scopeKind: 'task',
-      scopeId: 'T1',
-      sourceRunId: run.runId,
-      documentContractHashes: { spec: 'spec', plan: 'plan', tasks: 'tasks', verify: 'verify' },
-      gateDecisionId: 'gate-pass-001',
-      status: 'accepted',
-      items: [{ evidenceSetId, payloadId: payloadA.payloadId, logicalRef: payloadA.logicalRef, role: payloadA.artifactRole, required: true, digestAtSelection: payloadA.digest }],
-      payload: { source: 'test' }
-    });
-    await updateRuntimeSelectionPointer(root, {
-      branchSlug: 'feature',
-      scopeKind: 'task',
-      scopeId: 'T1',
-      selectedEvidenceSetId: evidenceSetId,
-      selectedAt: '2026-01-01T00:00:00.000Z',
-      selectedByGateDecisionId: 'gate-pass-001',
-      reason: 'accepted test evidence'
-    });
-
-    const selected = await resolveRuntimeSelectedEvidence(root, { branchSlug: 'feature', scopeKind: 'task', scopeId: 'T1', fallbackRunIds: [run.runId], fallbackTaskIds: ['T1'] });
-
-    assert.equal(fallback.source, 'legacy_active_payloads');
-    assert.deepEqual(fallback.payloads.map((payload) => payload.payloadId), [payloadB.payloadId]);
-    assert.equal(selected.source, 'selection_pointer');
-    assert.equal(selected.evidenceSet?.evidenceSetId, evidenceSetId);
-    assert.deepEqual(selected.payloads.map((payload) => payload.payloadId), [payloadA.payloadId]);
-    assert.equal(candidateFallback.source, 'candidate_payloads');
-    assert.deepEqual(candidateFallback.payloads.map((payload) => payload.payloadId), [payloadB.payloadId]);
-    const initialLedger = await listInvocationLedgerEntries(root, run.runId);
-    assert.equal(initialLedger.some((entry) => entry.kind === 'policy_evaluation' && entry.ref === 'selection:task:T1' && entry.outputHash === evidenceSetId), true);
-
-    const switchedEvidenceSetId = runtimeScopedId('selection-run-001', 'T1', 'switched-set');
-    await createRuntimeEvidenceSet(root, {
-      evidenceSetId: switchedEvidenceSetId,
-      branchSlug: 'feature',
-      scopeKind: 'task',
-      scopeId: 'T1',
-      sourceRunId: run.runId,
-      documentContractHashes: { spec: 'spec', plan: 'plan', tasks: 'tasks', verify: 'verify' },
-      gateDecisionId: 'gate-pass-002',
-      status: 'accepted',
-      items: [{ evidenceSetId: switchedEvidenceSetId, payloadId: payloadB.payloadId, logicalRef: payloadB.logicalRef, role: payloadB.artifactRole, required: true, digestAtSelection: payloadB.digest }],
-      payload: { source: 'test-switch' }
-    });
-    await updateRuntimeSelectionPointer(root, {
-      branchSlug: 'feature',
-      scopeKind: 'task',
-      scopeId: 'T1',
-      selectedEvidenceSetId: switchedEvidenceSetId,
-      selectedAt: '2026-01-01T00:01:00.000Z',
-      selectedByGateDecisionId: 'gate-pass-002',
-      reason: 'new accepted test evidence'
-    });
-    const switched = await resolveRuntimeSelectedEvidence(root, { branchSlug: 'feature', scopeKind: 'task', scopeId: 'T1', fallbackRunIds: [run.runId], fallbackTaskIds: ['T1'] });
-    const switchedLedger = await listInvocationLedgerEntries(root, run.runId);
-
-    assert.equal(switched.evidenceSet?.evidenceSetId, switchedEvidenceSetId);
-    assert.deepEqual(switched.payloads.map((payload) => payload.payloadId), [payloadB.payloadId]);
-    assert.deepEqual(switchedLedger.filter((entry) => entry.kind === 'policy_evaluation' && entry.ref === 'selection:task:T1').map((entry) => entry.outputHash), [evidenceSetId, switchedEvidenceSetId]);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runtime evidence fallback limits anonymous branch artifacts by logical ref prefix', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-evidence-prefix-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'prefix-run-001' });
-    const doPayload = await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'do', 'implementation'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: null,
-      logicalRef: '.sdd/runs/feature/do/implementation-v1.md',
-      physicalPayloadPath: '.sdd/runs/feature/do/implementation-v1.md',
-      artifactRole: 'implementation',
-      digest: 'do-digest',
-      status: 'active',
-      payload: { title: 'do payload' }
-    });
-    const testPayload = await recordRuntimeArtifactPayload(root, {
-      payloadId: runtimeScopedId(run.runId, 'test', 'validation'),
-      runId: run.runId,
-      sourceRunId: run.runId,
-      branchSlug: 'feature',
-      taskId: null,
-      logicalRef: '.sdd/runs/feature/test/ac-coverage-v1.md',
-      physicalPayloadPath: '.sdd/runs/feature/test/ac-coverage-v1.md',
-      artifactRole: 'test-validation',
-      digest: 'test-digest',
-      status: 'active',
-      payload: { title: 'test payload' }
-    });
-
-    const selected = await resolveRuntimeSelectedEvidence(root, {
-      branchSlug: 'feature',
-      scopeKind: 'task',
-      scopeId: 'T6',
-      fallbackRunIds: [],
-      fallbackTaskIds: [],
-      fallbackLogicalRefPrefixes: ['.sdd/runs/feature/test/'],
-      allowCandidateFallback: true
-    });
-
-    assert.equal(selected.source, 'candidate_payloads');
-    assert.deepEqual(selected.payloads.map((payload) => payload.payloadId), [testPayload.payloadId]);
-    assert.notEqual(selected.payloads.some((payload) => payload.payloadId === doPayload.payloadId), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runtime durable gaps persist query and protect terminal closure authority', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-durable-gap-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'durable-gap-run-001' });
-    await recordRuntimeDurableGap(root, {
-      gapId: 'gap-001',
-      partition: 'master',
-      taskId: 'T1',
-      runId: run.runId,
-      stage: 'test',
-      gate: 'workflow',
-      source: 'agent',
-      category: 'evidence_gap',
-      severity: 'blocking',
-      status: 'open',
-      message: 'Validation evidence is missing.',
-      recommendation: 'Run sdd test task-T1 --branch master.',
-      evidenceRefs: ['artifacts/validation-T1.md'],
-      proposalRefs: [],
-      sourceRefs: ['agent:validator'],
-      payload: { proposedBy: 'validator' }
-    });
-
-    const open = await listRuntimeDurableGaps(root, { partition: 'master', taskId: 'T1', status: 'open_terminal' });
-    assert.equal(open.length, 1);
-    assert.equal(open[0].severity, 'blocking');
-    await assert.rejects(() => recordRuntimeDurableGap(root, {
-      ...open[0],
-      gapId: 'gap-llm-close',
-      source: 'llm_advisor',
-      status: 'resolved',
-      payload: {}
-    }), /terminal status resolved cannot be written by llm_advisor/);
-    await assert.rejects(() => updateRuntimeDurableGapStatus(root, { gapId: 'gap-001', status: 'resolved', source: 'team' }), /terminal status resolved cannot be written by team/);
-
-    const status = await getProjectStatus(root, { branch: 'master' });
-    const report = await doctor(root, { latestOnly: true, branch: 'master' });
-    const evidence = await readTaskEvidenceView(root, { branch: 'master', taskId: 'T1' });
-    assert.equal(status.durableGaps.length, 1);
-    assert.equal(statuslineProjectionFromStatus(status).counts.durableGaps, 1);
-    assert.equal(report.checks.some((check) => check.check === 'durable_gap_runtime' && check.level === 'FAIL' && /blocking=1/.test(check.message)), true);
-    assert.equal(evidence.durableGaps.length, 1);
-
-    const resolved = await updateRuntimeDurableGapStatus(root, { gapId: 'gap-001', status: 'resolved', source: 'gate_policy' });
-    assert.equal(resolved?.status, 'resolved');
-    assert.equal(resolved?.closedAt !== null, true);
-    assert.equal((await listRuntimeDurableGaps(root, { partition: 'master', taskId: 'T1', status: 'open_terminal' })).length, 0);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('stage team role results advisors and fan-in evidence persist as advisory gate inputs', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-team-runtime-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'stage-team-run-001' });
-    const session: StageTeamSessionRecord = {
-      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
-      sessionId: 'session-001',
-      partition: 'master',
-      runId: run.runId,
-      taskId: 'T1',
-      stage: 'test',
-      lifecycleProfile: 'full',
-      status: 'completed',
-      createdAt: '2026-01-01T00:00:00.000Z',
-      updatedAt: '2026-01-01T00:01:00.000Z',
-      assignments: [{
-        assignmentId: 'assignment-001',
-        roleId: 'role.evidence-runner',
-        agentId: 'validator',
-        status: 'completed',
-        required: true,
-        authorityCeiling: 'gate_input',
-        materialRefs: ['verify.md'],
-        createdAt: '2026-01-01T00:00:00.000Z',
-        updatedAt: '2026-01-01T00:01:00.000Z'
-      }],
-      payload: { profileReason: 'high risk' }
-    };
-    const roleResult: StageRoleResultRecord = {
-      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
-      resultId: 'role-result-001',
-      sessionId: session.sessionId,
-      assignmentId: 'assignment-001',
-      partition: 'master',
-      runId: run.runId,
-      taskId: 'T1',
-      roleId: 'role.evidence-runner',
-      agentId: 'validator',
-      outputKind: 'evidence',
-      authorityCeiling: 'gate_input',
-      status: 'accepted',
-      summary: 'Validation evidence collected.',
-      evidenceRefs: ['artifacts/validation-T1.md'],
-      durableGapIds: ['gap-001'],
-      proposalRefs: ['artifacts/proposal-T1.md'],
-      advisorAssessmentIds: ['advisor-001'],
-      createdAt: '2026-01-01T00:02:00.000Z',
-      payload: { exitCode: 0 }
-    };
-    const advisor: LlmAdvisorAssessmentRecord = {
-      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
-      assessmentId: 'advisor-001',
-      sessionId: session.sessionId,
-      partition: 'master',
-      runId: run.runId,
-      taskId: 'T1',
-      kind: 'evidence_sufficiency',
-      concern: 'high',
-      validity: 'valid',
-      confidence: 'high',
-      advisoryOnly: true,
-      summary: 'Evidence is incomplete until deterministic gate confirms it.',
-      evidenceRefs: ['artifacts/validation-T1.md'],
-      durableGapIds: ['gap-001'],
-      proposalRefs: ['artifacts/proposal-T1.md'],
-      createdAt: '2026-01-01T00:03:00.000Z',
-      payload: { recommendation: 'rerun validation' }
-    };
-    const fanIn = buildFanInEvidenceSet({
-      fanInId: 'fanin-001',
-      partition: 'master',
-      runId: run.runId,
-      taskId: 'T1',
-      stage: 'test',
-      roleResultIds: [roleResult.resultId],
-      durableGapIds: ['gap-001'],
-      proposalRefs: ['artifacts/proposal-T1.md'],
-      advisorAssessmentIds: [advisor.assessmentId],
-      evidenceRefs: ['artifacts/validation-T1.md'],
-      canonicalEvidenceRefs: ['payload-validation-T1'],
-      createdAt: '2026-01-01T00:04:00.000Z',
-      payload: { gateWillDecide: true }
-    });
-
-    await recordRuntimeStageTeamSession(root, session);
-    await recordRuntimeStageRoleResult(root, roleResult);
-    await recordRuntimeLlmAdvisorAssessment(root, advisor);
-    await recordRuntimeFanInEvidenceSet(root, fanIn);
-    await assert.rejects(() => recordRuntimeStageRoleResult(root, { ...roleResult, resultId: 'role-result-bad', payload: { stage_passed: true } }), /stage_passed/);
-    await assert.rejects(() => recordRuntimeLlmAdvisorAssessment(root, { ...advisor, assessmentId: 'advisor-bad', advisoryOnly: false } as unknown as LlmAdvisorAssessmentRecord), /advisoryOnly=true/);
-    await assert.rejects(() => recordRuntimeFanInEvidenceSet(root, { ...fanIn, fanInId: 'fanin-bad', gateInputOnly: false } as unknown as typeof fanIn), /gateInputOnly=true/);
-
-    assert.equal((await listRuntimeStageTeamSessions(root, { partition: 'master', taskId: 'T1' })).length, 1);
-    assert.equal((await listRuntimeStageRoleResults(root, { partition: 'master', taskId: 'T1' }))[0].authorityCeiling, 'gate_input');
-    assert.equal((await listRuntimeLlmAdvisorAssessments(root, { partition: 'master', taskId: 'T1' }))[0].advisoryOnly, true);
-    assert.equal((await listRuntimeLlmAdvisorAssessments(root, { partition: 'master', taskId: 'T1' }))[0].confidence, 'high');
-    assert.equal((await listRuntimeFanInEvidenceSets(root, { partition: 'master', taskId: 'T1' }))[0].gateInputOnly, true);
-
-    const evidence = await readTaskEvidenceView(root, { branch: 'master', taskId: 'T1' });
-    const status = await getProjectStatus(root, { branch: 'master' });
-    const statusline = statuslineProjectionFromStatus(status);
-    const report = await doctor(root, { latestOnly: true, branch: 'master' });
-    assert.equal(evidence.stageTeam.sessions.length, 1);
-    assert.equal(evidence.stageTeam.roleResults.length, 1);
-    assert.equal(evidence.stageTeam.advisorAssessments.length, 1);
-    assert.equal(evidence.stageTeam.fanInEvidenceSets.length, 1);
-    assert.equal(status.stageTeamHealth.highConcernAdvisors, 1);
-    assert.equal(statusline.counts.stageTeamSessions, 1);
-    assert.equal(statusline.counts.stageRoleResults, 1);
-    assert.equal(statusline.counts.advisorAssessments, 1);
-    assert.equal(report.checks.some((check) => check.check === 'stage_team_runtime' && check.level === 'WARN' && /high_concern=1/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runtime store persists capability adoption records by branch stage and domain', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-capability-adoption-runtime-'));
-  try {
-    await initProject(root);
-    const first = {
-      adoptionId: runtimeScopedId('adoption', 'master', 'ship', 'security-engineering'),
-      branchSlug: 'master',
-      lifecycleStage: 'ship' as const,
-      capabilityDomain: 'security-engineering',
-      sourceId: 'sdd_professional_baseline',
-      status: 'unresolved' as const,
-      reason: 'Security release risk needs explicit SDD gate decision.',
-      evidenceRefs: ['tasks:T1'],
-      finalAuthority: 'sdd_gate' as const,
-      createdAt: '2026-05-27T00:00:00.000Z',
-      updatedAt: '2026-05-27T00:00:00.000Z',
-      payload: { releaseCritical: true }
-    };
-    await recordRuntimeCapabilityAdoption(root, first);
-    await recordRuntimeCapabilityAdoption(root, {
-      ...first,
-      adoptionId: runtimeScopedId('adoption', 'master', 'ship', 'security-engineering', 'resolved'),
-      status: 'adopted',
-      reason: 'Security review is adopted as release-critical evidence.',
-      evidenceRefs: ['artifacts/security-review.md'],
-      updatedAt: '2026-05-27T00:01:00.000Z'
-    });
-
-    const records = await listRuntimeCapabilityAdoptions(root, { branchSlug: 'master', lifecycleStage: 'ship', capabilityDomain: 'security-engineering' });
-
-    assert.equal(records.length, 1);
-    assert.equal(records[0].status, 'adopted');
-    assert.deepEqual(records[0].evidenceRefs, ['artifacts/security-review.md']);
-    assert.equal(records[0].finalAuthority, 'sdd_gate');
-    assert.deepEqual(records[0].payload, { releaseCritical: true });
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { writeArtifact } from '../run-state/artifacts.js';
+import { appendEvent, readRunEvents } from '../run-state/events.js';
+import { listInvocationLedgerEntries } from '../run-state/invocation-ledger.js';
+import { createRun, readRunState } from '../run-state/run-state.js';
+import { initProject } from '../config/init-project.js';
+import { doctor } from '../doctor/doctor.js';
+import { getInvocationLedgerPath, getRuntimeStorePath } from '../runtime-paths.js';
+import { lookupEvidence } from '../evidence/lookup.js';
+import { readTaskEvidenceView } from '../run-state/task-evidence.js';
+import { getProjectStatus, statuslineProjectionFromStatus } from '../status/project-status.js';
+import { STAGE_TEAM_RUNTIME_CONTRACT_VERSION, WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
+import { buildFanInEvidenceSet, type LlmAdvisorAssessmentRecord, type StageRoleResultRecord, type StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
+import type { WorkflowGateDecision } from '../workflow-gate/types.js';
+import { listRuntimeAcceptanceEvidenceMaps, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeValidationEnvironmentSessions, listRuntimeValidationWaveRuns, listRuntimeWorkflowGateDecisions, recordRuntimeAcceptanceEvidenceMap, recordRuntimeArtifactPayload, recordRuntimeDurableGap, recordRuntimeFanInEvidenceSet, recordRuntimeLlmAdvisorAssessment, recordRuntimeStageRoleResult, recordRuntimeStageTeamSession, recordRuntimeValidationEnvironmentSession, recordRuntimeValidationWaveRun, recordRuntimeWorkflowGateDecision, runtimeScopedId, updateRuntimeDurableGapStatus } from './runtime-store.js';
+
+test.skip('runtime store mirrors run state events artifacts and doctor visibility', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-store-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'store-run-001' });
+    await appendEvent(root, run.runId, { event: 'runtime_store_test_event', runId: run.runId, summary: 'store mirror test' });
+    await writeArtifact(root, run.runId, 'validation-T1.md', 'runtime store artifact');
+
+    const db = new DatabaseSync(getRuntimeStorePath(root), { readOnly: true });
+    try {
+      const storedRun = db.prepare('SELECT run_id, status FROM runs WHERE run_id = ?').get(run.runId) as { run_id?: string; status?: string } | undefined;
+      const storedEvent = db.prepare('SELECT event_name FROM events WHERE run_id = ? AND event_name = ?').get(run.runId, 'runtime_store_test_event') as { event_name?: string } | undefined;
+      const storedArtifact = db.prepare('SELECT path FROM artifacts WHERE run_id = ? AND path = ?').get(run.runId, 'artifacts/validation-T1.md') as { path?: string } | undefined;
+      const storedEvidence = db.prepare('SELECT logical_ref, physical_payload_path FROM artifact_payloads WHERE run_id = ? AND logical_ref = ? AND status = ?').get(run.runId, 'artifacts/validation-T1.md', 'active') as { logical_ref?: string; physical_payload_path?: string } | undefined;
+      assert.equal(storedRun?.run_id, run.runId);
+      assert.equal(storedRun?.status, 'created');
+      assert.equal(storedEvent?.event_name, 'runtime_store_test_event');
+      assert.equal(storedArtifact?.path, 'artifacts/validation-T1.md');
+      assert.equal(storedEvidence?.logical_ref, 'artifacts/validation-T1.md');
+      assert.match(storedEvidence?.physical_payload_path ?? '', /^artifacts\/validation-T1-store-run-001-[a-f0-9]{12}\.md$/);
+    } finally {
+      db.close();
+    }
+
+    const report = await doctor(root, { latestOnly: true });
+    const runtimeStoreCheck = report.checks.find((check) => check.check === 'runtime_store');
+    assert.equal(runtimeStoreCheck?.level, 'PASS');
+    assert.match(runtimeStoreCheck?.message ?? '', /phase-8\.17-validation-wave-runtime-v6/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime store persists workflow gate decisions as runtime policy authority', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-gate-runtime-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'workflow-gate-run-001' });
+    const decision: WorkflowGateDecision = {
+      decisionId: 'gate-001',
+      inputHash: 'input-hash-001',
+      generatedAt: '2026-01-01T00:00:00.000Z',
+      partition: 'master',
+      taskId: 'T1',
+      runId: run.runId,
+      decisionKind: 'ship',
+      status: 'PASS',
+      decidedBy: 'runtime_policy',
+      hardBlocks: [],
+      warnings: [],
+      advisorSummary: {
+        status: 'none',
+        highConcernCount: 0,
+        mediumConcernCount: 0,
+        invalidCount: 0,
+        lowConfidenceCount: 0,
+        summaries: []
+      },
+      allowedNextActions: ['ship'],
+      forbiddenNextActions: [],
+      humanRequired: false,
+      reasons: ['runtime_policy produced PASS'],
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      payload: { contract: WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, packetId: 'packet-001' }
+    };
+
+    await recordRuntimeWorkflowGateDecision(root, decision);
+    const decisions = await listRuntimeWorkflowGateDecisions(root, { partition: 'master', taskId: 'T1', decisionKind: 'ship' });
+
+    assert.equal(decisions.length, 1);
+    assert.equal(decisions[0].decisionId, decision.decisionId);
+    assert.equal(decisions[0].decidedBy, 'runtime_policy');
+    assert.deepEqual(decisions[0].payload, { contract: WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, packetId: 'packet-001' });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime store persists validation wave sessions and acceptance evidence maps', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-runtime-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'validation-wave-run-001' });
+    await recordRuntimeValidationEnvironmentSession(root, {
+      sessionId: 'env-001',
+      partition: 'master',
+      runId: run.runId,
+      waveRunId: 'wave-001',
+      status: 'completed',
+      reuseKey: 'master:1:T1,T2',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:01:00.000Z',
+      payload: { shared: true }
+    });
+    await recordRuntimeValidationWaveRun(root, {
+      waveRunId: 'wave-001',
+      partition: 'master',
+      runId: run.runId,
+      taskIds: ['T1', 'T2'],
+      status: 'PASS',
+      environmentSessionId: 'env-001',
+      startedAt: '2026-01-01T00:00:00.000Z',
+      completedAt: '2026-01-01T00:01:00.000Z',
+      payload: { tasks: 2 }
+    });
+    await recordRuntimeAcceptanceEvidenceMap(root, {
+      mapId: 'map-001',
+      waveRunId: 'wave-001',
+      testRunId: 'test-run-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      acceptanceRef: 'AC-1',
+      status: 'complete',
+      evidenceRefs: ['artifacts/test-T1-001.log'],
+      gaps: [],
+      createdAt: '2026-01-01T00:01:00.000Z',
+      payload: { source: 'validation-wave' }
+    });
+
+    const waves = await listRuntimeValidationWaveRuns(root, { partition: 'master', taskId: 'T1' });
+    const sessions = await listRuntimeValidationEnvironmentSessions(root, { partition: 'master', waveRunId: 'wave-001' });
+    const maps = await listRuntimeAcceptanceEvidenceMaps(root, { partition: 'master', taskId: 'T1', waveRunId: 'wave-001' });
+
+    assert.equal(waves.length, 1);
+    assert.deepEqual(waves[0].taskIds, ['T1', 'T2']);
+    assert.equal(sessions[0].reuseKey, 'master:1:T1,T2');
+    assert.deepEqual(maps[0].evidenceRefs, ['artifacts/test-T1-001.log']);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime store imports changed legacy run state and events', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-legacy-import-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'legacy-run-001' });
+    const state = await readRunState(root, run.runId);
+    const statePath = path.join(root, '.sdd', 'runs', run.runId, 'state.json');
+    await mkdir(path.dirname(statePath), { recursive: true });
+    const legacyIngestion = {
+      contract: 'sdd-artifact-result-ingestion-v1' as const,
+      runId: run.runId,
+      delegationId: 'D-T1-validator-001',
+      task: 'T1',
+      agent: 'validator',
+      artifactPath: 'artifacts/validation-T1.md',
+      status: 'accepted' as const,
+      resultStatus: 'PASS' as const,
+      delegationStatus: 'COMPLETED' as const,
+      ingestedAt: '2026-01-01T00:00:00.000Z',
+      issues: [],
+      gaps: []
+    };
+    await writeFile(statePath, `${JSON.stringify({
+      ...state,
+      status: 'completed',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+      artifacts: [{ path: 'artifacts/validation-T1.md', kind: 'validation', task: 'T1', agent: 'validator', createdAt: '2026-01-01T00:00:00.000Z' }],
+      artifactIngestions: { 'D-T1-validator-001:artifacts/validation-T1.md': legacyIngestion }
+    }, null, 2)}\n`, 'utf8');
+    await writeFile(path.join(root, '.sdd', 'runs', run.runId, 'events.jsonl'), `${JSON.stringify({
+      contract: 'sdd-event-log-v1',
+      time: '2026-01-01T00:00:00.000Z',
+      event: 'legacy_event_after_store',
+      runId: run.runId,
+      summary: 'legacy event'
+    })}\n`, 'utf8');
+    await mkdir(path.dirname(getInvocationLedgerPath(root, run.runId)), { recursive: true });
+    await writeFile(getInvocationLedgerPath(root, run.runId), `${JSON.stringify({
+      contract: 'sdd-invocation-ledger-v1',
+      version: '1.0.0',
+      entryId: 'legacy-ledger-entry-001',
+      runId: run.runId,
+      taskId: 'T1',
+      branch: 'master',
+      kind: 'command',
+      ref: 'npm test',
+      status: 'declared',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      materialRefs: [],
+      metadata: { source: 'legacy-test' }
+    })}\n`, 'utf8');
+    const dbBeforeImport = new DatabaseSync(getRuntimeStorePath(root));
+    try {
+      dbBeforeImport.prepare('DELETE FROM runs WHERE run_id = ?').run(run.runId);
+    } finally {
+      dbBeforeImport.close();
+    }
+
+    const importedState = await readRunState(root, run.runId);
+    const importedEvents = await readRunEvents(root, run.runId);
+    const importedLedger = await listInvocationLedgerEntries(root, run.runId);
+    const db = new DatabaseSync(getRuntimeStorePath(root), { readOnly: true });
+    try {
+      const artifact = db.prepare('SELECT path, status FROM artifacts WHERE run_id = ? AND path = ?').get(run.runId, 'artifacts/validation-T1.md') as { path?: string; status?: string } | undefined;
+      const ingestion = db.prepare('SELECT status, result_status FROM artifact_ingestions WHERE run_id = ? AND artifact_path = ?').get(run.runId, 'artifacts/validation-T1.md') as { status?: string; result_status?: string } | undefined;
+      const activity = db.prepare('SELECT ref, status FROM activities WHERE run_id = ? AND activity_id = ?').get(run.runId, 'legacy-ledger-entry-001') as { ref?: string; status?: string } | undefined;
+      assert.equal(importedState.status, 'completed');
+      assert.equal(importedEvents.some((event) => event.event === 'legacy_event_after_store'), true);
+      assert.equal(importedLedger.some((entry) => entry.entryId === 'legacy-ledger-entry-001'), true);
+      assert.equal(artifact?.status, 'legacy_imported');
+      assert.equal(ingestion?.status, 'accepted');
+      assert.equal(ingestion?.result_status, 'PASS');
+      assert.equal(activity?.ref, 'npm test');
+    } finally {
+      db.close();
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test('evidence lookup locates metadata payload statuses without gate authority', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-evidence-lookup-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'lookup-run-001' });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-a'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/validation-T1.md',
+      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-a.md',
+      artifactRole: 'validation',
+      digest: 'active-a',
+      status: 'active',
+      payload: { title: 'first active' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-b'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/validation-T1.md',
+      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-b.md',
+      artifactRole: 'validation',
+      digest: 'active-b',
+      status: 'active',
+      payload: { title: 'second active' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/review-T1.md', 'candidate'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/review-T1.md',
+      physicalPayloadPath: 'artifacts/review-T1-lookup-run-001-candidate.md',
+      artifactRole: 'review',
+      digest: 'candidate',
+      status: 'candidate',
+      payload: { title: 'candidate review' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/review-T1.md', 'rejected'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/review-T1.md',
+      physicalPayloadPath: 'artifacts/review-T1-lookup-run-001-rejected.md',
+      artifactRole: 'review',
+      digest: 'rejected',
+      status: 'rejected',
+      payload: { title: 'rejected review' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-t2'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T2',
+      logicalRef: 'artifacts/validation-T1.md',
+      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-t2.md',
+      artifactRole: 'validation',
+      digest: 'active-t2',
+      status: 'active',
+      payload: { title: 'different task active' }
+    });
+
+    const lookup = await lookupEvidence(root, { runId: run.runId, taskId: 'T1', status: 'any' });
+
+    assert.equal(lookup.retrievalMemoryOnly, true);
+    assert.equal(lookup.gateTruthAuthority, false);
+    assert.deepEqual(lookup.counts, { active: 1, candidate: 1, rejected: 1, superseded: 1 });
+    assert.equal(lookup.payloads.some((payload) => payload.status === 'superseded'), true);
+    assert.deepEqual(lookup.resolvedPayloads.map((payload) => payload.physicalPayloadPath), ['artifacts/validation-T1-lookup-run-001-active-b.md']);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime durable gaps persist query and protect terminal closure authority', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-durable-gap-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'durable-gap-run-001' });
+    await recordRuntimeDurableGap(root, {
+      gapId: 'gap-001',
+      partition: 'master',
+      taskId: 'T1',
+      runId: run.runId,
+      stage: 'test',
+      gate: 'workflow',
+      source: 'agent',
+      category: 'evidence_gap',
+      severity: 'blocking',
+      status: 'open',
+      message: 'Validation evidence is missing.',
+      recommendation: 'Run sdd test task T1 --branch master.',
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      proposalRefs: [],
+      sourceRefs: ['agent:validator'],
+      payload: { proposedBy: 'validator' }
+    });
+
+    const open = await listRuntimeDurableGaps(root, { partition: 'master', taskId: 'T1', status: 'open_terminal' });
+    assert.equal(open.length, 1);
+    assert.equal(open[0].severity, 'blocking');
+    await assert.rejects(() => recordRuntimeDurableGap(root, {
+      ...open[0],
+      gapId: 'gap-llm-close',
+      source: 'llm_advisor',
+      status: 'resolved',
+      payload: {}
+    }), /terminal status resolved cannot be written by llm_advisor/);
+    await assert.rejects(() => updateRuntimeDurableGapStatus(root, { gapId: 'gap-001', status: 'resolved', source: 'team' }), /terminal status resolved cannot be written by team/);
+
+    const status = await getProjectStatus(root, { branch: 'master' });
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+    const evidence = await readTaskEvidenceView(root, { branch: 'master', taskId: 'T1' });
+    assert.equal(status.durableGaps.length, 1);
+    assert.equal(statuslineProjectionFromStatus(status).counts.durableGaps, 1);
+    assert.equal(report.checks.some((check) => check.check === 'durable_gap_runtime' && check.level === 'FAIL' && /blocking=1/.test(check.message)), true);
+    assert.equal(evidence.durableGaps.length, 1);
+
+    const resolved = await updateRuntimeDurableGapStatus(root, { gapId: 'gap-001', status: 'resolved', source: 'gate_policy' });
+    assert.equal(resolved?.status, 'resolved');
+    assert.equal(resolved?.closedAt !== null, true);
+    assert.equal((await listRuntimeDurableGaps(root, { partition: 'master', taskId: 'T1', status: 'open_terminal' })).length, 0);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('stage team role results advisors and fan-in evidence persist as advisory gate inputs', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-team-runtime-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'stage-team-run-001' });
+    const session: StageTeamSessionRecord = {
+      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+      sessionId: 'session-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      stage: 'test',
+      lifecycleProfile: 'full',
+      status: 'completed',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:01:00.000Z',
+      assignments: [{
+        assignmentId: 'assignment-001',
+        roleId: 'role.evidence-runner',
+        agentId: 'validator',
+        status: 'completed',
+        required: true,
+        authorityCeiling: 'gate_input',
+        materialRefs: ['verify.md'],
+        createdAt: '2026-01-01T00:00:00.000Z',
+        updatedAt: '2026-01-01T00:01:00.000Z'
+      }],
+      payload: { profileReason: 'high risk' }
+    };
+    const roleResult: StageRoleResultRecord = {
+      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+      resultId: 'role-result-001',
+      sessionId: session.sessionId,
+      assignmentId: 'assignment-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      roleId: 'role.evidence-runner',
+      agentId: 'validator',
+      outputKind: 'evidence',
+      authorityCeiling: 'gate_input',
+      status: 'accepted',
+      summary: 'Validation evidence collected.',
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      durableGapIds: ['gap-001'],
+      proposalRefs: ['artifacts/proposal-T1.md'],
+      advisorAssessmentIds: ['advisor-001'],
+      createdAt: '2026-01-01T00:02:00.000Z',
+      payload: { exitCode: 0 }
+    };
+    const advisor: LlmAdvisorAssessmentRecord = {
+      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+      assessmentId: 'advisor-001',
+      sessionId: session.sessionId,
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      kind: 'evidence_sufficiency',
+      concern: 'high',
+      validity: 'valid',
+      confidence: 'high',
+      advisoryOnly: true,
+      summary: 'Evidence is incomplete until deterministic gate confirms it.',
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      durableGapIds: ['gap-001'],
+      proposalRefs: ['artifacts/proposal-T1.md'],
+      createdAt: '2026-01-01T00:03:00.000Z',
+      payload: { recommendation: 'rerun validation' }
+    };
+    const fanIn = buildFanInEvidenceSet({
+      fanInId: 'fanin-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      stage: 'test',
+      roleResultIds: [roleResult.resultId],
+      durableGapIds: ['gap-001'],
+      proposalRefs: ['artifacts/proposal-T1.md'],
+      advisorAssessmentIds: [advisor.assessmentId],
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      canonicalEvidenceRefs: ['payload-validation-T1'],
+      createdAt: '2026-01-01T00:04:00.000Z',
+      payload: { gateWillDecide: true }
+    });
+
+    await recordRuntimeStageTeamSession(root, session);
+    await recordRuntimeStageRoleResult(root, roleResult);
+    await recordRuntimeLlmAdvisorAssessment(root, advisor);
+    await recordRuntimeFanInEvidenceSet(root, fanIn);
+    await assert.rejects(() => recordRuntimeStageRoleResult(root, { ...roleResult, resultId: 'role-result-bad', payload: { stage_passed: true } }), /stage_passed/);
+    await assert.rejects(() => recordRuntimeLlmAdvisorAssessment(root, { ...advisor, assessmentId: 'advisor-bad', advisoryOnly: false } as unknown as LlmAdvisorAssessmentRecord), /advisoryOnly=true/);
+    await assert.rejects(() => recordRuntimeFanInEvidenceSet(root, { ...fanIn, fanInId: 'fanin-bad', gateInputOnly: false } as unknown as typeof fanIn), /gateInputOnly=true/);
+
+    assert.equal((await listRuntimeStageTeamSessions(root, { partition: 'master', taskId: 'T1' })).length, 1);
+    assert.equal((await listRuntimeStageRoleResults(root, { partition: 'master', taskId: 'T1' }))[0].authorityCeiling, 'gate_input');
+    assert.equal((await listRuntimeLlmAdvisorAssessments(root, { partition: 'master', taskId: 'T1' }))[0].advisoryOnly, true);
+    assert.equal((await listRuntimeLlmAdvisorAssessments(root, { partition: 'master', taskId: 'T1' }))[0].confidence, 'high');
+    assert.equal((await listRuntimeFanInEvidenceSets(root, { partition: 'master', taskId: 'T1' }))[0].gateInputOnly, true);
+
+    const evidence = await readTaskEvidenceView(root, { branch: 'master', taskId: 'T1' });
+    const status = await getProjectStatus(root, { branch: 'master' });
+    const statusline = statuslineProjectionFromStatus(status);
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+    assert.equal(evidence.stageTeam.sessions.length, 1);
+    assert.equal(evidence.stageTeam.roleResults.length, 1);
+    assert.equal(evidence.stageTeam.advisorAssessments.length, 1);
+    assert.equal(evidence.stageTeam.fanInEvidenceSets.length, 1);
+    assert.equal(status.stageTeamHealth.highConcernAdvisors, 1);
+    assert.equal(statusline.counts.stageTeamSessions, 1);
+    assert.equal(statusline.counts.stageRoleResults, 1);
+    assert.equal(statusline.counts.advisorAssessments, 1);
+    assert.equal(report.checks.some((check) => check.check === 'stage_team_runtime' && check.level === 'WARN' && /high_concern=1/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});