sdd-agent-platform 0.4.0 → 0.4.1

package/node_modules/@sdd-agent-platform/core/dist/verification/test-runtime.js

@@ -7,26 +7,26 @@ import { writeArtifact } from '../run-state/artifacts.js';
 import { resolveSddContext } from '../sdd-docs/context.js';
 import { bindRunStateToTask } from '../sdd-docs/run-binding.js';
 import { parseSddBranch } from '../sdd-docs/task-parser.js';
-import { recordRuntimeProjection, recordRuntimeTestRun, recordRuntimeTestStep, runtimeScopedId } from '../storage/runtime-store.js';
+import { inspectSddTask } from '../sdd-docs/task-inspection.js';
+import { recordRuntimeAcceptanceEvidenceMap, recordRuntimeDurableGap, recordRuntimeProjection, recordRuntimeTestRun, recordRuntimeTestStep, recordRuntimeValidationEnvironmentSession, recordRuntimeValidationWaveRun, runtimeScopedId, updateRuntimeDurableGapStatus } from '../storage/runtime-store.js';
 import { ACCEPTANCE_POLICY_RULESET_VERSION, SDD_EVIDENCE_CONTRACT, SDD_EVIDENCE_VERSION, SDD_RESULT_CONTRACT, SDD_RESULT_VERSION, TEST_EVIDENCE_RUN_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION } from '../contracts.js';
-import { inspectVerifyContract, writeVerifyContract } from './verify-contract.js';
+import { inspectVerifyContract } from './verify-contract.js';
 import { ensureTaskOrchestration, inspectOrchestrationGate } from '../orchestration/runtime.js';
 import { recordStageRunProjection, recordWorkflowHandoffProjection, validateWorkflowHandoff } from '../stage-runtime/runtime.js';
 import { evaluateTaskWorkflowGate, verifyContractBlockedGate } from '../risk.js';
 import { validateSddResultArtifact } from '../artifacts/sdd-result.js';
 import { dependencyBlockingReasonsForTask } from '../workflow-state/dependencies.js';
