sdd-agent-platform 0.4.0 → 0.4.1

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

@@ -2,23 +2,28 @@ import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { appendEvent } from '../run-state/events.js';
 import { appendInvocationLedgerEntry } from '../run-state/invocation-ledger.js';
-import type { RunState } from '../run-state/model.js';
+import type { RunState, RunStateTaskRuntime } from '../run-state/model.js';
 import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
 import { writeArtifact } from '../run-state/artifacts.js';
 import { resolveSddContext } from '../sdd-docs/context.js';
 import { bindRunStateToTask } from '../sdd-docs/run-binding.js';
 import { parseSddBranch, type SddTask } 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 type { LifecycleRiskDecision } from '../risk/contracts.js';
-import { inspectVerifyContract, writeVerifyContract, type VerifyContractInspection } from './verify-contract.js';
-import type { AcceptanceEvidenceCoverage, EvidenceCoverageStatus, TestEvidenceStatus, UnifiedTestEvidenceRun } from '../evidence-runtime.js';
+import { inspectVerifyContract, type VerifyContractInspection } from './verify-contract.js';
+import type { AcceptanceEvidenceCoverage, CapabilityEvidenceClassification, EvidenceCoverageStatus, TestEvidenceStatus, UnifiedTestEvidenceRun } from '../evidence-runtime.js';
 import { ensureTaskOrchestration, inspectOrchestrationGate } from '../orchestration/runtime.js';
 import { recordStageRunProjection, recordWorkflowHandoffProjection, validateWorkflowHandoff } from '../stage-runtime/runtime.js';
 import type { StageRun, WorkflowHandoff } from '../stage-runtime/contracts.js';
 import { evaluateTaskWorkflowGate, verifyContractBlockedGate, type ApprovalPolicy, type LifecycleRiskProfile, type LifecycleWorkflowGate } 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 type { AgentCapabilityRouteDecision } from '../router/agent-runtime.js';
+import { evaluateAndRecordWorkflowGateDecision } from '../workflow-gate/evidence-packet.js';
+import type { WorkflowGateDecision, WorkflowGateStatus } from '../workflow-gate/types.js';
 
 const DEFAULT_TEST_TIMEOUT_MS = 120_000;
 const MAX_CAPTURE_BYTES = 256 * 1024;
@@ -53,20 +58,23 @@ interface NormalizedSddTestCommand {
   shell: boolean;
 }
 
-interface TestSyncBackProposal {
-  path: string;
-  digest: string;
-}
-
 type VerifyContractAction = 'none' | 'created' | 'refreshed' | 'blocked';
 
+type RuntimeTestJudgment = WorkflowGateStatus;
+
 export interface SddTestResult {
   contract: 'sdd-test-runtime-v1';
   runId: string;
   testRunId: string;
+  validationWaveRunId: string;
+  validationEnvironmentSessionId: string;
   branch: string;
   taskId: string;
   status: SddTestStatus;
+  validationStatus: SddTestStatus;
+  workflowGateStatus: WorkflowGateStatus;
+  runtimeJudgment: RuntimeTestJudgment;
+  workflowGateDecision: WorkflowGateDecision;
   verifyContractStatus: string;
   verifyContractAction: VerifyContractAction;
   lifecycleGate: LifecycleWorkflowGate;
@@ -78,6 +86,7 @@ export interface SddTestResult {
   evidenceCoverage: EvidenceCoverageStatus;
   policyJudgment: TestEvidenceStatus;
   acceptanceCoverage: AcceptanceEvidenceCoverage[];
+  capabilityEvidence: CapabilityEvidenceClassification[];
   syncBackReady: boolean;
   commands: string[];
   steps: SddTestCommandStep[];
@@ -95,18 +104,16 @@ export interface RunSddTestOptions {
   commandInputs?: SddTestCommandInput[];
   timeoutMs?: number;
   approved?: boolean;
+  validationWave?: { waveRunId: string; environmentSessionId: string; taskIds: string[]; acceptanceRefsByTask?: Record<string, string[]> };
 }
 
 export async function runSddTest(projectRoot: string, options: RunSddTestOptions): Promise<SddTestResult> {
   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');
@@ -114,6 +121,35 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
   const commands = commandInputs.map((input) => input.command);
   const gaps: string[] = [];
   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',
@@ -126,6 +162,7 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
     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') {
@@ -175,7 +212,7 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
   const steps: SddTestCommandStep[] = [];
   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',
@@ -187,18 +224,40 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
   }
 
   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): item is string => 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,
@@ -210,6 +269,7 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
     evidenceCoverage,
     policyJudgment,
     acceptanceCoverage,
+    capabilityEvidence,
     syncBackReady,
     commands,
     steps,
@@ -218,9 +278,6 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
   });
   const completedAt = new Date().toISOString();
   const evidence = [validationArtifact?.runRelativePath, indexArtifact.runRelativePath, ...steps.map((step) => step.outputArtifact)].filter((item): item is string => Boolean(item));
