sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { DatabaseSync } from 'node:sqlite';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 
@@ -12,6 +12,13 @@ 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-'));
@@ -26,12 +33,13 @@ test('runtime store mirrors run state events artifacts and doctor visibility', a
       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 relative_path FROM evidence_attachments WHERE run_id = ? AND relative_path = ?').get(run.runId, 'artifacts/validation-T1.md') as { relative_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?.relative_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();
     }
@@ -39,7 +47,107 @@ test('runtime store mirrors run state events artifacts and doctor visibility', a
     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-7\.2-runtime-store-v2/);
+    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 });
   }
@@ -52,6 +160,7 @@ test('runtime store imports changed legacy run state and events', async () => {
     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,
@@ -80,6 +189,7 @@ test('runtime store imports changed legacy run state and events', async () => {
       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',
@@ -123,3 +233,449 @@ test('runtime store imports changed legacy run state and events', async () => {
     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 });
+  }
+});