sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -18,7 +18,7 @@ import { getProjectStatus, statuslineProjectionFromStatus } from '../status/proj
 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';
+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-'));
@@ -47,7 +47,7 @@ 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-8\.17-validation-wave-runtime-v6/);
+    assert.match(runtimeStoreCheck?.message ?? '', /phase-9\.1-stage-collaboration-contracts-runtime-v12/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -310,7 +310,7 @@ test('evidence lookup locates metadata payload statuses without gate authority',
 
     assert.equal(lookup.retrievalMemoryOnly, true);
     assert.equal(lookup.gateTruthAuthority, false);
-    assert.deepEqual(lookup.counts, { active: 1, candidate: 1, rejected: 1, superseded: 1 });
+    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 {
@@ -318,6 +318,158 @@ test('evidence lookup locates metadata payload statuses without gate authority',
   }
 });
 
+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 {
@@ -335,7 +487,7 @@ test('runtime durable gaps persist query and protect terminal closure authority'
       severity: 'blocking',
       status: 'open',
       message: 'Validation evidence is missing.',
-      recommendation: 'Run sdd test task T1 --branch master.',
+      recommendation: 'Run sdd test task-T1 --branch master.',
       evidenceRefs: ['artifacts/validation-T1.md'],
       proposalRefs: [],
       sourceRefs: ['agent:validator'],
@@ -487,3 +639,43 @@ test('stage team role results advisors and fan-in evidence persist as advisory g
     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 });
+  }
+});