-  const syncBackProposal = syncBackReady
-    ? await writeTestSyncBackProposal(projectRoot, state.runId, options.taskId, evidence, acceptanceCoverage)
-    : null;
 
   await recordRuntimeTestRun(projectRoot, {
     testRunId,
@@ -230,7 +287,7 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
     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',
@@ -238,6 +295,9 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
     runId: state.runId,
     taskId: options.taskId,
     status,
+    validationStatus,
+    workflowGateStatus: gateDecision.status,
+    runtimeJudgment,
     lifecycleGate: workflowGate.lifecycleGate,
     primaryReason: workflowGate.primaryReason,
     evidence,
@@ -253,21 +313,52 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
     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,
@@ -279,16 +370,37 @@ export async function runSddTest(projectRoot: string, options: RunSddTestOptions
     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: string, waveRunId: string, testRunId: string, partition: string, runId: string, taskId: string, acceptanceCoverage: AcceptanceEvidenceCoverage[]): Promise<void> {
+  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: string, input: { taskId: string; stageRun: StageRun; status: SddTestStatus; completedAt: string; evidence: string[]; gaps: string[]; riskDecision: LifecycleRiskDecision }): Promise<void> {
   const outputRefs = input.evidence.map((ref) => ({ kind: 'artifact' as const, ref }));
   const completedStage: StageRun = {
@@ -324,20 +436,8 @@ async function recordTestWorkflowProjection(projectRoot: string, input: { taskId
 
 
 async function ensureVerifyContractForTest(projectRoot: string, branch: string): Promise<{ inspection: VerifyContractInspection; action: VerifyContractAction }> {
-  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: VerifyContractInspection): string {
@@ -369,8 +469,14 @@ export function renderSddTestResult(result: SddTestResult): string {
     '',
     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}`
@@ -485,31 +591,61 @@ function executeCommand(projectRoot: string, commandInput: NormalizedSddTestComm
   });
 }
 
-async function writeValidationArtifact(projectRoot: string, runId: string, task: SddTask, status: SddTestStatus, steps: SddTestCommandStep[], gaps: string[]): Promise<{ absolutePath: string; runRelativePath: string }> {
-  const artifactPath = `validation-${task.id}.md`;
+async function writeValidationArtifact(projectRoot: string, runId: string, task: SddTask, status: SddTestStatus, steps: SddTestCommandStep[], gaps: string[], capabilityEvidence: CapabilityEvidenceClassification[]): Promise<{ absolutePath: string; runRelativePath: string }> {
+  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: string, runId: string, taskId: string, artifacts: string[], acceptanceCoverage: AcceptanceEvidenceCoverage[]): Promise<TestSyncBackProposal> {
-  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: string, runId: string, payload: Omit<SddTestResult, 'contract' | 'runId' | 'indexArtifact' | 'next'>): Promise<{ absolutePath: string; runRelativePath: string }> {
   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: string, state: RunState, taskId: string, status: SddTestStatus, commands: string[], evidence: string[], validationArtifact: string | null, syncBackProposal: TestSyncBackProposal | null): Promise<void> {
+async function persistTestRunState(projectRoot: string, state: RunState, taskId: string, validationStatus: SddTestStatus, commands: string[], evidence: string[], validationArtifact: string | null): Promise<void> {
   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: string, runId: string, taskId: string, status: SddTestStatus, validationStatus: SddTestStatus, commands: string[], evidence: string[], validationArtifact: string | null, gateDecision: WorkflowGateDecision): Promise<void> {
+  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',
@@ -518,29 +654,72 @@ async function persistTestRunState(projectRoot: string, state: RunState, taskId:
     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: string): string {
+  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: RunStateTaskRuntime | undefined): RunStateTaskRuntime {
+  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: SddTestStatus): RunStateTaskRuntime['verificationStatus'] {
+  if (validationStatus === 'PASS') {
+    return 'pass';
+  }
+  return validationStatus === 'FAIL' ? 'failed' : 'blocked';
+}
+
+function runtimeTaskStatusAfterGate(status: SddTestStatus, validationStatus: SddTestStatus): string {
+  if (status === 'PASS') {
+    return 'implemented_verified';
+  }
+  if (validationStatus === 'PASS') {
+    return 'workflow_gate_blocked';
+  }
+  return validationStatus === 'FAIL' ? 'validation_failed' : 'validation_blocked';
+}
+
 function deriveCommandStatus(gaps: string[], steps: SddTestCommandStep[]): TestEvidenceStatus {
   if (gaps.length > 0 || steps.some((step) => step.status === 'blocked')) {
     return 'BLOCKED';
@@ -551,8 +730,8 @@ function deriveCommandStatus(gaps: string[], steps: SddTestCommandStep[]): TestE
   return 'PASS';
 }
 
-function buildAcceptanceCoverage(task: SddTask | null, steps: SddTestCommandStep[], commandStatus: TestEvidenceStatus): AcceptanceEvidenceCoverage[] {
-  const acceptanceRefs = task ? taskAcceptanceRefs(task) : [];
+function buildAcceptanceCoverage(task: SddTask | null, steps: SddTestCommandStep[], commandStatus: TestEvidenceStatus, acceptanceRefsOverride: string[] | undefined): AcceptanceEvidenceCoverage[] {
+  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');
@@ -566,7 +745,7 @@ function buildAcceptanceCoverage(task: SddTask | null, steps: SddTestCommandStep
       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.`]
     };
   });
 }
@@ -594,7 +773,72 @@ function derivePolicyJudgment(commandStatus: TestEvidenceStatus, evidenceCoverag
   return 'PASS';
 }
 
-function buildUnifiedTestEvidenceRun(id: string, branch: string, runId: string, taskId: string, commandStatus: TestEvidenceStatus, evidenceCoverage: EvidenceCoverageStatus, policyJudgment: TestEvidenceStatus, steps: SddTestCommandStep[], acceptanceCoverage: AcceptanceEvidenceCoverage[], syncBackReady: boolean, gaps: string[]): UnifiedTestEvidenceRun {
+async function resolveTestRuntimeDurableGap(
+  projectRoot: string,
+  branch: string,
+  runId: string,
+  taskId: string,
+  validationStatus: SddTestStatus,
+  gaps: string[]
+): Promise<void> {
+  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: string,
+  branch: string,
+  runId: string,
+  taskId: string,
+  status: SddTestStatus,
+  validationStatus: SddTestStatus,
+  runtimeJudgment: WorkflowGateStatus,
+  gaps: string[],
+  evidenceRefs: string[]
+): Promise<void> {
+  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: string, _runId: string, taskId: string): string {
+  return runtimeScopedId(branch, taskId, 'test-runtime-gap');
+}
+
+function finalStatusForTest(validationStatus: SddTestStatus, runtimeJudgment: WorkflowGateStatus): SddTestStatus {
+  if (validationStatus !== 'PASS') {
+    return validationStatus;
+  }
+  return runtimeJudgment === 'PASS' ? 'PASS' : 'BLOCKED';
+}
+
+function buildUnifiedTestEvidenceRun(id: string, branch: string, runId: string, taskId: string, commandStatus: TestEvidenceStatus, evidenceCoverage: EvidenceCoverageStatus, policyJudgment: TestEvidenceStatus, status: SddTestStatus, runtimeJudgment: WorkflowGateStatus, steps: SddTestCommandStep[], acceptanceCoverage: AcceptanceEvidenceCoverage[], capabilityEvidence: CapabilityEvidenceClassification[], syncBackReady: boolean, gaps: string[], gateNextAction: string | null, gateDecision: WorkflowGateDecision | null): UnifiedTestEvidenceRun {
   return {
     contract: TEST_EVIDENCE_RUN_CONTRACT_VERSION,
     id,
@@ -612,26 +856,104 @@ function buildUnifiedTestEvidenceRun(id: string, branch: string, runId: string,
       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: SddTestStatus, branch: string, taskId: string, runId: string, indexArtifact: string, gateNextAction: string | null): string {
+function buildCapabilityEvidenceClassification(decision: AgentCapabilityRouteDecision | null, steps: SddTestCommandStep[]): CapabilityEvidenceClassification[] {
+  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' as const,
+    source: 'professional_capability' as const,
+    domainOrSourceId: domain.domain,
+    evidenceRefs: [],
+    acceptanceRefs,
+    provenanceRefs: [{ kind: 'projection' as const, 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) as CapabilityEvidenceClassification['class'],
+    source: 'external_source' as const,
+    domainOrSourceId: source.sourceId,
+    evidenceRefs: [],
+    acceptanceRefs: [],
+    provenanceRefs: [{ kind: 'external' as const, ref: source.sourceId }],
+    reason: source.reason
+  }));
+  return [...professionalEvidence, ...externalEvidence];
+}
+
+function capabilityClassForRejectedSource(status: AgentCapabilityRouteDecision['rejectedExternalSources'][number]['quarantineStatus']): CapabilityEvidenceClassification['class'] {
+  if (status === 'denied') {
+    return 'blocked';
+  }
+  if (status === 'required' || status === 'quarantined') {
+    return 'quarantined';
+  }
+  return 'diagnostic';
+}
+
+function renderCapabilityEvidenceClassification(items: CapabilityEvidenceClassification[]): string {
+  if (items.length === 0) {
+    return '- none';
+  }
+  return items.map((item) => `- [${item.class}] ${item.source}:${item.domainOrSourceId} — ${item.reason}`).join('\n');
+}
+
+function capabilityEvidenceSummary(items: CapabilityEvidenceClassification[]): string {
+  if (items.length === 0) {
+    return 'none';
+  }
+  const counts = new Map<CapabilityEvidenceClassification['class'], number>();
+  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: SddTestStatus, runtimeJudgment: WorkflowGateStatus, branch: string, taskId: string, _runId: string, indexArtifact: string, gateNextAction: string | null, gateDecision: WorkflowGateDecision | null): string {
   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}.`;
   }
-  return gateNextAction ?? `Inspect ${indexArtifact}, fix command/evidence gaps, 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}.`;
+  }
+  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: SddTestResult): string {
-  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.';
@@ -677,7 +999,10 @@ function normalizeTestCommandInput(input: SddTestCommandInput): NormalizedSddTes
   throw new Error('Command input must include command or argv.');
 }
 
-function acceptanceRefsForCommand(task: SddTask | null, command: string): string[] {
+function acceptanceRefsForCommand(task: SddTask | null, command: string, acceptanceRefsOverride: string[] | undefined): string[] {
+  if (acceptanceRefsOverride && acceptanceRefsOverride.length > 0) {
+    return [...new Set(acceptanceRefsOverride)];
+  }
   return [...new Set((task?.validationCommands ?? [])
     .filter((entry) => entry.command === command)
     .flatMap((entry) => entry.acceptanceRefs))];