+import { routeSddTask } from '../router/route-sdd-task.js';
+import { evaluateAndRecordWorkflowGateDecision } from '../workflow-gate/evidence-packet.js';
 const DEFAULT_TEST_TIMEOUT_MS = 120_000;
 const MAX_CAPTURE_BYTES = 256 * 1024;
 export async function runSddTest(projectRoot, options) {
     const context = await resolveSddContext(projectRoot, { branch: options.branch ?? undefined, branchSource: options.branch ? 'cli_option' : undefined });
-    let model = await parseSddBranch(projectRoot, context.partition);
-    let task = model.tasks.find((candidate) => candidate.id === options.taskId) ?? null;
+    const model = await parseSddBranch(projectRoot, context.partition);
+    const inspected = inspectSddTask(model, options.taskId);
+    const task = inspected.task;
     const verifyContract = await ensureVerifyContractForTest(projectRoot, context.partition);
     const verifyInspection = verifyContract.inspection;
-    if (verifyContract.action === 'created' || verifyContract.action === 'refreshed') {
-        model = await parseSddBranch(projectRoot, context.partition);
-        task = model.tasks.find((candidate) => candidate.id === options.taskId) ?? null;
-    }
     const initialState = options.runId ? await readRunState(projectRoot, options.runId) : await createRun(projectRoot);
     const state = await bindRunStateToTask(projectRoot, initialState, context, model, task, options.taskId);
     const testRunId = runtimeScopedId(state.runId, options.taskId, new Date().toISOString(), 'sdd-test');
@@ -34,6 +34,35 @@ export async function runSddTest(projectRoot, options) {
     const commands = commandInputs.map((input) => input.command);
     const gaps = [];
     const startedAt = new Date().toISOString();
+    const ownsValidationWave = !options.validationWave;
+    const validationWaveRunId = options.validationWave?.waveRunId ?? runtimeScopedId(context.partition, options.taskId, state.runId, testRunId, 'validation-wave');
+    const validationEnvironmentSessionId = options.validationWave?.environmentSessionId ?? runtimeScopedId(context.partition, validationWaveRunId, 'validation-env');
+    const validationWaveTaskIds = options.validationWave?.taskIds ?? [options.taskId];
+    const validationWaveAcceptanceRefs = options.validationWave?.acceptanceRefsByTask?.[options.taskId];
+    if (ownsValidationWave) {
+        await recordRuntimeValidationEnvironmentSession(projectRoot, {
+            sessionId: validationEnvironmentSessionId,
+            partition: context.partition,
+            runId: state.runId,
+            waveRunId: validationWaveRunId,
+            status: 'active',
+            reuseKey: `${context.partition}:${options.taskId}`,
+            createdAt: startedAt,
+            updatedAt: startedAt,
+            payload: { contract: 'phase-8.17-validation-wave-runtime-v1', mode: 'single-task' }
+        });
+        await recordRuntimeValidationWaveRun(projectRoot, {
+            waveRunId: validationWaveRunId,
+            partition: context.partition,
+            runId: state.runId,
+            taskIds: validationWaveTaskIds,
+            status: 'RUNNING',
+            environmentSessionId: validationEnvironmentSessionId,
+            startedAt,
+            completedAt: startedAt,
+            payload: { contract: 'phase-8.17-validation-wave-runtime-v1', mode: 'single-task', taskId: options.taskId }
+        });
+    }
     await appendEvent(projectRoot, state.runId, {
         event: 'test_runtime_started',
         runId: state.runId,
@@ -44,6 +73,7 @@ export async function runSddTest(projectRoot, options) {
         gaps.push(`Task ${options.taskId} was not found in specs/${context.partition}/tasks.md.`);
     }
     if (task) {
+        gaps.push(...inspected.gaps.filter((gap) => gap.severity === 'blocking').map((gap) => `${gap.field}: ${gap.message}`));
         gaps.push(...dependencyBlockingReasonsForTask(model, options.taskId));
     }
     if (verifyContract.action === 'blocked') {
@@ -91,7 +121,7 @@ export async function runSddTest(projectRoot, options) {
     const steps = [];
     if (gaps.length === 0) {
         for (const [index, commandInput] of commandInputs.entries()) {
-            const step = await runCommandStep(projectRoot, state.runId, context.partition, options.taskId, testRunId, index + 1, commandInput, acceptanceRefsForCommand(task, commandInput.command), options.timeoutMs ?? DEFAULT_TEST_TIMEOUT_MS);
+            const step = await runCommandStep(projectRoot, state.runId, context.partition, options.taskId, testRunId, index + 1, commandInput, acceptanceRefsForCommand(task, commandInput.command, validationWaveAcceptanceRefs), options.timeoutMs ?? DEFAULT_TEST_TIMEOUT_MS);
             steps.push(step);
             await appendEvent(projectRoot, state.runId, {
                 event: 'test_step_completed',
@@ -102,18 +132,39 @@ export async function runSddTest(projectRoot, options) {
         }
     }
     const commandStatus = deriveCommandStatus(gaps, steps);
-    const acceptanceCoverage = buildAcceptanceCoverage(task, steps, commandStatus);
+    const acceptanceCoverage = buildAcceptanceCoverage(task, steps, commandStatus, validationWaveAcceptanceRefs);
     const evidenceCoverage = summarizeEvidenceCoverage(acceptanceCoverage);
     const policyJudgment = derivePolicyJudgment(commandStatus, evidenceCoverage);
-    const status = policyJudgment;
-    const syncBackReady = status === 'PASS';
-    const validationArtifact = task ? await writeValidationArtifact(projectRoot, state.runId, task, status, steps, gaps) : null;
-    const unifiedEvidence = buildUnifiedTestEvidenceRun(testRunId, context.partition, state.runId, options.taskId, commandStatus, evidenceCoverage, policyJudgment, steps, acceptanceCoverage, syncBackReady, gaps);
+    await recordAcceptanceEvidenceMaps(projectRoot, validationWaveRunId, testRunId, context.partition, state.runId, options.taskId, acceptanceCoverage);
+    const validationStatus = policyJudgment;
+    const syncBackReady = false;
+    const capabilityRoute = task ? await routeSddTask(projectRoot, { taskId: options.taskId, branch: context.partition, approved: options.approved }) : null;
+    const capabilityEvidence = buildCapabilityEvidenceClassification(capabilityRoute?.capabilityDecision ?? null, steps);
+    const validationArtifact = task ? await writeValidationArtifact(projectRoot, state.runId, task, validationStatus, steps, gaps, capabilityEvidence) : null;
+    const evidenceBeforeIndex = [validationArtifact?.runRelativePath, ...steps.map((step) => step.outputArtifact)].filter((item) => Boolean(item));
+    await persistTestRunState(projectRoot, state, options.taskId, validationStatus, commands, evidenceBeforeIndex, validationArtifact?.runRelativePath ?? null);
+    await resolveTestRuntimeDurableGap(projectRoot, context.partition, state.runId, options.taskId, validationStatus, gaps);
+    const gateDecision = (await evaluateAndRecordWorkflowGateDecision(projectRoot, {
+        branch: context.partition,
+        taskId: options.taskId,
+        runId: state.runId,
+        decisionKind: 'test'
+    })).decision;
+    const runtimeJudgment = gateDecision.status;
+    const status = finalStatusForTest(validationStatus, runtimeJudgment);
+    await recordTestRuntimeDurableGap(projectRoot, context.partition, state.runId, options.taskId, status, validationStatus, runtimeJudgment, gaps, evidenceBeforeIndex);
+    const unifiedEvidence = buildUnifiedTestEvidenceRun(testRunId, context.partition, state.runId, options.taskId, commandStatus, evidenceCoverage, policyJudgment, status, runtimeJudgment, steps, acceptanceCoverage, capabilityEvidence, syncBackReady, gaps, workflowGate.nextAction, gateDecision);
     const indexArtifact = await writeIndexArtifact(projectRoot, state.runId, {
         testRunId,
+        validationWaveRunId,
+        validationEnvironmentSessionId,
         branch: context.partition,
         taskId: options.taskId,
         status,
+        validationStatus,
+        workflowGateStatus: gateDecision.status,
+        runtimeJudgment,
+        workflowGateDecision: gateDecision,
         verifyContractStatus: verifyInspection.status,
         verifyContractAction: verifyContract.action,
         lifecycleGate: workflowGate.lifecycleGate,
@@ -125,6 +176,7 @@ export async function runSddTest(projectRoot, options) {
         evidenceCoverage,
         policyJudgment,
         acceptanceCoverage,
+        capabilityEvidence,
         syncBackReady,
         commands,
         steps,
@@ -133,9 +185,6 @@ export async function runSddTest(projectRoot, options) {
     });
     const completedAt = new Date().toISOString();
     const evidence = [validationArtifact?.runRelativePath, indexArtifact.runRelativePath, ...steps.map((step) => step.outputArtifact)].filter((item) => Boolean(item));
-    const syncBackProposal = syncBackReady
-        ? await writeTestSyncBackProposal(projectRoot, state.runId, options.taskId, evidence, acceptanceCoverage)
-        : null;
     await recordRuntimeTestRun(projectRoot, {
         testRunId,
         runId: state.runId,
@@ -144,7 +193,7 @@ export async function runSddTest(projectRoot, options) {
         status,
         startedAt,
         completedAt,
-        payload: { verifyContractStatus: verifyInspection.status, verifyContractAction: verifyContract.action, lifecycleGate: workflowGate.lifecycleGate, lifecycleProfile: workflowGate.lifecycleProfile, approvalPolicy: workflowGate.approvalPolicy, requiredStages: workflowGate.requiredStages, primaryReason: workflowGate.primaryReason, commandStatus, evidenceCoverage, policyJudgment, acceptanceCoverage, syncBackReady, commands, commandInputs, evidence, gaps, syncBackProposal: syncBackProposal?.path ?? null }
+        payload: { verifyContractStatus: verifyInspection.status, verifyContractAction: verifyContract.action, lifecycleGate: workflowGate.lifecycleGate, lifecycleProfile: workflowGate.lifecycleProfile, approvalPolicy: workflowGate.approvalPolicy, requiredStages: workflowGate.requiredStages, primaryReason: workflowGate.primaryReason, commandStatus, evidenceCoverage, policyJudgment, validationStatus, workflowGateStatus: gateDecision.status, runtimeJudgment, workflowGateDecision: gateDecision, acceptanceCoverage, capabilityEvidence, syncBackReady, commands, commandInputs, evidence, gaps }
     });
     await recordRuntimeProjection(projectRoot, 'test_runtime', `${context.partition}:${options.taskId}:${state.runId}`, {
         contract: 'sdd-test-runtime-v1',
@@ -152,6 +201,9 @@ export async function runSddTest(projectRoot, options) {
         runId: state.runId,
         taskId: options.taskId,
         status,
+        validationStatus,
+        workflowGateStatus: gateDecision.status,
+        runtimeJudgment,
         lifecycleGate: workflowGate.lifecycleGate,
         primaryReason: workflowGate.primaryReason,
         evidence,
@@ -167,20 +219,50 @@ export async function runSddTest(projectRoot, options) {
         gaps,
         riskDecision: orchestration.riskDecision
     });
-    await persistTestRunState(projectRoot, state, options.taskId, status, commands, evidence, validationArtifact?.runRelativePath ?? null, syncBackProposal);
+    await persistTestGateOutcome(projectRoot, state.runId, options.taskId, status, validationStatus, commands, evidence, validationArtifact?.runRelativePath ?? null, gateDecision);
+    if (ownsValidationWave) {
+        await recordRuntimeValidationWaveRun(projectRoot, {
+            waveRunId: validationWaveRunId,
+            partition: context.partition,
+            runId: state.runId,
+            taskIds: validationWaveTaskIds,
+            status,
+            environmentSessionId: validationEnvironmentSessionId,
+            startedAt,
+            completedAt,
+            payload: { contract: 'phase-8.17-validation-wave-runtime-v1', mode: 'single-task', taskId: options.taskId, testRunId, evidence, gaps, workflowGateDecision: gateDecision }
+        });
+        await recordRuntimeValidationEnvironmentSession(projectRoot, {
+            sessionId: validationEnvironmentSessionId,
+            partition: context.partition,
+            runId: state.runId,
+            waveRunId: validationWaveRunId,
+            status: status === 'PASS' ? 'completed' : status === 'FAIL' ? 'failed' : 'blocked',
+            reuseKey: `${context.partition}:${options.taskId}`,
+            createdAt: startedAt,
+            updatedAt: completedAt,
+            payload: { contract: 'phase-8.17-validation-wave-runtime-v1', mode: 'single-task', taskId: options.taskId, validationStatus, workflowGateStatus: gateDecision.status, status }
+        });
+    }
     await appendEvent(projectRoot, state.runId, {
-        event: status === 'PASS' ? 'test_runtime_passed' : 'test_runtime_failed',
+        event: status === 'PASS' ? 'test_runtime_passed' : 'test_runtime_blocked',
         runId: state.runId,
         summary: `SDD test runtime ${status} for ${options.taskId}`,
-        data: { taskId: options.taskId, testRunId, status, evidence, gaps }
+        data: { taskId: options.taskId, testRunId, status, validationStatus, evidence, gaps, gateDecisionId: gateDecision.decisionId, gateStatus: gateDecision.status }
     });
     return {
         contract: 'sdd-test-runtime-v1',
         runId: state.runId,
         testRunId,
+        validationWaveRunId,
+        validationEnvironmentSessionId,
         branch: context.partition,
         taskId: options.taskId,
         status,
+        validationStatus,
+        workflowGateStatus: gateDecision.status,
+        runtimeJudgment,
+        workflowGateDecision: gateDecision,
         verifyContractStatus: verifyInspection.status,
         verifyContractAction: verifyContract.action,
         lifecycleGate: workflowGate.lifecycleGate,
@@ -192,15 +274,35 @@ export async function runSddTest(projectRoot, options) {
         evidenceCoverage,
         policyJudgment,
         acceptanceCoverage,
+        capabilityEvidence,
         syncBackReady,
         commands,
         steps,
         validationArtifact: validationArtifact?.runRelativePath ?? null,
         indexArtifact: indexArtifact.runRelativePath,
         gaps,
-        next: nextForTestResult(status, context.partition, options.taskId, state.runId, indexArtifact.runRelativePath, workflowGate.nextAction)
+        next: nextForTestResult(status, runtimeJudgment, context.partition, options.taskId, state.runId, indexArtifact.runRelativePath, workflowGate.nextAction, gateDecision)
     };
 }
+async function recordAcceptanceEvidenceMaps(projectRoot, waveRunId, testRunId, partition, runId, taskId, acceptanceCoverage) {
+    const createdAt = new Date().toISOString();
+    for (const coverage of acceptanceCoverage) {
+        await recordRuntimeAcceptanceEvidenceMap(projectRoot, {
+            mapId: runtimeScopedId(waveRunId, testRunId, taskId, coverage.acceptanceRef),
+            waveRunId,
+            testRunId,
+            partition,
+            runId,
+            taskId,
+            acceptanceRef: coverage.acceptanceRef,
+            status: coverage.status,
+            evidenceRefs: coverage.evidenceRefs.map((ref) => ref.ref),
+            gaps: coverage.gaps,
+            createdAt,
+            payload: coverage
+        });
+    }
+}
 async function recordTestWorkflowProjection(projectRoot, input) {
     const outputRefs = input.evidence.map((ref) => ({ kind: 'artifact', ref }));
     const completedStage = {
@@ -233,19 +335,8 @@ async function recordTestWorkflowProjection(projectRoot, input) {
     await recordWorkflowHandoffProjection(projectRoot, validation.valid ? handoff : { ...handoff, status: 'blocked', blockingGaps: validation.issues, decidedAt: input.completedAt });
 }
 async function ensureVerifyContractForTest(projectRoot, branch) {
-    let inspection = await inspectVerifyContract(projectRoot, { branch, branchSource: 'cli_option' });
-    if (inspection.status === 'BLOCKED') {
-        return { inspection, action: 'blocked' };
-    }
-    if (inspection.status === 'PASS') {
-        return { inspection, action: 'none' };
-    }
-    const written = await writeVerifyContract(projectRoot, { branch, branchSource: 'cli_option', force: inspection.exists });
-    inspection = await inspectVerifyContract(projectRoot, { branch, branchSource: 'cli_option' });
-    if (inspection.status !== 'PASS') {
-        return { inspection, action: 'blocked' };
-    }
-    return { inspection, action: written.status === 'created' ? 'created' : 'refreshed' };
+    const inspection = await inspectVerifyContract(projectRoot, { branch, branchSource: 'cli_option' });
+    return { inspection, action: inspection.status === 'PASS' ? 'none' : 'blocked' };
 }
 function verifyContractBlocker(inspection) {
     const issueSummary = inspection.issues.map((issue) => `${issue.field}: ${issue.message}`).join(' ');
@@ -272,8 +363,14 @@ export function renderSddTestResult(result) {
         '',
         resultSentenceForTest(result),
         '',
+        'Decision:',
+        `- validation_status=${result.validationStatus}`,
+        `- workflow_gate_status=${result.workflowGateStatus}`,
+        `- workflow_gate_decision=${result.workflowGateDecision.decisionId}`,
+        '',
         'Why:',
         `- ${result.primaryReason}`,
+        `- capability_evidence=${capabilityEvidenceSummary(result.capabilityEvidence)}`,
         '',
         'Next:',
         `- ${result.next}`
@@ -386,28 +483,57 @@ function executeCommand(projectRoot, commandInput, timeoutMs) {
         child.on('close', (code, signal) => finish({ exitCode: code, signal, error: null }));
     });
 }
-async function writeValidationArtifact(projectRoot, runId, task, status, steps, gaps) {
-    const artifactPath = `validation-${task.id}.md`;
+async function writeValidationArtifact(projectRoot, runId, task, status, steps, gaps, capabilityEvidence) {
+    const artifactPath = `test-validation-${task.id}.md`;
     const runRelativePath = `artifacts/${artifactPath}`;
     const resultStatus = status === 'PASS' ? 'PASS' : status === 'FAIL' ? 'FAIL' : 'BLOCKED';
-    const content = `# Validation ${task.id}\n\n\`\`\`sdd-result\ncontract: ${SDD_RESULT_CONTRACT}\nversion: ${SDD_RESULT_VERSION}\nagent: validator\ntask: ${task.id}\nstatus: ${resultStatus}\nartifacts:\n  - ${runRelativePath}\n\`\`\`\n\n## Test Runtime\n\n- status: ${status}\n- commands:\n${steps.length > 0 ? steps.map((step) => `  - [${step.status}] ${step.command}`).join('\n') : '  - none'}\n- gaps:\n${gaps.length > 0 ? gaps.map((gap) => `  - ${gap}`).join('\n') : '  - none'}\n\n## Acceptance Evidence\n\n${renderEvidenceBlocks(task, status, runRelativePath, steps)}\n`;
+    const content = `# Test Validation ${task.id}\n\n\`\`\`sdd-result\ncontract: ${SDD_RESULT_CONTRACT}\nversion: ${SDD_RESULT_VERSION}\nagent: validator\ntask: ${task.id}\nstatus: ${resultStatus}\nartifacts:\n  - ${runRelativePath}\n\`\`\`\n\n## Test Runtime\n\n- status: ${status}\n- commands:\n${steps.length > 0 ? steps.map((step) => `  - [${step.status}] ${step.command}`).join('\n') : '  - none'}\n- gaps:\n${gaps.length > 0 ? gaps.map((gap) => `  - ${gap}`).join('\n') : '  - none'}\n\n## Capability Evidence Classification\n\n${renderCapabilityEvidenceClassification(capabilityEvidence)}\n\n## Acceptance Evidence\n\n${renderEvidenceBlocks(task, status, runRelativePath, steps)}\n`;
     return writeArtifact(projectRoot, runId, artifactPath, content);
 }
-async function writeTestSyncBackProposal(projectRoot, runId, taskId, artifacts, acceptanceCoverage) {
-    const content = `# Sync-back Proposal\n\n## ${taskId}\n\n- status: verified\n- summary: /sdd:test passed with complete command and acceptance evidence.\n- artifacts:\n${artifacts.length > 0 ? artifacts.map((artifact) => `  - ${artifact}`).join('\n') : '  - none'}\n- acceptance_coverage:\n${acceptanceCoverage.length > 0 ? acceptanceCoverage.map((coverage) => `  - [${coverage.status}] ${coverage.acceptanceRef}`).join('\n') : '  - none'}\n- gaps:\n  - none\n\n## Boundaries\n\n- Proposal only; tasks.md/spec.md/plan.md were not modified by runtime.\n- /sdd:test executed declared validation commands and mapped evidence to acceptance refs.\n`;
-    const written = await writeArtifact(projectRoot, runId, 'sync-back-proposal.md', content);
-    return { path: written.runRelativePath, digest: hashDocumentContent(content) };
-}
 async function writeIndexArtifact(projectRoot, runId, payload) {
     return writeArtifact(projectRoot, runId, `test-index-${payload.taskId}.json`, `${JSON.stringify({ contract: 'sdd-test-runtime-v1', runId, ...payload }, null, 2)}\n`);
 }
-async function persistTestRunState(projectRoot, state, taskId, status, commands, evidence, validationArtifact, syncBackProposal) {
+async function persistTestRunState(projectRoot, state, taskId, validationStatus, commands, evidence, validationArtifact) {
     const latest = await readRunState(projectRoot, state.runId);
     const knownArtifacts = new Set(latest.artifacts.map((artifact) => artifact.path));
     const now = new Date().toISOString();
     const nextArtifacts = evidence
         .filter((artifactPath) => !knownArtifacts.has(artifactPath))
-        .map((artifactPath) => ({ path: artifactPath, kind: artifactPath.includes('validation-') ? 'validation' : 'test', task: taskId, agent: artifactPath === validationArtifact ? 'validator' : 'test-runtime', createdAt: now }));
+        .map((artifactPath) => ({ path: artifactPath, kind: testArtifactKind(artifactPath), task: taskId, agent: 'test-runtime', createdAt: now }));
+    const existingTaskState = latest.tasks[taskId];
+    await writeRunState(projectRoot, {
+        ...latest,
+        status: validationStatus === 'PASS' ? 'running' : validationStatus === 'FAIL' ? 'failed' : 'blocked',
+        phase: 'test',
+        currentTask: taskId,
+        tasks: {
+            ...latest.tasks,
+            [taskId]: {
+                ...baseRuntimeTaskState(existingTaskState),
+                status: validationStatus === 'PASS' ? 'validation_passed_pending_gate' : validationStatus === 'FAIL' ? 'validation_failed' : 'validation_blocked',
+                implementationStatus: existingTaskState?.implementationStatus ?? 'implemented',
+                verificationStatus: verificationStatusFromTest(validationStatus),
+                testStatus: validationStatus,
+                evidence
+            }
+        },
+        artifacts: [...latest.artifacts, ...nextArtifacts],
+        validation: {
+            status: validationStatus === 'PASS' ? 'pass' : validationStatus === 'FAIL' ? 'fail' : 'blocked',
+            commands,
+            evidence
+        },
+        syncBack: latest.syncBack
+    });
+}
+async function persistTestGateOutcome(projectRoot, runId, taskId, status, validationStatus, commands, evidence, validationArtifact, gateDecision) {
+    const latest = await readRunState(projectRoot, runId);
+    const knownArtifacts = new Set(latest.artifacts.map((artifact) => artifact.path));
+    const now = new Date().toISOString();
+    const nextArtifacts = evidence
+        .filter((artifactPath) => !knownArtifacts.has(artifactPath))
+        .map((artifactPath) => ({ path: artifactPath, kind: testArtifactKind(artifactPath), task: taskId, agent: 'test-runtime', createdAt: now }));
+    const existingTaskState = latest.tasks[taskId];
     await writeRunState(projectRoot, {
         ...latest,
         status: status === 'PASS' ? 'completed' : status === 'FAIL' ? 'failed' : 'blocked',
@@ -416,28 +542,67 @@ async function persistTestRunState(projectRoot, state, taskId, status, commands,
         tasks: {
             ...latest.tasks,
             [taskId]: {
-                status: status === 'PASS' ? 'tested' : 'blocked',
+                ...baseRuntimeTaskState(existingTaskState),
+                status: runtimeTaskStatusAfterGate(status, validationStatus),
+                implementationStatus: existingTaskState?.implementationStatus ?? 'implemented',
+                verificationStatus: verificationStatusFromTest(validationStatus),
                 testStatus: status,
+                validationStatus,
+                workflowGateStatus: gateDecision.status,
+                workflowGateDecisionId: gateDecision.decisionId,
                 evidence
             }
         },
         artifacts: [...latest.artifacts, ...nextArtifacts],
         validation: {
-            status: status === 'PASS' ? 'pass' : status === 'FAIL' ? 'fail' : 'blocked',
+            status: validationStatus === 'PASS' ? 'pass' : validationStatus === 'FAIL' ? 'fail' : 'blocked',
             commands,
             evidence
         },
-        syncBack: syncBackProposal
-            ? {
-                mode: 'proposal',
-                proposalPath: syncBackProposal.path,
-                proposalDigest: syncBackProposal.digest,
-                sourceVerifyStatus: status,
-                status: 'proposed'
-            }
-            : latest.syncBack
+        syncBack: latest.syncBack
     });
 }
+function testArtifactKind(artifactPath) {
+    const fileName = artifactPath.split('/').pop() ?? artifactPath;
+    if (fileName.startsWith('test-validation-')) {
+        return 'test-validation';
+    }
+    if (fileName.startsWith('test-index-')) {
+        return 'test-index';
+    }
+    return 'test';
+}
+function baseRuntimeTaskState(existing) {
+    return {
+        status: existing?.status ?? 'not_started',
+        implementationStatus: existing?.implementationStatus ?? 'not_started',
+        verificationStatus: existing?.verificationStatus ?? 'not_run',
+        validationBatch: existing?.validationBatch ?? null,
+        validationTiming: existing?.validationTiming ?? 'task_end',
+        requiresVerifyBeforeNext: existing?.requiresVerifyBeforeNext ?? true,
+        gaps: existing?.gaps,
+        artifacts: existing?.artifacts,
+        testStatus: existing?.testStatus,
+        workflowGateStatus: existing?.workflowGateStatus,
+        workflowGateDecisionId: existing?.workflowGateDecisionId,
+        evidence: existing?.evidence
+    };
+}
+function verificationStatusFromTest(validationStatus) {
+    if (validationStatus === 'PASS') {
+        return 'pass';
+    }
+    return validationStatus === 'FAIL' ? 'failed' : 'blocked';
+}
+function runtimeTaskStatusAfterGate(status, validationStatus) {
+    if (status === 'PASS') {
+        return 'implemented_verified';
+    }
+    if (validationStatus === 'PASS') {
+        return 'workflow_gate_blocked';
+    }
+    return validationStatus === 'FAIL' ? 'validation_failed' : 'validation_blocked';
+}
 function deriveCommandStatus(gaps, steps) {
     if (gaps.length > 0 || steps.some((step) => step.status === 'blocked')) {
         return 'BLOCKED';
@@ -447,8 +612,8 @@ function deriveCommandStatus(gaps, steps) {
     }
     return 'PASS';
 }
-function buildAcceptanceCoverage(task, steps, commandStatus) {
-    const acceptanceRefs = task ? taskAcceptanceRefs(task) : [];
+function buildAcceptanceCoverage(task, steps, commandStatus, acceptanceRefsOverride) {
+    const acceptanceRefs = acceptanceRefsOverride && acceptanceRefsOverride.length > 0 ? [...new Set(acceptanceRefsOverride)] : task ? taskAcceptanceRefs(task) : [];
     return acceptanceRefs.map((acceptanceRef) => {
         const mappedSteps = steps.filter((step) => step.acceptanceRefs.includes(acceptanceRef));
         const hasPassingEvidence = mappedSteps.some((step) => step.status === 'pass');
@@ -462,7 +627,7 @@ function buildAcceptanceCoverage(task, steps, commandStatus) {
             acceptanceRef,
             status,
             evidenceRefs: mappedSteps.map((step) => ({ kind: 'artifact', ref: step.outputArtifact })),
-            gaps: status === 'complete' ? [] : [`Acceptance ${acceptanceRef} has no complete non-stale evidence from /sdd:test.`]
+            gaps: status === 'complete' ? [] : [`Acceptance ${acceptanceRef} has no complete non-stale evidence from sdd test task.`]
         };
     });
 }
@@ -487,7 +652,51 @@ function derivePolicyJudgment(commandStatus, evidenceCoverage) {
     }
     return 'PASS';
 }
-function buildUnifiedTestEvidenceRun(id, branch, runId, taskId, commandStatus, evidenceCoverage, policyJudgment, steps, acceptanceCoverage, syncBackReady, gaps) {
+async function resolveTestRuntimeDurableGap(projectRoot, branch, runId, taskId, validationStatus, gaps) {
+    if (validationStatus !== 'PASS' || gaps.length > 0) {
+        return;
+    }
+    await updateRuntimeDurableGapStatus(projectRoot, {
+        gapId: testRuntimeGapId(branch, runId, taskId),
+        status: 'resolved',
+        source: 'gate_policy',
+        payload: { validationStatus, gaps }
+    });
+}
+async function recordTestRuntimeDurableGap(projectRoot, branch, runId, taskId, status, validationStatus, runtimeJudgment, gaps, evidenceRefs) {
+    if (status === 'PASS' && gaps.length === 0) {
+        return;
+    }
+    const message = gaps[0] ?? (runtimeJudgment === 'PASS' ? `Validation status is ${validationStatus}.` : `Workflow gate status is ${runtimeJudgment}.`);
+    await recordRuntimeDurableGap(projectRoot, {
+        gapId: testRuntimeGapId(branch, runId, taskId),
+        partition: branch,
+        taskId,
+        runId,
+        stage: 'test',
+        gate: 'test',
+        source: 'runtime',
+        category: runtimeJudgment === 'PASS' ? 'validation' : 'workflow_gate',
+        severity: 'blocking',
+        status: 'open',
+        message,
+        recommendation: `Resolve test runtime gaps for ${taskId}, then rerun sdd test task ${taskId} --branch ${branch}.`,
+        evidenceRefs,
+        proposalRefs: [],
+        sourceRefs: [],
+        payload: { status, validationStatus, runtimeJudgment, gaps }
+    });
+}
+function testRuntimeGapId(branch, _runId, taskId) {
+    return runtimeScopedId(branch, taskId, 'test-runtime-gap');
+}
+function finalStatusForTest(validationStatus, runtimeJudgment) {
+    if (validationStatus !== 'PASS') {
+        return validationStatus;
+    }
+    return runtimeJudgment === 'PASS' ? 'PASS' : 'BLOCKED';
+}
+function buildUnifiedTestEvidenceRun(id, branch, runId, taskId, commandStatus, evidenceCoverage, policyJudgment, status, runtimeJudgment, steps, acceptanceCoverage, capabilityEvidence, syncBackReady, gaps, gateNextAction, gateDecision) {
     return {
         contract: TEST_EVIDENCE_RUN_CONTRACT_VERSION,
         id,
@@ -505,24 +714,98 @@ function buildUnifiedTestEvidenceRun(id, branch, runId, taskId, commandStatus, e
             completedAt: new Date().toISOString()
         })),
         acceptanceCoverage,
+        capabilityEvidence,
         syncBackReady,
         gaps: [...gaps, ...acceptanceCoverage.flatMap((coverage) => coverage.gaps)],
-        next: nextForTestResult(policyJudgment, branch, taskId, runId, `artifacts/test-index-${taskId}.json`, null),
+        next: nextForTestResult(status, runtimeJudgment, branch, taskId, runId, `artifacts/test-index-${taskId}.json`, gateNextAction, gateDecision),
         generatedAt: new Date().toISOString()
     };
 }
-function nextForTestResult(status, branch, taskId, runId, indexArtifact, gateNextAction) {
+function buildCapabilityEvidenceClassification(decision, steps) {
+    if (!decision) {
+        return [{
+                class: 'diagnostic',
+                source: 'runtime_diagnostic',
+                domainOrSourceId: 'capability-routing',
+                evidenceRefs: [],
+                acceptanceRefs: [],
+                provenanceRefs: [],
+                reason: 'Capability routing did not run; no capability output is accepted as test evidence.'
+            }];
+    }
+    const acceptanceRefs = [...new Set(steps.flatMap((step) => step.acceptanceRefs))];
+    const professionalEvidence = decision.selectedDomains.map((domain) => ({
+        class: 'candidate',
+        source: 'professional_capability',
+        domainOrSourceId: domain.domain,
+        evidenceRefs: [],
+        acceptanceRefs,
+        provenanceRefs: [{ kind: 'projection', ref: `capability:${domain.capabilityId}` }],
+        reason: `${domain.reason}; capability output is advisory candidate evidence until accepted by command evidence and policy refs.`
+    }));
+    const externalEvidence = decision.rejectedExternalSources.map((source) => ({
+        class: capabilityClassForRejectedSource(source.quarantineStatus),
+        source: 'external_source',
+        domainOrSourceId: source.sourceId,
+        evidenceRefs: [],
+        acceptanceRefs: [],
+        provenanceRefs: [{ kind: 'external', ref: source.sourceId }],
+        reason: source.reason
+    }));
+    return [...professionalEvidence, ...externalEvidence];
+}
+function capabilityClassForRejectedSource(status) {
+    if (status === 'denied') {
+        return 'blocked';
+    }
+    if (status === 'required' || status === 'quarantined') {
+        return 'quarantined';
+    }
+    return 'diagnostic';
+}
+function renderCapabilityEvidenceClassification(items) {
+    if (items.length === 0) {
+        return '- none';
+    }
+    return items.map((item) => `- [${item.class}] ${item.source}:${item.domainOrSourceId} — ${item.reason}`).join('\n');
+}
+function capabilityEvidenceSummary(items) {
+    if (items.length === 0) {
+        return 'none';
+    }
+    const counts = new Map();
+    for (const item of items) {
+        counts.set(item.class, (counts.get(item.class) ?? 0) + 1);
+    }
+    return [...counts.entries()].map(([kind, count]) => `${kind}:${count}`).join(',');
+}
+function nextForTestResult(status, runtimeJudgment, branch, taskId, _runId, indexArtifact, gateNextAction, gateDecision) {
     if (status === 'PASS') {
-        return `sdd sync-back inspect ${runId} --branch ${branch} --task ${taskId}`;
+        return `sdd ship --branch ${branch} --dry-run`;
+    }
+    if (gateNextAction) {
+        return gateNextAction;
+    }
+    if (runtimeJudgment === 'HUMAN_REQUIRED') {
+        return gateDecision ? `Create a decision card for workflow gate ${gateDecision.decisionId}, then rerun sdd test task ${taskId} --branch ${branch}.` : `Create a decision card, then rerun sdd test task ${taskId} --branch ${branch}.`;
+    }
+    if (runtimeJudgment === 'WARN') {
+        return gateDecision ? `Review workflow gate ${gateDecision.decisionId} warnings, then rerun sdd test task ${taskId} --branch ${branch} or proceed only with explicit review.` : `Review workflow gate warnings, then rerun sdd test task ${taskId} --branch ${branch}.`;
     }
-    return gateNextAction ?? `Inspect ${indexArtifact}, fix command/evidence gaps, then rerun sdd test task ${taskId} --branch ${branch}.`;
+    if (runtimeJudgment === 'ADVISORY_ONLY') {
+        return `Inspect advisor assessments for ${taskId}; advisory output cannot satisfy the test gate.`;
+    }
+    if (status === 'FAIL') {
+        return `Inspect ${indexArtifact}, fix failing validation commands, then rerun sdd test task ${taskId} --branch ${branch}.`;
+    }
+    return gateDecision ? `Inspect ${indexArtifact} and workflow gate ${gateDecision.decisionId}, resolve blockers, then rerun sdd test task ${taskId} --branch ${branch}.` : `Inspect ${indexArtifact}, fix command/evidence gaps, then rerun sdd test task ${taskId} --branch ${branch}.`;
 }
 function resultSentenceForTest(result) {
-    if (result.status === 'PASS' && result.lifecycleGate === 'direct') {
-        return 'Validation passed and sync-back is ready.';
-    }
     if (result.status === 'PASS') {
-        return 'Validation passed; sync-back needs review.';
+        return 'Validation and workflow gate passed; proceed to release readiness.';
+    }
+    if (result.validationStatus === 'PASS' && result.workflowGateStatus !== 'PASS') {
+        return `Validation passed, but workflow gate returned ${result.workflowGateStatus}.`;
     }
     if (result.commandStatus === 'BLOCKED') {
         return 'Blocked before validation commands ran.';
@@ -564,7 +847,10 @@ function normalizeTestCommandInput(input) {
     }
     throw new Error('Command input must include command or argv.');
 }
-function acceptanceRefsForCommand(task, command) {
+function acceptanceRefsForCommand(task, command, acceptanceRefsOverride) {
+    if (acceptanceRefsOverride && acceptanceRefsOverride.length > 0) {
+        return [...new Set(acceptanceRefsOverride)];
+    }
     return [...new Set((task?.validationCommands ?? [])
             .filter((entry) => entry.command === command)
             .flatMap((entry) => entry.acceptanceRefs))];