sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -1,492 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { initProject } from '../config/init-project.js';
-import { validResultArtifact, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
-import { listRuntimeTestRuns, listRuntimeTestSteps } from '../storage/runtime-store.js';
-import { readRunState } from '../run-state/run-state.js';
-import { readArtifact, writeArtifact } from '../run-state/artifacts.js';
-import { listInvocationLedgerEntries } from '../run-state/invocation-ledger.js';
-import { writeVerifyContract } from './verify-contract.js';
-import { renderSddTestResult, runSddTest } from './test-runtime.js';
-import { runGoalVerify } from './goal-verify.js';
-import { routeSddTask } from '../router/route-sdd-task.js';
-import { doctor } from '../doctor/doctor.js';
-import { getProjectStatus } from '../status/project-status.js';
-import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
-import { parseSddBranch } from '../sdd-docs/task-parser.js';
-import { getBranchStageEvidencePathFromRef } from '../runtime-paths.js';
-
-function mappedValidationTaskMarkdown(taskId: string, command: string): string {
-  return `# Tasks
-
-### ${taskId}: Mapped validation task
-
-\`\`\`sdd-task
-id: ${taskId}
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-1
-plan_refs:
-  - "§4 Target Design Overview"
-affected_files:
-  - docs/${taskId.toLowerCase()}.md
-validation:
-  - ${command} => AC-1
-risk: []
-\`\`\`
-
-#### Boundary
-
-Stay in validation runtime fixtures only.
-
-#### Acceptance
-
-- AC-1: Parser behavior is covered.
-`;
-}
-
-function mappedValidationTaskWithRequiredArtifactsMarkdown(taskId: string, command: string): string {
-  return mappedValidationTaskMarkdown(taskId, command).replace('risk: []', `risk: []\nrequired_artifacts:\n  - .sdd/runs/feature/do/implementation-${taskId}.md\n  - .sdd/runs/feature/test/test-validation-${taskId}.md`);
-}
-
-function capabilityMappedValidationTaskMarkdown(taskId: string, command: string): string {
-  return mappedValidationTaskMarkdown(taskId, command).replace('risk: []', 'risk:\n  - security');
-}
-
-function sourceBoundaryMappedValidationTaskMarkdown(taskId: string, command: string): string {
-  return mappedValidationTaskMarkdown(taskId, command).replace(
-    `docs/${taskId.toLowerCase()}.md`,
-    'packages/core/src/index.ts'
-  );
-}
-
-function directSafeTaskMarkdown(taskId: string): string {
-  return validTaskMarkdown(taskId, []).replace('packages/core/src/index.ts', `docs/${taskId.toLowerCase()}.md`);
-}
-
-test('runSddTest records PASS command metadata without default log or index artifacts', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-pass-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', directSafeTaskMarkdown('T1'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.commandStatus, 'PASS');
-    assert.equal(result.evidenceCoverage, 'missing');
-    assert.equal(result.policyJudgment, 'BLOCKED');
-    assert.equal(result.steps.length, 1);
-    assert.equal(result.validationArtifact, '.sdd/runs/feature/test/test-validation-T1.md');
-    assert.equal(result.indexArtifact, null);
-    assert.equal(result.capabilityEvidence.length > 0, true);
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'accepted'), false);
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'quarantined' && item.source === 'external_source'), true);
-    assert.match(renderSddTestResult(result), /capability_evidence=/);
-
-    const state = await readRunState(root, result.runId);
-    assert.equal(state.phase, 'test');
-    assert.equal(state.validation.status, 'blocked');
-    assert.equal(state.validation.evidence.includes('.sdd/runs/feature/test/test-validation-T1.md'), true);
-    assert.equal(state.tasks.T1?.implementationStatus, 'not_started');
-
-    const validation = await readArtifact(root, result.runId, 'test-validation-T1.md');
-    assert.equal(await readFile(getBranchStageEvidencePathFromRef(root, '.sdd/runs/feature/test/test-validation-T1.md'), 'utf8'), validation);
-    assert.match(validation, /```sdd-result/);
-    assert.doesNotMatch(validation, /```sdd-evidence/);
-    assert.match(validation, /not explicitly mapped/);
-    assert.doesNotMatch(validation, /## Capability Evidence Classification/);
-    const ledger = await listInvocationLedgerEntries(root, result.runId);
-    assert.equal(ledger.some((entry) => entry.kind === 'command' && entry.ref === 'node -e "process.stdout.write(\'ok\')"' && entry.status === 'pass'), true);
-
-    await assert.rejects(readdir(path.join(root, '.sdd', 'runs', 'feature', 'evidence')));
-    await writeArtifact(root, result.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', '.sdd/runs/feature/do/review-T1.md'));
-    const verify = await runGoalVerify(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      runId: result.runId,
-      reviewArtifact: '.sdd/runs/feature/do/review-T1.md',
-      validationArtifact: result.validationArtifact ?? undefined
-    });
-    assert.equal(verify.status, 'BLOCKED');
-    assert.deepEqual(verify.acceptanceCoverage.map((item) => item.status), ['MISSING']);
-
-    const testRuns = await listRuntimeTestRuns(root, result.runId);
-    assert.equal(testRuns.length, 1);
-    assert.equal(testRuns[0].status, 'BLOCKED');
-    const testSteps = await listRuntimeTestSteps(root, { runId: result.runId });
-    assert.equal(testSteps.length, 1);
-    assert.equal(testSteps[0].status, 'pass');
-    assert.equal(testSteps[0].outputArtifact, null);
-    assert.match((testSteps[0].payload as { stdoutDigest: string }).stdoutDigest, /^[a-f0-9]{64}$/);
-    assert.match((testSteps[0].payload as { stderrDigest: string }).stderrDigest, /^[a-f0-9]{64}$/);
-    assert.match((testSteps[0].payload as { startedAt: string }).startedAt, /^\d{4}-\d{2}-\d{2}T/);
-    assert.match((testSteps[0].payload as { endedAt: string }).endedAt, /^\d{4}-\d{2}-\d{2}T/);
-    assert.equal((testSteps[0].payload as { cwd: string }).cwd, root);
-    assert.match((testSteps[0].payload as { outputSummary: string }).outputSummary, /stdout_bytes=2/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest writes validator evidence to declared required validation artifact', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-required-artifact-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', mappedValidationTaskWithRequiredArtifactsMarkdown('REQ', 'node -e "process.stdout.write(\'ok\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'REQ',
-      approved: true,
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-
-    assert.equal(result.validationArtifact, '.sdd/runs/feature/test/test-validation-REQ.md');
-    assert.equal(result.workflowGateDecision.hardBlocks.some((block) => block.code === 'missing_required_artifact' && block.refs.includes('.sdd/runs/feature/test/test-validation-REQ.md')), false);
-    assert.equal(result.workflowGateDecision.hardBlocks.some((block) => block.code === 'missing_required_artifact' && block.refs.includes('.sdd/runs/feature/do/implementation-REQ.md')), true);
-    const validation = await readArtifact(root, result.runId, 'test-validation-REQ.md');
-    assert.match(validation, /runs\/feature\/test\/test-validation-REQ\.md/);
-    await assert.rejects(readdir(path.join(root, '.sdd', 'runs', 'feature', 'evidence')));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest executes argv commands without shell and records argv evidence', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-argv-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', directSafeTaskMarkdown('T1'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      commandInputs: [{ argv: [process.execPath, '-e', 'process.stdout.write(process.argv[1])', 'literal;not-shell'] }]
-    });
-
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.commandStatus, 'PASS');
-    assert.equal(result.steps[0].shell, false);
-    assert.deepEqual(result.steps[0].argv, [process.execPath, '-e', 'process.stdout.write(process.argv[1])', 'literal;not-shell']);
-
-    const testSteps = await listRuntimeTestSteps(root, { runId: result.runId });
-    assert.equal(testSteps.length, 1);
-    assert.equal(testSteps[0].outputArtifact, null);
-    assert.equal((testSteps[0].payload as { shell: boolean }).shell, false);
-    assert.deepEqual((testSteps[0].payload as { argv: string[] }).argv, [process.execPath, '-e', 'process.stdout.write(process.argv[1])', 'literal;not-shell']);
-    assert.match((testSteps[0].payload as { outputSummary: string }).outputSummary, /stdout_bytes=17/);
-    const ledger = await listInvocationLedgerEntries(root, result.runId);
-    const commandEntry = ledger.find((entry) => entry.kind === 'command' && entry.status === 'pass');
-    assert.equal(commandEntry?.metadata.shell, false);
-    assert.equal(commandEntry?.metadata.argv, JSON.stringify([process.execPath, '-e', 'process.stdout.write(process.argv[1])', 'literal;not-shell']));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest blocks on missing verify contract without creating it', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-missing-verify-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', mappedValidationTaskMarkdown('T1', 'node -e "process.stdout.write(\'ok\')"'));
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-
-    await assert.rejects(readFile(path.join(root, 'specs', 'feature', 'verify.md'), 'utf8'));
-    assert.equal(result.verifyContractStatus, 'BLOCKED');
-    assert.equal(result.verifyContractAction, 'blocked');
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.steps.length, 0);
-    assert.match(result.gaps.join('\n'), /Verification contract document is missing/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest ignores legacy verify hash metadata and executes validation', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-legacy-verify-hash-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', mappedValidationTaskMarkdown('T1', 'node -e "process.stdout.write(\'ok\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    const verifyPath = path.join(root, 'specs', 'feature', 'verify.md');
-    const verifyWithLegacyMetadata = (await readFile(verifyPath, 'utf8')).replace('author_role: verification-designer', 'based_on_tasks_contract_hash: legacy\nbased_on_tasks_hash: legacy\nauthor_role: verification-designer');
-    await writeFile(verifyPath, verifyWithLegacyMetadata, 'utf8');
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-    const verify = await readFile(verifyPath, 'utf8');
-
-    assert.equal(result.verifyContractStatus, 'PASS');
-    assert.equal(result.commandStatus, 'PASS');
-    assert.equal(result.status, 'PASS');
-    assert.equal(result.steps.length, 1);
-    assert.match(verify, /based_on_tasks_contract_hash: legacy/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest produces validator evidence accepted by goal verify', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-verify-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', mappedValidationTaskMarkdown('T1', 'node -e "process.stdout.write(\'ok\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-    await writeArtifact(root, result.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', '.sdd/runs/feature/do/review-T1.md'));
-    const verify = await runGoalVerify(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      runId: result.runId,
-      reviewArtifact: '.sdd/runs/feature/do/review-T1.md',
-      validationArtifact: result.validationArtifact ?? undefined
-    });
-
-    assert.equal(verify.status, 'PASS');
-    assert.equal(verify.acceptanceCoverage.every((item) => item.status === 'PASS'), true);
-    assert.equal(result.evidenceCoverage, 'complete');
-    assert.equal(result.policyJudgment, 'PASS');
-    assert.equal(result.capabilityEvidence.length > 0, true);
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'accepted'), false);
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'quarantined' && item.source === 'external_source'), true);
-    assert.equal(result.indexArtifact, null);
-    assert.match(result.next, /^sdd test close --branch feature --target goal-verify --compact-json$/);
-    assert.deepEqual(verify.plannedCommands, ['node -e "process.stdout.write(\'ok\')"']);
-    assert.deepEqual(verify.executedCommands, ['node -e "process.stdout.write(\'ok\')"']);
-    const coverage = await readArtifact(root, result.runId, 'acceptance-coverage-T1.md');
-    assert.match(coverage, /## Planned Validation Commands/);
-    assert.match(coverage, /## Executed Runtime Commands/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest exposes candidate capability evidence without making it authoritative', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-capability-evidence-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', capabilityMappedValidationTaskMarkdown('CAPABILITY', 'node -e "process.stdout.write(\'ok\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'CAPABILITY',
-      approved: true,
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-
-    assert.equal(result.status, 'PASS');
-    assert.equal(result.policyJudgment, 'PASS');
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'candidate' && item.source === 'professional_capability' && item.domainOrSourceId === 'security-engineering'), true);
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'accepted'), false);
-    assert.equal(result.capabilityEvidence.some((item) => item.class === 'quarantined' && item.source === 'external_source'), true);
-    assert.equal(result.indexArtifact, null);
-    const validation = await readArtifact(root, result.runId, 'test-validation-CAPABILITY.md');
-    assert.doesNotMatch(validation, /professional_capability:security-engineering/);
-    assert.doesNotMatch(validation, /## Capability Evidence Classification/);
-    const status = await getProjectStatus(root, { branch: 'feature' });
-    assert.equal(status.capabilityHealth.activeDomains.includes('security-engineering'), false);
-    assert.equal(status.capabilityHealth.releaseCriticalGaps.includes('security-engineering'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest records failing commands without promoting verification pass', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-fail-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', directSafeTaskMarkdown('T1'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'T1',
-      commands: ['node -e "process.exit(2)"']
-    });
-
-    assert.equal(result.status, 'FAIL');
-    assert.equal(result.steps[0].exitCode, 2);
-    const state = await readRunState(root, result.runId);
-    assert.equal(state.status, 'failed');
-    assert.equal(state.validation.status, 'fail');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest blocks source-boundary validation before command execution', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-source-gate-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', sourceBoundaryMappedValidationTaskMarkdown('SOURCE', 'node -e "process.stdout.write(\'should-not-run\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'SOURCE',
-      commands: ['node -e "process.stdout.write(\'should-not-run\')"']
-    });
-
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.lifecycleGate, 'review-before-test');
-    assert.equal(result.commandStatus, 'BLOCKED');
-    assert.equal(result.steps.length, 0);
-    assert.match(result.primaryReason, /source, runtime state, API\/schema/);
-    assert.match(result.primaryReason, /review before validation/);
-    assert.match(result.next, /reviewer inspect affected files and validation commands/);
-    const rendered = renderSddTestResult(result);
-    assert.match(rendered, /Blocked before validation commands ran\./);
-    assert.match(rendered, /Why:\n- Task SOURCE touches source, runtime state, API\/schema/);
-    assert.match(rendered, /Next:\n- Have a reviewer inspect affected files and validation commands for SOURCE/);
-    const ledger = await listInvocationLedgerEntries(root, result.runId);
-    assert.equal(ledger.some((entry) => entry.kind === 'command'), false);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest allows source-boundary validation after reviewer checkpoint passes', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-source-review-pass-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', sourceBoundaryMappedValidationTaskMarkdown('SOURCE', 'node -e "process.stdout.write(\'ok\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const blocked = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'SOURCE',
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-    assert.equal(blocked.status, 'BLOCKED');
-    assert.equal(blocked.lifecycleGate, 'review-before-test');
-    assert.equal(blocked.steps.length, 0);
-
-    await writeArtifact(root, blocked.runId, 'review-SOURCE.md', validResultArtifact('reviewer', 'SOURCE', 'PASS', '.sdd/runs/feature/do/review-SOURCE.md'));
-    const result = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'SOURCE',
-      runId: blocked.runId,
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-
-    assert.equal(result.status, 'PASS');
-    assert.equal(result.lifecycleGate, 'review-before-test');
-    assert.equal(result.commandStatus, 'PASS');
-    assert.equal(result.steps.length, 1);
-    assert.match(result.next, /^sdd test close --branch feature --target goal-verify --compact-json$/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('runSddTest replaces stale blocked handoff after retry pass', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-handoff-retry-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', sourceBoundaryMappedValidationTaskMarkdown('SOURCE', 'node -e "process.stdout.write(\'ok\')"'));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const blocked = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'SOURCE',
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-    assert.equal(blocked.status, 'BLOCKED');
-
-    await writeArtifact(root, blocked.runId, 'review-SOURCE.md', validResultArtifact('reviewer', 'SOURCE', 'PASS', '.sdd/runs/feature/do/review-SOURCE.md'));
-    const passed = await runSddTest(root, {
-      branch: 'feature',
-      taskId: 'SOURCE',
-      runId: blocked.runId,
-      commands: ['node -e "process.stdout.write(\'ok\')"']
-    });
-    const report = await doctor(root, { latestOnly: true, branch: 'feature' });
-
-    const handoffCheck = report.checks.find((check) => check.check === 'workflow_handoff_state');
-
-    assert.equal(passed.status, 'PASS');
-    assert.notEqual(handoffCheck?.level, 'FAIL');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-
-test('runSddTest blocks downstream validation until dependencies are completed', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-runtime-dependencies-'));
-  try {
-    await initProject(root);
-    const dep2 = mappedValidationTaskMarkdown('DEP2', 'node -e "process.stdout.write(\'should-not-run\')"')
-      .replace('depends_on: []', 'depends_on:\n  - DEP1');
-    await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', [])}\n${dep2}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await seedLifecycleRiskDecision(root, 'feature');
-
-    const blockedRoute = await routeSddTask(root, { branch: 'feature', taskId: 'DEP2', approved: true });
-    const blocked = await runSddTest(root, { branch: 'feature', taskId: 'DEP2', approved: true });
-
-    assert.equal(blockedRoute.category, 'blocked');
-    assert.match(blockedRoute.blockedReason ?? '', /DEP2 depends on DEP1, but DEP1 has not passed required verification/);
-    assert.equal(blocked.status, 'BLOCKED');
-    assert.equal(blocked.steps.length, 0);
-    assert.equal(blocked.commandStatus, 'BLOCKED');
-    assert.match(blocked.gaps.join('\n'), /DEP2 depends on DEP1, but DEP1 has not passed required verification/);
-
-    await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', []).replace('status: pending', 'status: completed')}\n${dep2}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option', force: true });
-    await seedLifecycleRiskDecision(root, 'feature');
-    const readyRoute = await routeSddTask(root, { branch: 'feature', taskId: 'DEP2' });
-    const ready = await runSddTest(root, { branch: 'feature', taskId: 'DEP2' });
-
-    assert.notEqual(readyRoute.category, 'blocked');
-    assert.equal(readyRoute.blockedReason, null);
-    assert.equal(ready.steps.length, 1);
-    assert.equal(ready.status, 'PASS');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
-  const model = await parseSddBranch(root, branch);
-  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
-}