sdd-agent-platform 0.4.0 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/stage-collaboration.test.ts

@@ -0,0 +1,2903 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { access, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { LIFECYCLE_RISK_DECISION_CONTRACT_VERSION, STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION, VERIFY_DOCUMENT_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION, type RuntimeRef, type RuntimeRefKind, type SddStage } from './contracts.js';
+import type { LifecycleRiskDecision } from './risk/contracts.js';
+import { initProject } from './config/init-project.js';
+import {
+  adjudicateSpecStageClosureRequest,
+  buildDoStageWorkOrder,
+  buildGoalVerifyStageWorkOrder,
+  buildPlanStageWorkOrder,
+  buildShipStageWorkOrder,
+  buildSpecStageWorkOrder,
+  buildTasksStageWorkOrder,
+  buildTestStageWorkOrder,
+  buildVerifiesStageWorkOrder,
+  deriveSpecCollaborationProfile,
+  inspectFullStageChain,
+  inspectSpecCollaborationHealth,
+  reconcileDoCollaborationClosure,
+  reconcileGoalVerifyCollaborationClosure,
+  reconcileShipCollaborationClosure,
+  reconcilePlanCollaborationClosure,
+  reconcileTasksCollaborationClosure,
+  reconcileTestCollaborationClosure,
+  reconcileVerifiesCollaborationClosure,
+  reconcileSpecCollaborationClosure,
+  readTruthAlignmentProjection,
+  recordSpecCollaborationAdjudicationProjection,
+  type CapabilityFinding,
+  type SpecDocumentCandidate,
+  type SpecManagerCoordinationRecord,
+  type SpecProposalItemKind,
+  type SpecReviewResult,
+  type StageClosureRequest,
+  type StageCollaborationProfile
+} from './stage-collaboration.js';
+import { inspectWorkflowStageHandoff, readStageRunProjection, readWorkflowHandoffProjection, recordStageRunProjection, recordWorkflowHandoffProjection } from './stage-runtime/runtime.js';
+import { hashDocumentContent } from './sdd-docs/document-hashes.js';
+import { listRuntimeStageArtifacts, listRuntimeStageCollaborationContracts, recordRuntimeStageArtifact } from './storage/runtime-store.js';
+import { expectedStageArtifactContracts, readMarkdownArtifact, validateStageArtifactFrontmatter } from './stage-artifacts.js';
+
+const generatedAt = '2026-01-01T00:00:00.000Z';
+
+test('direct lifecycle keeps spec collaboration as runtime no-op', () => {
+  const profile = deriveSpecCollaborationProfile(decision('direct', ['do', 'test']), generatedAt);
+  const result = adjudicateSpecStageClosureRequest({ profile, generatedAt });
+
+  assert.equal(profile.contract, STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION);
+  assert.equal(profile.intensity, 'noop');
+  assert.equal(profile.required, false);
+  assert.equal(profile.requiresStageClosure, false);
+  assert.equal(result.health, 'no-op');
+  assert.equal(result.stageDecision?.status, 'skipped');
+  assert.equal(result.handoffPacket, null);
+});
+
+test('full lifecycle creates spec-manager work order with agent-team proposal-only authority', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  const workOrder = buildSpecStageWorkOrder(profile, ref('projection', 'profile/spec'), generatedAt);
+
+  assert.equal(profile.intensity, 'team-required');
+  assert.equal(profile.required, true);
+  assert.equal(profile.requiresStageClosure, true);
+  assert.equal(workOrder.authorityCeiling, 'proposal_input');
+  assert.deepEqual(workOrder.forbiddenActions, ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved']);
+  assert.equal(workOrder.stageManager, 'spec-manager');
+  assert.deepEqual(workOrder.agentTeam, ['scout', 'spec-drafter', 'spec-reviewer']);
+  assert.deepEqual(workOrder.requiredCapabilities, ['norm_discovery', 'uncertainty_resolution']);
+  assert.equal(workOrder.collaborationPlan.topology, 'team-required');
+  assert.equal(workOrder.collaborationPlan.fanIn, 'runtime_adjudication');
+  assert.equal(workOrder.collaborationPlan.participants.some((participant) => participant.kind === 'agent' && participant.id === 'spec-manager'), true);
+  assert.equal(workOrder.collaborationPlan.participants.some((participant) => participant.kind === 'subagent' && participant.id === 'spec-reviewer' && participant.role === 'spec-document-reviewer'), true);
+  assert.equal(workOrder.collaborationPlan.participants.some((participant) => participant.kind === 'subagent' && participant.id === 'scout' && participant.parallelGroup === 'discovery'), true);
+  assert.equal(workOrder.collaborationPlan.participants.some((participant) => participant.kind === 'skill' && participant.id === 'cap.norm_discovery'), true);
+  assert.equal(workOrder.collaborationPlan.participants.some((participant) => participant.kind === 'material-pack' && participant.id === 'project-norms'), true);
+});
+
+test('stage run projection keeps completed stage from being downgraded by later rejected diagnostics', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-run-terminal-'));
+  try {
+    await initProject(root);
+    const scope = { branch: 'feature' };
+    const completed = testStageRun('do-completed', scope, 'completed', '2026-01-01T00:00:00.000Z');
+    const rejected = testStageRun('do-rejected', scope, 'failed', '2026-01-01T00:01:00.000Z');
+
+    await recordStageRunProjection(root, completed);
+    const result = await recordStageRunProjection(root, rejected);
+    const stored = await readStageRunProjection(root, scope, 'do');
+
+    assert.equal(result.status, 'unchanged');
+    assert.equal(stored?.payload.id, completed.id);
+    assert.equal(stored?.payload.status, 'completed');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('blocking ambiguity produces clarification gate instead of handoff', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  const team = stageClosure(profile, { items: [candidateItem('amb-1', 'blocking_ambiguity')] });
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest: team.closureRequest, generatedAt });
+
+  assert.equal(result.health, 'needs_clarification');
+  assert.equal(result.clarificationGate?.status, 'needs_clarification');
+  assert.deepEqual(result.clarificationGate?.blockingItemIds, ['amb-1']);
+  assert.equal(result.stageDecision, null);
+  assert.equal(result.handoffPacket, null);
+  assert.equal(profile.collaborationPlan.topology, 'team-required');
+});
+
+test('answered clarification becomes spec decision and spec to plan handoff', () => {
+  const profile = deriveSpecCollaborationProfile(decision('research', ['spec', 'plan', 'verifies']), generatedAt);
+  const team = stageClosure(profile, { items: [candidateItem('amb-1', 'blocking_ambiguity'), candidateItem('find-1', 'advisory_finding')] });
+  const result = adjudicateSpecStageClosureRequest({
+    profile,
+    closureRequest: team.closureRequest,
+    answerRefs: [ref('external', 'answer/spec-ambiguity')],
+    generatedAt
+  });
+
+  assert.equal(result.health, 'ready_for_plan');
+  assert.equal(result.specDecisionRecord?.source, 'clarification-answer');
+  assert.deepEqual(result.specDecisionRecord?.acceptedItemIds, ['amb-1', 'find-1']);
+  assert.equal(result.stageDecision?.status, 'completed');
+  assert.equal(result.handoffPacket?.fromStage, 'spec');
+  assert.equal(result.handoffPacket?.toStage, 'plan');
+  assert.deepEqual(result.handoffPacket?.recommendedNextStageRoles, ['role.norm-scout', 'role.uncertainty-reviewer']);
+  assert.equal(profile.collaborationPlan.topology, 'parallel-research');
+});
+
+test('valid stage closure is accepted into runtime-owned stage decision and handoff', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  const team = stageClosure(profile);
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest: team.closureRequest, generatedAt });
+
+  assert.equal(result.health, 'ready_for_plan');
+  assert.deepEqual(result.acceptedItemIds, ['find-1', 'cap-1', 'handoff-1']);
+  assert.equal(result.specDecisionRecord?.source, 'stage-closure-request');
+  assert.equal(result.stageDecision?.health, 'ready_for_plan');
+  assert.equal(result.handoffPacket?.status, 'proposed');
+  assert.deepEqual(result.handoffPacket?.recommendedNextStageRoles, ['role.norm-scout', 'role.performance-planner', 'role.verification-designer']);
+});
+
+test('authority-violating closure request is rejected with actionable metadata', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  const team = stageClosure(profile, { authorityAttempts: ['stage_pass'] });
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest: team.closureRequest, generatedAt, retryBudgetRemaining: 2 });
+
+  assert.equal(result.health, 'rejected');
+  assert.equal(result.rejection?.reasonCode, 'authority_violation');
+  assert.equal(result.rejection?.retryAllowed, true);
+  assert.equal(result.rejection?.retryBudgetRemaining, 2);
+  assert.equal(result.rejection?.fallbackRoute, 'revise-proposal');
+  assert.match(result.rejection?.requiredNextAction ?? '', /Remove workflow-authority/);
+});
+
+test('candidate items must carry refs', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  const team = stageClosure(profile, { items: [candidateItem('find-1', 'advisory_finding', [])] });
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest: team.closureRequest, generatedAt });
+
+  assert.equal(result.health, 'rejected');
+  assert.equal(result.rejection?.reasonCode, 'missing_refs');
+});
+
+test('missing spec-reviewer result returns prioritized stage-manager next action', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  const team = stageClosure(profile);
+  const closureRequest = { ...team.closureRequest, reviewRefs: [], reviewResults: [] };
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest, generatedAt });
+
+  assert.equal(result.health, 'rejected');
+  assert.equal(result.rejection?.reasonCode, 'missing_required_review');
+  assert.equal(result.nextActions[0]?.reasonCode, 'missing_required_review');
+  assert.equal(result.nextActions[0]?.owner, 'stage-manager');
+  assert.equal(result.nextActions[0]?.kind, 'collect_required_review');
+});
+
+test('spec collaboration adjudication projection exposes compact health', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-collaboration-'));
+  try {
+    await initProject(root);
+    const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+    const team = stageClosure(profile);
+    const result = adjudicateSpecStageClosureRequest({ profile, closureRequest: team.closureRequest, generatedAt });
+
+    await recordSpecCollaborationAdjudicationProjection(root, result);
+    const health = await inspectSpecCollaborationHealth(root, 'master');
+
+    assert.equal(health.status, 'ready_for_plan');
+    assert.equal(health.projectionCount, 1);
+    assert.equal(health.latestHandoffId, result.handoffPacket?.handoffId);
+    assert.equal(health.latestClarificationGateId, null);
+    assert.equal(health.latestRejectionReason, null);
+    assert.match(health.reasons.join(' '), /ready for plan handoff/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('full-stage chain diagnostic reports missing projections before stage closure', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-full-chain-missing-'));
+  try {
+    await initProject(root);
+    const chain = await inspectFullStageChain(root, 'master');
+
+    assert.equal(chain.contract, 'sdd-full-stage-chain-diagnostic-v1');
+    assert.equal(chain.status, 'missing');
+    assert.equal(chain.stages.length, 8);
+    assert.equal(chain.projectionCounts.adjudications, 0);
+    assert.equal(chain.projectionCounts.completedStages, 0);
+    assert.equal(chain.projectionCounts.validatedCollaborationContracts, 0);
+    assert.equal(chain.finalHealth, null);
+    assert.equal(chain.stages.every((stage) => stage.projectionRef === null), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready closure accepts reviewed spec document, agent-authored evidence, and sqlite projections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-closure-ready-'));
+  try {
+    await initProject(root);
+    const reviewedSpecContent = reviewedSpec();
+    const specHash = hashDocumentContent(reviewedSpecContent);
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), reviewedSpecContent, 'utf8');
+    await writeSpecStageArtifacts(root, { specHash });
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ready-closure'
+    });
+    const specContent = await readFile(path.join(root, 'specs', 'master', 'spec.md'), 'utf8');
+    const health = await inspectSpecCollaborationHealth(root, 'master');
+    const handoff = await inspectWorkflowStageHandoff(root, 'master');
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'spec' });
+    const registeredContracts = await listRuntimeStageCollaborationContracts(root, { branchSlug: 'master', stage: 'spec' });
+
+    assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedSpecRef?.ref, 'specs/master/spec.md');
+    assert.equal(closure.acceptedSpecRef?.hash, specHash);
+    assert.equal(specContent, reviewedSpecContent);
+    assert.equal(closure.artifactRefs.every((artifact) => artifact.ref.startsWith('.sdd/runs/master/spec/')), true);
+    assert.equal(closure.artifactRefs.some((artifact) => artifact.ref.startsWith(['artifacts', 'phase9.1'].join('/'))), false);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', 'scout_context', 'spec_review']);
+    assert.equal(registeredContracts.length, 1);
+    assert.equal(registeredContracts[0]?.status, 'validated');
+    assert.equal(closure.registeredCollaborationContracts[0]?.ref, '.sdd/runs/master/spec/spec-collaboration-contract-v1.md');
+    assert.equal(closure.adjudication.closureRefs?.collaborationContractRef?.ref, '.sdd/runs/master/spec/spec-collaboration-contract-v1.md');
+    assert.equal(health.status, 'ready_for_plan');
+    assert.equal(health.latest?.closureRefs?.runRef.ref, 'run-ready-closure');
+    assert.equal(health.latest?.closureRefs?.acceptedSpecRef?.ref, 'specs/master/spec.md');
+    assert.equal(handoff.status, 'fresh');
+    assert.equal(handoff.latestStageRun?.status, 'completed');
+    assert.equal(handoff.latestHandoff?.requiredInputRefs[0]?.ref, 'specs/master/spec.md');
+    assert.equal(handoff.latestHandoff?.requiredInputRefs[0]?.hash, specHash);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.1')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready structural closure rejects missing collaboration contract without handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-closure-missing-contract-'));
+  try {
+    await initProject(root);
+    const reviewedSpecContent = reviewedSpec();
+    const specHash = hashDocumentContent(reviewedSpecContent);
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), reviewedSpecContent, 'utf8');
+    await writeSpecStageArtifacts(root, { specHash, omitContract: true });
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-missing-contract-closure'
+    });
+    const handoff = await inspectWorkflowStageHandoff(root, 'master');
+    const registeredContracts = await listRuntimeStageCollaborationContracts(root, { branchSlug: 'master', stage: 'spec' });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'invalid_proposal');
+    assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'not_accepted_wrong_ref');
+    assert.equal(closure.adjudication.closureRefs?.collaborationContractRef, null);
+    assert.equal(closure.acceptedSpecRef, null);
+    assert.equal(registeredContracts.length, 0);
+    assert.equal(handoff.status, 'missing');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('stage artifact registration supports plan-stage review and manager artifacts', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-artifact-registration-'));
+  try {
+    await initProject(root);
+    const planContent = reviewedPlan();
+    const planHash = hashDocumentContent(planContent);
+    await mkdir(path.join(root, 'specs', 'master'), { recursive: true });
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+    await writePlanStageArtifacts(root, { planHash });
+
+    const reviewArtifact = await readMarkdownArtifact(root, '.sdd/runs/master/plan/plan-review-v1.md');
+    const reviewRecord = validateStageArtifactFrontmatter({
+      branch: 'master',
+      stage: 'plan',
+      ref: reviewArtifact.ref,
+      hash: reviewArtifact.hash,
+      frontmatter: reviewArtifact.frontmatter,
+      registeredAt: generatedAt
+    });
+    const managerArtifact = await readMarkdownArtifact(root, '.sdd/runs/master/plan/plan-manager-v1.md');
+    const managerRecord = validateStageArtifactFrontmatter({
+      branch: 'master',
+      stage: 'plan',
+      ref: managerArtifact.ref,
+      hash: managerArtifact.hash,
+      frontmatter: managerArtifact.frontmatter,
+      registeredAt: generatedAt
+    });
+    await recordRuntimeStageArtifact(root, reviewRecord);
+    await recordRuntimeStageArtifact(root, managerRecord);
+
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'plan' });
+
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', 'plan_review']);
+    assert.equal(reviewRecord.targetRef?.ref, 'specs/master/plan.md');
+    assert.equal(reviewRecord.targetHash, planHash);
+    assert.equal(managerRecord.reviewRef?.ref, '.sdd/runs/master/plan/plan-review-v1.md');
+    assert.equal(managerRecord.reviewHash, reviewArtifact.hash);
+    assert.throws(() => validateStageArtifactFrontmatter({
+      branch: 'master',
+      stage: 'plan',
+      ref: reviewArtifact.ref,
+      hash: reviewArtifact.hash,
+      frontmatter: { ...reviewArtifact.frontmatter, producer: 'spec-reviewer' },
+      registeredAt: generatedAt
+    }), /must be produced by plan-reviewer/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('stage artifact registration supports review and manager pairs through ship', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-artifact-registration-'));
+  try {
+    await initProject(root);
+    for (const stageCase of stageArtifactPairCases) {
+      await writeStageArtifactPair(root, stageCase);
+      const reviewArtifact = await readMarkdownArtifact(root, `.sdd/runs/master/${stageCase.stage}/${stageCase.reviewFile}`);
+      const reviewRecord = validateStageArtifactFrontmatter({
+        branch: 'master',
+        stage: stageCase.stage,
+        ref: reviewArtifact.ref,
+        hash: reviewArtifact.hash,
+        frontmatter: reviewArtifact.frontmatter,
+        registeredAt: generatedAt
+      });
+      const managerArtifact = await readMarkdownArtifact(root, `.sdd/runs/master/${stageCase.stage}/${stageCase.managerFile}`);
+      const managerRecord = validateStageArtifactFrontmatter({
+        branch: 'master',
+        stage: stageCase.stage,
+        ref: managerArtifact.ref,
+        hash: managerArtifact.hash,
+        frontmatter: managerArtifact.frontmatter,
+        registeredAt: generatedAt
+      });
+      await recordRuntimeStageArtifact(root, reviewRecord);
+      await recordRuntimeStageArtifact(root, managerRecord);
+
+      const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: stageCase.stage });
+
+      assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', stageCase.reviewKind].sort());
+      assert.equal(reviewRecord.producer, stageCase.reviewProducer);
+      assert.equal(reviewRecord.targetRef?.ref, stageCase.targetRef);
+      assert.equal(managerRecord.producer, stageCase.managerProducer);
+      assert.equal(managerRecord.reviewRef?.ref, `.sdd/runs/master/${stageCase.stage}/${stageCase.reviewFile}`);
+      assert.equal(managerRecord.reviewHash, reviewArtifact.hash);
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('clarification closure records agent-authored evidence without accepting spec or handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-closure-clarification-'));
+  try {
+    await initProject(root);
+    const reviewedSpecContent = reviewedSpec();
+    const specHash = hashDocumentContent(reviewedSpecContent);
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), reviewedSpecContent, 'utf8');
+    await writeSpecStageArtifacts(root, { specHash, verdict: 'blocked', blockingCount: 1, recommendation: 'request_clarification' });
+    const riskDecision = decision('research', ['spec', 'plan', 'verifies']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-clarification-closure'
+    });
+    const health = await inspectSpecCollaborationHealth(root, 'master');
+    const handoff = await inspectWorkflowStageHandoff(root, 'master');
+
+    assert.equal(closure.adjudication.health, 'needs_clarification');
+    assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'not_accepted_needs_clarification');
+    assert.equal(closure.acceptedSpecRef, null);
+    assert.equal(closure.artifactRefs.every((artifact) => artifact.ref.startsWith('.sdd/runs/master/spec/')), true);
+    assert.equal(health.status, 'needs_clarification');
+    assert.equal(handoff.status, 'missing');
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.1')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready structural closure rejects mismatched canonical spec hash without handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-closure-mismatch-'));
+  try {
+    await initProject(root);
+    const reviewedSpecContent = reviewedSpec();
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), reviewedSpecContent, 'utf8');
+    await writeSpecStageArtifacts(root, { specHash: 'stale-hash' });
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-hash-mismatch-closure'
+    });
+    const handoff = await inspectWorkflowStageHandoff(root, 'master');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'invalid_proposal');
+    assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'not_accepted_hash_mismatch');
+    assert.equal(closure.acceptedSpecRef, null);
+    assert.equal(handoff.status, 'missing');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready plan closure accepts reviewed plan document and records plan to tasks handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan');
+    const planContent = reviewedPlan();
+    const planHash = hashDocumentContent(planContent);
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+    await writePlanStageArtifacts(root, { planHash });
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-ready-closure'
+    });
+    const planContentAfterClosure = await readFile(path.join(root, 'specs', 'master', 'plan.md'), 'utf8');
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'plan' });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'ready_for_tasks');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedPlanRef?.ref, 'specs/master/plan.md');
+    assert.equal(closure.acceptedPlanRef?.hash, planHash);
+    assert.equal(planContentAfterClosure, planContent);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', 'plan_review']);
+    assert.equal(handoff?.payload.fromStage, 'plan');
+    assert.equal(handoff?.payload.toStage, 'tasks');
+    assert.equal(handoff?.payload.requiredInputRefs[0]?.ref, 'specs/master/plan.md');
+    assert.equal(handoff?.payload.requiredInputRefs[0]?.hash, planHash);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.2')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects missing plan review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-missing-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-missing-review');
+    const planContent = reviewedPlan();
+    const planHash = hashDocumentContent(planContent);
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+    await writePlanStageArtifacts(root, { planHash, omitReview: true });
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-missing-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'missing_required_review');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedPlanRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects missing accepted spec handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-missing-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    const planContent = reviewedPlan();
+    const planHash = hashDocumentContent(planContent);
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), reviewedSpec(), 'utf8');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+    await writePlanStageArtifacts(root, { planHash });
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-missing-upstream-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.equal(closure.acceptedPlanRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects stale accepted spec handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-stale-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-stale');
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), `${reviewedSpec()}\nStale after handoff.\n`, 'utf8');
+    const planContent = reviewedPlan();
+    const planHash = hashDocumentContent(planContent);
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+    await writePlanStageArtifacts(root, { planHash });
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-stale-upstream-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedPlanRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects mismatched canonical plan hash without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-mismatch-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-hash-mismatch');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), reviewedPlan(), 'utf8');
+    await writePlanStageArtifacts(root, { planHash: 'stale-plan-hash' });
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-hash-mismatch-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'invalid_proposal');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_hash_mismatch');
+    assert.equal(closure.acceptedPlanRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready tasks closure accepts reviewed tasks document and records tasks to verifies handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks');
+    const tasksContent = reviewedTasks();
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+    await writeTasksStageArtifacts(root, { tasksHash });
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-ready-closure'
+    });
+    const tasksContentAfterClosure = await readFile(path.join(root, 'specs', 'master', 'tasks.md'), 'utf8');
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'tasks' });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'verifies');
+
+    assert.equal(closure.adjudication.health, 'ready_for_verifies');
+    assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedTasksRef?.ref, 'specs/master/tasks.md');
+    assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+    assert.equal(tasksContentAfterClosure, tasksContent);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', 'tasks_review']);
+    assert.equal(handoff?.payload.fromStage, 'tasks');
+    assert.equal(handoff?.payload.toStage, 'verifies');
+    assert.equal(handoff?.payload.requiredInputRefs[0]?.ref, 'specs/master/tasks.md');
+    assert.equal(handoff?.payload.requiredInputRefs[0]?.hash, tasksHash);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.3')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure rejects missing tasks review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-missing-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-missing-review');
+    const tasksContent = reviewedTasks();
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+    await writeTasksStageArtifacts(root, { tasksHash, omitReview: true });
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-missing-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'verifies');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'missing_required_review');
+    assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedTasksRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure rejects stale accepted plan handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-stale-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-stale');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), `${reviewedPlan()}\nStale after handoff.\n`, 'utf8');
+    const tasksContent = reviewedTasks();
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+    await writeTasksStageArtifacts(root, { tasksHash });
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-stale-upstream-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'verifies');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedTasksRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure rejects duplicate task ids without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-duplicate-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-duplicate');
+    const tasksContent = reviewedTasks({ duplicate: true });
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+    await writeTasksStageArtifacts(root, { tasksHash });
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-duplicate-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'verifies');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'invalid_proposal');
+    assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'not_accepted_duplicate_task_ids');
+    assert.equal(closure.acceptedTasksRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready verifies closure accepts reviewed verify contract and records verifies to do handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verifies-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTasksClosure(root, riskDecision, 'run-tasks-ready-for-verifies');
+    const verifyContent = reviewedVerify(reviewedTasks());
+    const verifyHash = hashDocumentContent(verifyContent);
+    await writeFile(path.join(root, 'specs', 'master', 'verify.md'), verifyContent, 'utf8');
+    await writeVerifiesStageArtifacts(root, { verifyHash });
+
+    const closure = await reconcileVerifiesCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-verifies-ready-closure'
+    });
+    const verifyContentAfterClosure = await readFile(path.join(root, 'specs', 'master', 'verify.md'), 'utf8');
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'verifies' });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'verifies', 'do');
+
+    assert.equal(closure.adjudication.health, 'ready_for_do');
+    assert.equal(closure.adjudication.closureRefs.verifyAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedVerifyRef?.ref, 'specs/master/verify.md');
+    assert.equal(closure.acceptedVerifyRef?.hash, verifyHash);
+    assert.equal(verifyContentAfterClosure, verifyContent);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', 'verifies_review']);
+    assert.equal(handoff?.payload.fromStage, 'verifies');
+    assert.equal(handoff?.payload.toStage, 'do');
+    assert.equal(handoff?.payload.requiredInputRefs[0]?.ref, 'specs/master/verify.md');
+    assert.equal(handoff?.payload.requiredInputRefs[0]?.hash, verifyHash);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.4')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('verifies closure rejects missing verifies review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verifies-closure-missing-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTasksClosure(root, riskDecision, 'run-tasks-ready-for-verifies-missing-review');
+    const verifyContent = reviewedVerify(reviewedTasks());
+    const verifyHash = hashDocumentContent(verifyContent);
+    await writeFile(path.join(root, 'specs', 'master', 'verify.md'), verifyContent, 'utf8');
+    await writeVerifiesStageArtifacts(root, { verifyHash, omitReview: true });
+
+    const closure = await reconcileVerifiesCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-verifies-missing-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'verifies', 'do');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'missing_required_review');
+    assert.equal(closure.adjudication.closureRefs.verifyAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedVerifyRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('verifies closure rejects stale accepted tasks handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verifies-closure-stale-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTasksClosure(root, riskDecision, 'run-tasks-ready-for-verifies-stale');
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), `${reviewedTasks()}\nStale after handoff.\n`, 'utf8');
+    const verifyContent = reviewedVerify(reviewedTasks());
+    const verifyHash = hashDocumentContent(verifyContent);
+    await writeFile(path.join(root, 'specs', 'master', 'verify.md'), verifyContent, 'utf8');
+    await writeVerifiesStageArtifacts(root, { verifyHash });
+
+    const closure = await reconcileVerifiesCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-verifies-stale-upstream-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'verifies', 'do');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.verifyAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedVerifyRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('verifies closure rejects incomplete coverage without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verifies-closure-incomplete-coverage-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTasksClosure(root, riskDecision, 'run-tasks-ready-for-verifies-incomplete');
+    const verifyContent = reviewedVerify(reviewedTasks(), { omitTaskId: 'T2' });
+    const verifyHash = hashDocumentContent(verifyContent);
+    await writeFile(path.join(root, 'specs', 'master', 'verify.md'), verifyContent, 'utf8');
+    await writeVerifiesStageArtifacts(root, { verifyHash });
+
+    const closure = await reconcileVerifiesCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-verifies-incomplete-coverage-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'verifies', 'do');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.verifyAcceptanceStatus, 'not_accepted_incomplete_coverage');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /T2/);
+    assert.equal(closure.acceptedVerifyRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready do closure accepts reviewed implementation state and records do to test handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    const changedFileHash = hashDocumentContent(changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: changedFileHash }] });
+    await writeFile(path.join(root, '.sdd', 'runs', 'master', 'do', 't1-schema-review-v1.md'), '# Human note\n\nThis note is not a stage artifact.\n', 'utf8');
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: [changedFileRef],
+      generatedAt,
+      runId: 'run-do-ready-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+    const doFiles = (await readdir(path.join(root, '.sdd', 'runs', 'master', 'do'))).sort();
+    const changedFileAfterClosure = await readFile(path.join(root, changedFileRef), 'utf8');
+
+    assert.equal(closure.adjudication.health, 'ready_for_test');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedImplementationRef?.ref, '.sdd/runs/master/do/implementation-v1.md');
+    assert.deepEqual(closure.changedFileRefs, [{ kind: 'evidence', ref: changedFileRef, hash: changedFileHash }]);
+    assert.equal(handoff?.payload.fromStage, 'do');
+    assert.equal(handoff?.payload.toStage, 'test');
+    assert.equal(handoff?.payload.requiredInputRefs.some((inputRef) => inputRef.ref === changedFileRef && inputRef.hash === changedFileHash), true);
+    assert.deepEqual(doFiles, ['code-review-v1.md', 'do-collaboration-contract-v1.md', 'do-manager-v1.md', 'implementation-v1.md', 't1-schema-review-v1.md']);
+    assert.equal(changedFileAfterClosure, changedFileContent);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.5')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready do closure accepts branch-scoped SQL implementation assets matched by task glob', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-spec-sql-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-spec-sql');
+    const changedFileRef = 'specs/master/add_table.sql';
+    const changedFileContent = 'create table add_table (id int primary key);\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    const changedFileHash = hashDocumentContent(changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: changedFileHash }] });
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: ['specs/master/*.sql'],
+      generatedAt,
+      runId: 'run-do-spec-sql-closure'
+    });
+
+    assert.equal(closure.adjudication.health, 'ready_for_test');
+    assert.deepEqual(closure.changedFileRefs, [{ kind: 'evidence', ref: changedFileRef, hash: changedFileHash }]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('do closure rejects missing code review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-missing-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-missing-review');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: hashDocumentContent(changedFileContent) }], omitReview: true });
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: [changedFileRef],
+      generatedAt,
+      runId: 'run-do-missing-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.rejection?.reasonCode, 'missing_required_review');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedImplementationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('do closure rejects stale accepted verifies handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-stale-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-stale');
+    await writeFile(path.join(root, 'specs', 'master', 'verify.md'), `${reviewedVerify(reviewedTasks())}\nStale after handoff.\n`, 'utf8');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: hashDocumentContent(changedFileContent) }] });
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: [changedFileRef],
+      generatedAt,
+      runId: 'run-do-stale-upstream-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedImplementationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('do closure rejects changed-file hash drift without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-hash-drift-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-hash-drift');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: hashDocumentContent(changedFileContent) }] });
+    await writeWorkspaceFile(root, changedFileRef, 'export const login = () => false;\n');
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: [changedFileRef],
+      generatedAt,
+      runId: 'run-do-hash-drift-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'not_accepted_hash_mismatch');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedImplementationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('do closure rejects changed files outside task boundary without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-boundary-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-boundary');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: hashDocumentContent(changedFileContent) }] });
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: ['packages/app/profile.ts'],
+      generatedAt,
+      runId: 'run-do-boundary-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'not_accepted_boundary_violation');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /outside/);
+    assert.equal(closure.acceptedImplementationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('do closure rejects blocking code review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-blocking-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-blocking-review');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: hashDocumentContent(changedFileContent) }], verdict: 'changes_requested', blockingCount: 1 });
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: [changedFileRef],
+      generatedAt,
+      runId: 'run-do-blocking-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedImplementationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('do closure rejects do-manager rework recommendation without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-do-closure-manager-rework-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedVerifiesClosure(root, riskDecision, 'run-verifies-ready-for-do-manager-rework');
+    const changedFileRef = 'packages/app/login.ts';
+    const changedFileContent = 'export const login = () => true;\n';
+    await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+    await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: hashDocumentContent(changedFileContent) }], recommendation: 'request_clarification' });
+
+    const closure = await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: [changedFileRef],
+      generatedAt,
+      runId: 'run-do-manager-rework-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'do', 'test');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'not_accepted_rejected');
+    assert.equal(closure.acceptedImplementationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready test closure accepts mapped validation evidence and records test to goal-verify handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test');
+    await writeTestStageArtifacts(root, {});
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-ready-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+    const testFiles = (await readdir(path.join(root, '.sdd', 'runs', 'master', 'test'))).sort();
+
+    assert.equal(closure.adjudication.health, 'ready_for_goal_verify');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedTestEvidenceRef?.ref, '.sdd/runs/master/test/validation-v1.md');
+    assert.equal(handoff?.payload.fromStage, 'test');
+    assert.equal(handoff?.payload.toStage, 'goal-verify');
+    assert.equal(handoff?.payload.requiredInputRefs.some((inputRef) => inputRef.ref === '.sdd/runs/master/test/validation-v1.md'), true);
+    assert.deepEqual(testFiles, ['test-collaboration-contract-v1.md', 'test-execution-v1.md', 'test-manager-v1.md', 'test-review-v1.md', 'validation-v1.md']);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.6')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('test closure rejects missing command evidence without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-missing-execution-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test-missing-execution');
+    await writeTestStageArtifacts(root, { omitExecution: true });
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-missing-execution-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'not_accepted_missing_execution');
+    assert.equal(closure.acceptedTestEvidenceRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('test closure rejects stale accepted do handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-stale-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    const doState = await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test-stale');
+    await writeWorkspaceFile(root, doState.changedFileRef, 'export const login = () => false;\n');
+    await writeTestStageArtifacts(root, {});
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-stale-upstream-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedTestEvidenceRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('test closure rejects failing command evidence without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-failing-execution-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test-failing');
+    await writeTestStageArtifacts(root, { executionStatus: 'failed', exitCode: 1 });
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-failing-execution-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'not_accepted_failed_tests');
+    assert.equal(closure.acceptedTestEvidenceRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('test closure rejects unmapped acceptance evidence without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-unmapped-acceptance-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test-unmapped');
+    await writeTestStageArtifacts(root, { acceptanceMapped: false });
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-unmapped-acceptance-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'not_accepted_unmapped_acceptance');
+    assert.equal(closure.acceptedTestEvidenceRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('test closure rejects blocking test review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-blocking-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test-blocking-review');
+    await writeTestStageArtifacts(root, { verdict: 'changes_requested', blockingCount: 1 });
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-blocking-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedTestEvidenceRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('test closure rejects test-manager rework recommendation without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-test-closure-manager-rework-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedDoClosure(root, riskDecision, 'run-do-ready-for-test-manager-rework');
+    await writeTestStageArtifacts(root, { recommendation: 'request_clarification' });
+
+    const closure = await reconcileTestCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-test-manager-rework-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'test', 'goal-verify');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'not_accepted_rejected');
+    assert.equal(closure.acceptedTestEvidenceRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready goal-verify closure accepts reviewed goal evidence and records truthAlignment for ship', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-goal-verify-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTestClosure(root, riskDecision, 'run-test-ready-for-goal-verify');
+    await writeGoalVerifyStageArtifacts(root, {});
+
+    const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-goal-verify-ready-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'goal-verify', 'ship');
+    const truthAlignment = await readTruthAlignmentProjection(root, riskDecision.scope);
+    const chain = await inspectFullStageChain(root, 'master');
+    const goalVerifyFiles = (await readdir(path.join(root, '.sdd', 'runs', 'master', 'goal-verify'))).sort();
+
+    assert.equal(closure.adjudication.health, 'ready_for_ship');
+    assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedGoalVerificationRef?.ref, '.sdd/runs/master/goal-verify/goal-verification-v1.md');
+    assert.equal(handoff, null);
+    assert.equal(closure.adjudication.closureRefs.truthAlignmentProjectionRef?.kind, 'projection');
+    assert.equal(truthAlignment?.payload.status, 'aligned');
+    assert.equal(chain.status, 'partial');
+    assert.equal(chain.finalHealth, 'ready_for_ship');
+    assert.equal(chain.projectionCounts.completedStages, 7);
+    assert.equal(truthAlignment?.payload.sourceStage, 'goal-verify');
+    assert.equal(truthAlignment?.payload.acceptedRealityRefs.some((inputRef) => inputRef.ref === '.sdd/runs/master/goal-verify/goal-verification-v1.md'), true);
+    assert.deepEqual(goalVerifyFiles, ['goal-review-v1.md', 'goal-verification-v1.md', 'goal-verify-collaboration-contract-v1.md', 'goal-verify-manager-v1.md']);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.7')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('goal-verify closure rejects incomplete acceptance coverage without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-goal-verify-closure-incomplete-coverage-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTestClosure(root, riskDecision, 'run-test-ready-for-goal-verify-incomplete-coverage');
+    await writeGoalVerifyStageArtifacts(root, { coverageComplete: false });
+
+    const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-goal-verify-incomplete-coverage-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'goal-verify', 'ship');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'not_accepted_incomplete_coverage');
+    assert.equal(closure.acceptedGoalVerificationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('goal-verify closure rejects stale accepted test handoff without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-goal-verify-closure-stale-test-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTestClosure(root, riskDecision, 'run-test-ready-for-goal-verify-stale');
+    await writeFile(path.join(root, '.sdd', 'runs', 'master', 'test', 'validation-v1.md'), validationEvidenceArtifact('stale-execution-hash', 'passed', true), 'utf8');
+    await writeGoalVerifyStageArtifacts(root, {});
+
+    const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-goal-verify-stale-test-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'goal-verify', 'ship');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /stale/);
+    assert.equal(closure.acceptedGoalVerificationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('goal-verify closure rejects open durable gaps without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-goal-verify-closure-open-gap-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTestClosure(root, riskDecision, 'run-test-ready-for-goal-verify-open-gap');
+    await writeGoalVerifyStageArtifacts(root, { durableGapCount: 1 });
+
+    const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-goal-verify-open-gap-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'goal-verify', 'ship');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'not_accepted_open_gap');
+    assert.equal(closure.acceptedGoalVerificationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('goal-verify closure rejects blocking goal review without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-goal-verify-closure-blocking-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTestClosure(root, riskDecision, 'run-test-ready-for-goal-verify-blocking-review');
+    await writeGoalVerifyStageArtifacts(root, { verdict: 'changes_requested', blockingCount: 1 });
+
+    const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-goal-verify-blocking-review-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'goal-verify', 'ship');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedGoalVerificationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('goal-verify closure rejects goal-verify-manager rework recommendation without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-goal-verify-closure-manager-rework-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedTestClosure(root, riskDecision, 'run-test-ready-for-goal-verify-manager-rework');
+    await writeGoalVerifyStageArtifacts(root, { recommendation: 'request_clarification' });
+
+    const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-goal-verify-manager-rework-closure'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'goal-verify', 'ship');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'not_accepted_rejected');
+    assert.equal(closure.acceptedGoalVerificationRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test('ready ship closure accepts reviewed readiness evidence and records final ship-ready projection', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship');
+    await writeShipStageArtifacts(root, {});
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-ready-closure'
+    });
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'ship' });
+    const shipFiles = await readdir(path.join(root, '.sdd', 'runs', 'master', 'ship'));
+
+    assert.equal(closure.adjudication.health, 'ship_ready');
+    assert.equal(closure.adjudication.stageDecision.status, 'completed');
+    assert.equal(closure.adjudication.handoffPacket, null);
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'accepted');
+    assert.equal(closure.acceptedShipReadinessRef?.ref, '.sdd/runs/master/ship/ship-readiness-v1.md');
+    assert.equal(closure.releaseDocumentRef, null);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), ['manager_closure_request', 'release_review', 'ship_readiness']);
+    assert.deepEqual(shipFiles, ['release-review-v1.md', 'ship-collaboration-contract-v1.md', 'ship-manager-v1.md', 'ship-readiness-v1.md']);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs', 'master', 'evidence', 'artifacts', 'phase9.9')));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship required release review is satisfied by registered release-review artifact', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-required-review-'));
+  try {
+    await initProject(root);
+    const riskDecision: LifecycleRiskDecision = {
+      ...decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']),
+      requiredEvidence: [{
+        id: 'phase8-risk:command-evidence',
+        acceptanceRef: 'phase8-risk-decision',
+        kind: 'command',
+        requiredBefore: 'ship',
+        refs: [ref('task', 'T1'), ref('task', 'T2')],
+        reasons: ['Task declares high-risk tags: evidence-semantics.']
+      }],
+      requiredReviews: [{
+        id: 'phase8-risk:release-review',
+        kind: 'release',
+        requiredBefore: 'ship',
+        reasons: ['Phase 8 risk signal requires release review.']
+      }]
+    };
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship-required-review');
+    await writeShipStageArtifacts(root, {});
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-required-review-closure'
+    });
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'ship' });
+
+    assert.equal(closure.adjudication.health, 'ship_ready');
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'accepted');
+    assert.equal(closure.acceptedShipReadinessRef?.ref, '.sdd/runs/master/ship/ship-readiness-v1.md');
+    assert.equal(registered.some((artifact) => artifact.kind === 'release_review'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('full-stage chain diagnostic summarizes ready chain from runtime projections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-full-chain-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-full-chain-ready-for-ship');
+    await writeShipStageArtifacts(root, {});
+    const shipClosure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-full-chain-ship-ready'
+    });
+    const chain = await inspectFullStageChain(root, 'master');
+
+    assert.equal(shipClosure.adjudication.health, 'ship_ready');
+    assert.equal(chain.status, 'ready');
+    assert.equal(chain.finalHealth, 'ship_ready');
+    assert.equal(chain.projectionCounts.adjudications, 8);
+    assert.equal(chain.projectionCounts.completedStages, 8);
+    assert.equal(chain.projectionCounts.validatedCollaborationContracts, 8);
+    assert.equal(chain.projectionCounts.handoffs, 6);
+    assert.deepEqual(chain.stages.map((stage) => stage.stage), ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    assert.equal(chain.stages.every((stage) => !stage.acceptedRef?.ref.startsWith('runs/')), true);
+    assert.equal(chain.stages.every((stage) => stage.acceptedRef?.ref.includes('evidence/artifacts') === false), true);
+    assert.equal(chain.stages.every((stage) => stage.acceptedRef?.ref.startsWith('artifacts/') === false), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime close replay does not create or mutate Markdown files', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-full-chain-markdown-immutable-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-markdown-immutable-ready-for-ship');
+    await writeShipStageArtifacts(root, {});
+    await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-markdown-immutable-ship-ready'
+    });
+    const before = await markdownSnapshot(root);
+
+    await reconcileSpecCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-spec' });
+    await reconcilePlanCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-plan' });
+    await reconcileTasksCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-tasks' });
+    await reconcileVerifiesCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-verifies' });
+    await reconcileDoCollaborationClosure(root, {
+      decision: riskDecision,
+      allowedChangedFileRefs: ['packages/app/login.ts'],
+      generatedAt,
+      runId: 'run-markdown-immutable-replay-do'
+    });
+    await reconcileTestCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-test' });
+    await reconcileGoalVerifyCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-goal-verify' });
+    await reconcileShipCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-ship' });
+    const after = await markdownSnapshot(root);
+
+    assert.deepEqual(after, before);
+    assert.equal([...after.keys()].some((file) => file.startsWith('runs/')), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship closure rejects missing release review without final readiness', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-missing-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship-missing-review');
+    await writeShipStageArtifacts(root, { omitReview: true });
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-missing-review-closure'
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'not_accepted_missing_review');
+    assert.equal(closure.acceptedShipReadinessRef, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship closure rejects stale truthAlignment reality refs without final readiness', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-stale-truth-alignment-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship-stale');
+    await writeFile(path.join(root, '.sdd', 'runs', 'master', 'goal-verify', 'goal-verification-v1.md'), `${goalVerificationArtifact('passed', true, 0, 0)}\nDrift after truthAlignment.\n`, 'utf8');
+    await writeShipStageArtifacts(root, {});
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-stale-truth-alignment-closure'
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /truthAlignment|stale/);
+    assert.equal(closure.acceptedShipReadinessRef, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship closure rejects open readiness blockers without final readiness', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-open-blocker-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship-open-blocker');
+    await writeShipStageArtifacts(root, { doctorBlockerCount: 1 });
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-open-blocker-closure'
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'not_accepted_open_blocker');
+    assert.equal(closure.acceptedShipReadinessRef, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship closure rejects release document hash drift when release doc is declared', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-release-drift-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship-release-drift');
+    const releaseContent = '# Release Notes\n\nReady to ship.\n';
+    await writeFile(path.join(root, 'specs', 'master', 'release.md'), releaseContent, 'utf8');
+    await writeShipStageArtifacts(root, { release: { ref: 'specs/master/release.md', hash: hashDocumentContent(releaseContent) } });
+    await writeFile(path.join(root, 'specs', 'master', 'release.md'), `${releaseContent}\nDrift after readiness.\n`, 'utf8');
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-release-drift-closure'
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'not_accepted_release_drift');
+    assert.equal(closure.acceptedShipReadinessRef, null);
+    assert.equal(closure.releaseDocumentRef, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship closure rejects authority-violating readiness evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-ship-authority-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    await writeAcceptedGoalVerifyClosure(root, riskDecision, 'run-goal-verify-ready-for-ship-authority');
+    await writeShipStageArtifacts(root, { authorityAttempts: ['ship_ready'] });
+
+    const closure = await reconcileShipCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ship-authority-closure'
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.shipReadinessStatus, 'not_accepted_authority_violation');
+    assert.equal(closure.acceptedShipReadinessRef, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+function decision(profile: LifecycleRiskDecision['profile'], requiredStages: LifecycleRiskDecision['requiredStages']): LifecycleRiskDecision {
+  return {
+    contract: LIFECYCLE_RISK_DECISION_CONTRACT_VERSION,
+    scope: { branch: 'master' },
+    profile,
+    requiredStages,
+    skippedStages: [],
+    blockedStages: profile === 'blocked' ? ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'] : [],
+    requiredEvidence: [],
+    requiredReviews: [],
+    humanCheckpointRequired: profile === 'blocked',
+    approvalPolicy: profile === 'blocked' ? 'blocked' : profile === 'direct' ? 'auto-allow' : 'review-required',
+    inputRefs: [ref('document', 'specs/master/phase9.1-spec.md')],
+    signalRefs: [],
+    policyVersion: 'test-policy',
+    inputHash: 'input-hash',
+    confidence: 'high',
+    reasons: [`${profile} test decision`],
+    generatedAt
+  };
+}
+
+function stageClosure(profile: StageCollaborationProfile, overrides: { items?: CandidateItem[]; authorityAttempts?: StageClosureRequest['authorityAttempts']; canonicalSpecRef?: ReturnType<typeof ref> } = {}): { coordination: SpecManagerCoordinationRecord; closureRequest: StageClosureRequest } {
+  const workOrder = buildSpecStageWorkOrder(profile, ref('projection', 'profile/spec'), generatedAt);
+  const workOrderRef = ref('projection', `spec-work-order/${profile.scope.branch}`);
+  const candidateRef = overrides.canonicalSpecRef ?? ref('document', 'specs/master/spec.md');
+  const reviewRef = ref('artifact', '.sdd/runs/master/spec/spec-review-v1.md');
+  const items = overrides.items ?? [candidateItem('find-1', 'advisory_finding'), candidateItem('cap-1', 'capability_suggestion'), candidateItem('handoff-1', 'handoff_proposal')];
+  const unresolvedAmbiguityIds = items.filter((item) => item.kind === 'blocking_ambiguity').map((item) => item.id);
+  const candidate: SpecDocumentCandidate = {
+    contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+    candidateId: `candidate-${profile.scope.branch}`,
+    stage: 'spec',
+    scope: profile.scope,
+    producedBy: 'spec-drafter',
+    inputRefs: workOrder.inputRefs,
+    evidenceRefs: items.flatMap((item) => item.refs),
+    acceptedItems: items,
+    generatedAt
+  };
+  const capabilityFindings = items
+    .filter((item) => item.kind === 'capability_suggestion')
+    .map((item): CapabilityFinding => ({
+      contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+      findingId: `finding-${item.id}`,
+      stage: 'spec',
+      scope: profile.scope,
+      capabilityDomain: 'solution-design',
+      summary: item.summary,
+      refs: item.refs,
+      generatedAt
+    }));
+  const capabilityFindingRefs = capabilityFindings.map((finding) => ref('artifact', `.sdd/runs/master/spec/spec-capability-finding-${finding.findingId}.md`));
+  const review: SpecReviewResult = {
+    contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+    reviewId: `review-${profile.scope.branch}`,
+    stage: 'spec',
+    scope: profile.scope,
+    reviewer: 'spec-reviewer',
+    candidateRef,
+    verdict: unresolvedAmbiguityIds.length > 0 ? 'blocked' : 'approved',
+    findings: items.map((item) => item.summary),
+    evidenceRefs: items.flatMap((item) => item.refs),
+    generatedAt
+  };
+  const agentTeamRefs = [candidateRef, reviewRef, ...capabilityFindingRefs];
+  const coordination: SpecManagerCoordinationRecord = {
+    contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+    coordinationId: `coordination-${profile.scope.branch}`,
+    stage: 'spec',
+    scope: profile.scope,
+    stageManager: 'spec-manager',
+    workOrderRef,
+    agentTeamRefs,
+    recommendation: unresolvedAmbiguityIds.length > 0 ? 'request_clarification' : 'close_stage',
+    generatedAt
+  };
+  const closureRequest: StageClosureRequest = {
+    contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+    closureRequestId: `closure-${profile.scope.branch}`,
+    stage: 'spec',
+    scope: profile.scope,
+    submittedBy: 'spec-manager',
+    workOrderRef,
+    coordinationRef: ref('artifact', '.sdd/runs/master/spec/spec-manager-v1.md'),
+    candidateRef,
+    reviewRefs: [reviewRef],
+    capabilityFindingRefs,
+    evidenceRefs: [workOrderRef, ...agentTeamRefs, ...items.flatMap((item) => item.refs)],
+    candidate,
+    reviewResults: [review],
+    capabilityFindings,
+    unresolvedAmbiguityIds,
+    authorityAttempts: overrides.authorityAttempts ?? [],
+    managerRecommendation: unresolvedAmbiguityIds.length > 0 ? 'request_clarification' : 'close_stage',
+    generatedAt
+  };
+  return { coordination, closureRequest };
+}
+
+type CandidateItem = { id: string; kind: SpecProposalItemKind; summary: string; refs: ReturnType<typeof ref>[] };
+
+function candidateItem(id: string, kind: SpecProposalItemKind, refs = [ref('document', `specs/master/${id}.md`)]): CandidateItem {
+  return { id, kind, summary: `${kind} ${id}`, refs };
+}
+
+async function writeAcceptedSpecClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<void> {
+  const specContent = reviewedSpec();
+  const specHash = hashDocumentContent(specContent);
+  await writeFile(path.join(root, 'specs', 'master', 'spec.md'), specContent, 'utf8');
+  await writeSpecStageArtifacts(root, { specHash });
+  const closure = await reconcileSpecCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedSpecRef?.hash, specHash);
+}
+
+async function writeAcceptedPlanClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<void> {
+  await writeAcceptedSpecClosure(root, riskDecision, `${runId}-spec`);
+  const planContent = reviewedPlan();
+  const planHash = hashDocumentContent(planContent);
+  await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+  await writePlanStageArtifacts(root, { planHash });
+  const closure = await reconcilePlanCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedPlanRef?.hash, planHash);
+}
+
+async function writeAcceptedTasksClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<void> {
+  await writeAcceptedPlanClosure(root, riskDecision, `${runId}-plan`);
+  const tasksContent = reviewedTasks();
+  const tasksHash = hashDocumentContent(tasksContent);
+  await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+  await writeTasksStageArtifacts(root, { tasksHash });
+  const closure = await reconcileTasksCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+}
+
+async function writeAcceptedVerifiesClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<void> {
+  await writeAcceptedTasksClosure(root, riskDecision, `${runId}-tasks`);
+  const tasksContent = reviewedTasks();
+  const verifyContent = reviewedVerify(tasksContent);
+  const verifyHash = hashDocumentContent(verifyContent);
+  await writeFile(path.join(root, 'specs', 'master', 'verify.md'), verifyContent, 'utf8');
+  await writeVerifiesStageArtifacts(root, { verifyHash });
+  const closure = await reconcileVerifiesCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.closureRefs.verifyAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedVerifyRef?.hash, verifyHash);
+}
+
+async function writeAcceptedDoClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<{ changedFileRef: string; changedFileHash: string }> {
+  await writeAcceptedVerifiesClosure(root, riskDecision, `${runId}-verifies`);
+  const changedFileRef = 'packages/app/login.ts';
+  const changedFileContent = 'export const login = () => true;\n';
+  await writeWorkspaceFile(root, changedFileRef, changedFileContent);
+  const changedFileHash = hashDocumentContent(changedFileContent);
+  await writeDoStageArtifacts(root, { changedFiles: [{ ref: changedFileRef, hash: changedFileHash }] });
+  const closure = await reconcileDoCollaborationClosure(root, {
+    decision: riskDecision,
+    allowedChangedFileRefs: [changedFileRef],
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.closureRefs.implementationAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedImplementationRef?.ref, '.sdd/runs/master/do/implementation-v1.md');
+  return { changedFileRef, changedFileHash };
+}
+
+async function writeAcceptedTestClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<void> {
+  await writeAcceptedDoClosure(root, riskDecision, `${runId}-do`);
+  await writeTestStageArtifacts(root, {});
+  const closure = await reconcileTestCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.closureRefs.testAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedTestEvidenceRef?.ref, '.sdd/runs/master/test/validation-v1.md');
+}
+
+async function writeAcceptedGoalVerifyClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<{ acceptedGoalVerificationRef: RuntimeRef }> {
+  await writeAcceptedTestClosure(root, riskDecision, `${runId}-test`);
+  await writeGoalVerifyStageArtifacts(root, {});
+  const closure = await reconcileGoalVerifyCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  const acceptedGoalVerificationRef = closure.acceptedGoalVerificationRef;
+  assert.equal(closure.adjudication.health, 'ready_for_ship');
+  assert.equal(closure.adjudication.closureRefs.goalVerifyAcceptanceStatus, 'accepted');
+  assert.ok(acceptedGoalVerificationRef);
+  assert.equal(acceptedGoalVerificationRef.ref, '.sdd/runs/master/goal-verify/goal-verification-v1.md');
+  assert.ok(acceptedGoalVerificationRef.hash);
+  assert.equal(closure.adjudication.closureRefs.truthAlignmentProjectionRef?.kind, 'projection');
+  return { acceptedGoalVerificationRef };
+}
+
+
+async function writeWorkspaceFile(root: string, fileRef: string, content: string): Promise<void> {
+  await mkdir(path.dirname(path.join(root, fileRef)), { recursive: true });
+  await writeFile(path.join(root, fileRef), content, 'utf8');
+}
+
+async function writeSpecStageArtifacts(root: string, options: { specHash: string; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation']; omitContract?: boolean }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'spec');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeFile(path.join(dir, 'spec-collaboration-contract-v1.md'), specCollaborationContractArtifact(specWorkOrderId()), 'utf8');
+  }
+  await writeFile(path.join(dir, 'scout.md'), specScoutArtifact(), 'utf8');
+  const review = specReviewArtifact(options.specHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  await writeFile(path.join(dir, 'spec-review-v1.md'), review, 'utf8');
+  await writeFile(path.join(dir, 'spec-manager-v1.md'), specManagerArtifact(options.specHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function specWorkOrderId(): string {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']), generatedAt);
+  return buildSpecStageWorkOrder(profile, ref('projection', 'profile/spec'), generatedAt).workOrderId;
+}
+
+function specCollaborationContractArtifact(workOrderId: string): string {
+  return `---
+contract: sdd-stage-collaboration-contract-v1
+branch: master
+stage: spec
+kind: stage_collaboration_contract
+producer: spec-manager
+workOrderId: ${workOrderId}
+selectedAgents:
+  - scout
+  - spec-drafter
+  - spec-reviewer
+selectedSkills:
+  - cap.norm_discovery
+  - cap.uncertainty_resolution
+selectedMaterialPacks:
+  - project-norms
+  - uncertainty-map
+evidenceContracts:
+  - sdd-spec-scout-artifact-v1
+  - sdd-spec-review-artifact-v1
+  - sdd-spec-manager-artifact-v1
+checkpointPlan:
+  - scout_context
+  - review_before_closure
+writableRefs:
+  - specs/master/spec.md
+  - .sdd/runs/master/spec/scout.md
+  - .sdd/runs/master/spec/spec-review-v1.md
+  - .sdd/runs/master/spec/spec-manager-v1.md
+authorityAttempts: []
+maxReworkAttempts: 2
+allowAutoWithinStage: true
+allowAutoNextStage: false
+authorityCeiling: proposal_input
+---
+
+# Spec Collaboration Contract
+
+Spec-manager selected the spec-stage team and evidence strategy within runtime constraints.
+`;
+}
+
+interface StageContractFixtureWorkOrder {
+  workOrderId: string;
+  stage: SddStage;
+  stageManager: string;
+  agentTeam: readonly string[];
+  requiredCapabilities: readonly string[];
+  materialPackIds: readonly string[];
+  requiredOutputKinds: readonly string[];
+  authorityCeiling: string;
+}
+
+async function writeStageCollaborationContract(root: string, stage: SddStage, writableRefs: readonly string[]): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', stage);
+  const workOrder = stageContractFixtureWorkOrder(stage);
+  await writeFile(path.join(dir, `${stage}-collaboration-contract-v1.md`), stageCollaborationContractArtifact(workOrder, writableRefs), 'utf8');
+}
+
+function stageContractFixtureWorkOrder(stage: SddStage): StageContractFixtureWorkOrder {
+  const scope = decision('full', ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']).scope;
+  const profileRef = ref('projection', `profile/${stage}`);
+  const inputRefs = [ref('document', 'specs/master/phase9.1-spec.md')];
+  if (stage === 'plan') return buildPlanStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  if (stage === 'tasks') return buildTasksStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  if (stage === 'verifies') return buildVerifiesStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  if (stage === 'do') return buildDoStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  if (stage === 'test') return buildTestStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  if (stage === 'goal-verify') return buildGoalVerifyStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  if (stage === 'ship') return buildShipStageWorkOrder(scope, profileRef, inputRefs, generatedAt);
+  throw new Error(`Unsupported stage contract fixture ${stage}`);
+}
+
+function stageCollaborationContractArtifact(workOrder: StageContractFixtureWorkOrder, writableRefs: readonly string[]): string {
+  return `---
+contract: sdd-stage-collaboration-contract-v1
+branch: master
+stage: ${workOrder.stage}
+kind: stage_collaboration_contract
+producer: ${workOrder.stageManager}
+workOrderId: ${workOrder.workOrderId}
+selectedAgents:
+${yamlList(workOrder.agentTeam)}
+selectedSkills:
+${yamlList(workOrder.requiredCapabilities.map((capability) => `cap.${capability}`))}
+selectedMaterialPacks:
+${yamlList(workOrder.materialPackIds)}
+evidenceContracts:
+${yamlList(expectedStageArtifactContracts(workOrder.stage, workOrder.requiredOutputKinds))}
+checkpointPlan:
+${yamlList(workOrder.requiredOutputKinds)}
+writableRefs:
+${yamlList(writableRefs)}
+authorityAttempts: []
+maxReworkAttempts: 2
+allowAutoWithinStage: true
+allowAutoNextStage: false
+authorityCeiling: ${workOrder.authorityCeiling}
+---
+
+# ${workOrder.stage} Collaboration Contract
+
+${workOrder.stageManager} selected the stage team and evidence strategy within runtime constraints.
+`;
+}
+
+function yamlList(values: readonly string[]): string {
+  return values.map((value) => `  - ${value}`).join('\n');
+}
+
+function specScoutArtifact(): string {
+  return `---
+contract: sdd-spec-scout-artifact-v1
+branch: master
+stage: spec
+kind: scout_context
+producer: scout
+---
+
+# Scout Context
+
+The scout captured project norms and constraints for the spec drafter and reviewer.
+`;
+}
+
+function specReviewArtifact(specHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-spec-review-artifact-v1
+branch: master
+stage: spec
+kind: spec_review
+producer: spec-reviewer
+targetRef: specs/master/spec.md
+targetHash: ${specHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Spec Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function specManagerArtifact(specHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-spec-manager-artifact-v1
+branch: master
+stage: spec
+kind: manager_closure_request
+producer: spec-manager
+targetRef: specs/master/spec.md
+targetHash: ${specHash}
+reviewRef: .sdd/runs/master/spec/spec-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Spec Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+async function writePlanStageArtifacts(root: string, options: { planHash: string; omitContract?: boolean; omitReview?: boolean; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'plan');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'plan', ['specs/master/plan.md', '.sdd/runs/master/plan/plan-review-v1.md', '.sdd/runs/master/plan/plan-manager-v1.md']);
+  }
+  const review = planReviewArtifact(options.planHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'plan-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'plan-manager-v1.md'), planManagerArtifact(options.planHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function planReviewArtifact(planHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-plan-review-artifact-v1
+branch: master
+stage: plan
+kind: plan_review
+producer: plan-reviewer
+targetRef: specs/master/plan.md
+targetHash: ${planHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Plan Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function planManagerArtifact(planHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-plan-manager-artifact-v1
+branch: master
+stage: plan
+kind: manager_closure_request
+producer: plan-manager
+targetRef: specs/master/plan.md
+targetHash: ${planHash}
+reviewRef: .sdd/runs/master/plan/plan-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Plan Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+async function writeTasksStageArtifacts(root: string, options: { tasksHash: string; omitContract?: boolean; omitReview?: boolean; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'tasks');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'tasks', ['specs/master/tasks.md', '.sdd/runs/master/tasks/tasks-review-v1.md', '.sdd/runs/master/tasks/tasks-manager-v1.md']);
+  }
+  const review = tasksReviewArtifact(options.tasksHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'tasks-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'tasks-manager-v1.md'), tasksManagerArtifact(options.tasksHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function tasksReviewArtifact(tasksHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-tasks-review-artifact-v1
+branch: master
+stage: tasks
+kind: tasks_review
+producer: tasks-reviewer
+targetRef: specs/master/tasks.md
+targetHash: ${tasksHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Tasks Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function tasksManagerArtifact(tasksHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-tasks-manager-artifact-v1
+branch: master
+stage: tasks
+kind: manager_closure_request
+producer: tasks-manager
+targetRef: specs/master/tasks.md
+targetHash: ${tasksHash}
+reviewRef: .sdd/runs/master/tasks/tasks-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Tasks Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+async function writeVerifiesStageArtifacts(root: string, options: { verifyHash: string; omitContract?: boolean; omitReview?: boolean; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'verifies');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'verifies', ['specs/master/verify.md', '.sdd/runs/master/verifies/verifies-review-v1.md', '.sdd/runs/master/verifies/verifies-manager-v1.md']);
+  }
+  const review = verifiesReviewArtifact(options.verifyHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'verifies-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'verifies-manager-v1.md'), verifiesManagerArtifact(options.verifyHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function verifiesReviewArtifact(verifyHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-verifies-review-artifact-v1
+branch: master
+stage: verifies
+kind: verifies_review
+producer: verifies-reviewer
+targetRef: specs/master/verify.md
+targetHash: ${verifyHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Verifies Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function verifiesManagerArtifact(verifyHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-verifies-manager-artifact-v1
+branch: master
+stage: verifies
+kind: manager_closure_request
+producer: verifies-manager
+targetRef: specs/master/verify.md
+targetHash: ${verifyHash}
+reviewRef: .sdd/runs/master/verifies/verifies-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Verifies Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+interface ChangedFileFixture {
+  ref: string;
+  hash: string;
+}
+
+async function writeDoStageArtifacts(root: string, options: { changedFiles: ChangedFileFixture[]; omitContract?: boolean; omitReview?: boolean; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'do');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'do', ['.sdd/runs/master/do/implementation-v1.md', '.sdd/runs/master/do/code-review-v1.md', '.sdd/runs/master/do/do-manager-v1.md']);
+  }
+  const implementation = implementationArtifact(options.changedFiles);
+  const implementationHash = hashDocumentContent(implementation);
+  await writeFile(path.join(dir, 'implementation-v1.md'), implementation, 'utf8');
+  const review = codeReviewArtifact(implementationHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'code-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'do-manager-v1.md'), doManagerArtifact(implementationHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function implementationArtifact(changedFiles: ChangedFileFixture[]): string {
+  const changedFileEntries = changedFiles
+    .map((changedFile) => `  - ref: ${changedFile.ref}\n    hash: ${changedFile.hash}`)
+    .join('\n');
+  return `---
+contract: sdd-do-implementation-artifact-v1
+branch: master
+stage: do
+kind: implementation_evidence
+producer: implementer
+changedFiles:
+${changedFileEntries}
+---
+
+# Implementation Evidence
+
+Changed files were produced by the implementer.
+`;
+}
+
+function codeReviewArtifact(implementationHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-do-code-review-artifact-v1
+branch: master
+stage: do
+kind: code_review
+producer: code-reviewer
+targetRef: .sdd/runs/master/do/implementation-v1.md
+targetHash: ${implementationHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Code Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function doManagerArtifact(implementationHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-do-manager-artifact-v1
+branch: master
+stage: do
+kind: manager_closure_request
+producer: do-manager
+targetRef: .sdd/runs/master/do/implementation-v1.md
+targetHash: ${implementationHash}
+reviewRef: .sdd/runs/master/do/code-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Do Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+async function writeTestStageArtifacts(root: string, options: { omitContract?: boolean; omitExecution?: boolean; omitValidation?: boolean; executionStatus?: 'passed' | 'failed'; validationStatus?: 'passed' | 'failed'; exitCode?: number; acceptanceMapped?: boolean; omitReview?: boolean; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'test');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'test', ['.sdd/runs/master/test/test-execution-v1.md', '.sdd/runs/master/test/validation-v1.md', '.sdd/runs/master/test/test-review-v1.md', '.sdd/runs/master/test/test-manager-v1.md']);
+  }
+  const execution = testExecutionArtifact(options.executionStatus ?? 'passed', options.exitCode ?? 0);
+  const executionHash = hashDocumentContent(execution);
+  if (!options.omitExecution) {
+    await writeFile(path.join(dir, 'test-execution-v1.md'), execution, 'utf8');
+  }
+  const validation = validationEvidenceArtifact(executionHash, options.validationStatus ?? 'passed', options.acceptanceMapped ?? true);
+  const validationHash = hashDocumentContent(validation);
+  if (!options.omitValidation) {
+    await writeFile(path.join(dir, 'validation-v1.md'), validation, 'utf8');
+  }
+  const review = testReviewArtifact(validationHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'test-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'test-manager-v1.md'), testManagerArtifact(validationHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function testExecutionArtifact(status: 'passed' | 'failed', exitCode: number): string {
+  return `---
+contract: sdd-test-execution-artifact-v1
+branch: master
+stage: test
+kind: test_execution
+producer: test-runner
+status: ${status}
+exitCode: ${exitCode}
+---
+
+# Test Execution
+
+Status: ${status}.
+`;
+}
+
+function validationEvidenceArtifact(executionHash: string, status: 'passed' | 'failed', acceptanceMapped: boolean): string {
+  return `---
+contract: sdd-test-validation-artifact-v1
+branch: master
+stage: test
+kind: validation_evidence
+producer: validator
+executionRef: .sdd/runs/master/test/test-execution-v1.md
+executionHash: ${executionHash}
+status: ${status}
+acceptanceMapped: ${acceptanceMapped}
+---
+
+# Validation Evidence
+
+Acceptance mapped: ${acceptanceMapped}.
+`;
+}
+
+function testReviewArtifact(validationHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-test-review-artifact-v1
+branch: master
+stage: test
+kind: test_review
+producer: test-reviewer
+targetRef: .sdd/runs/master/test/validation-v1.md
+targetHash: ${validationHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Test Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function testManagerArtifact(validationHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-test-manager-artifact-v1
+branch: master
+stage: test
+kind: manager_closure_request
+producer: test-manager
+targetRef: .sdd/runs/master/test/validation-v1.md
+targetHash: ${validationHash}
+reviewRef: .sdd/runs/master/test/test-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Test Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+async function writeGoalVerifyStageArtifacts(root: string, options: { omitContract?: boolean; omitVerification?: boolean; status?: 'passed' | 'failed'; coverageComplete?: boolean; durableGapCount?: number; openGapCount?: number; omitReview?: boolean; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'goal-verify');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'goal-verify', ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/goal-verify/goal-review-v1.md', '.sdd/runs/master/goal-verify/goal-verify-manager-v1.md']);
+  }
+  const verification = goalVerificationArtifact(options.status ?? 'passed', options.coverageComplete ?? true, options.durableGapCount ?? 0, options.openGapCount ?? 0);
+  const verificationHash = hashDocumentContent(verification);
+  if (!options.omitVerification) {
+    await writeFile(path.join(dir, 'goal-verification-v1.md'), verification, 'utf8');
+  }
+  const review = goalReviewArtifact(verificationHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'goal-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'goal-verify-manager-v1.md'), goalVerifyManagerArtifact(verificationHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function goalVerificationArtifact(status: 'passed' | 'failed', coverageComplete: boolean, durableGapCount: number, openGapCount: number): string {
+  return `---
+contract: sdd-goal-verify-verification-artifact-v1
+branch: master
+stage: goal-verify
+kind: goal_verification
+producer: goal-validator
+status: ${status}
+coverageComplete: ${coverageComplete}
+durableGapCount: ${durableGapCount}
+openGapCount: ${openGapCount}
+---
+
+# Goal Verification
+
+Coverage complete: ${coverageComplete}.
+`;
+}
+
+function goalReviewArtifact(verificationHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-goal-verify-review-artifact-v1
+branch: master
+stage: goal-verify
+kind: goal_review
+producer: goal-reviewer
+targetRef: .sdd/runs/master/goal-verify/goal-verification-v1.md
+targetHash: ${verificationHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Goal Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function goalVerifyManagerArtifact(verificationHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-goal-verify-manager-artifact-v1
+branch: master
+stage: goal-verify
+kind: manager_closure_request
+producer: goal-verify-manager
+targetRef: .sdd/runs/master/goal-verify/goal-verification-v1.md
+targetHash: ${verificationHash}
+reviewRef: .sdd/runs/master/goal-verify/goal-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Goal Verify Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+
+async function writeShipStageArtifacts(root: string, options: { omitContract?: boolean; omitReadiness?: boolean; omitReview?: boolean; status?: 'ready' | 'blocked'; doctorBlockerCount?: number; capabilityBlockerCount?: number; repairBlockerCount?: number; gapBlockerCount?: number; migrationBlockerCount?: number; release?: { ref: string; hash: string }; authorityAttempts?: string[]; verdict?: SpecReviewResult['verdict']; blockingCount?: number; recommendation?: SpecManagerCoordinationRecord['recommendation'] }): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', 'ship');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'ship', ['.sdd/runs/master/ship/ship-readiness-v1.md', '.sdd/runs/master/ship/release-review-v1.md', '.sdd/runs/master/ship/ship-manager-v1.md', 'specs/master/release.md']);
+  }
+  const readiness = shipReadinessArtifact({
+    status: options.status ?? 'ready',
+    doctorBlockerCount: options.doctorBlockerCount ?? 0,
+    capabilityBlockerCount: options.capabilityBlockerCount ?? 0,
+    repairBlockerCount: options.repairBlockerCount ?? 0,
+    gapBlockerCount: options.gapBlockerCount ?? 0,
+    migrationBlockerCount: options.migrationBlockerCount ?? 0,
+    release: options.release,
+    authorityAttempts: options.authorityAttempts ?? []
+  });
+  const readinessHash = hashDocumentContent(readiness);
+  if (!options.omitReadiness) {
+    await writeFile(path.join(dir, 'ship-readiness-v1.md'), readiness, 'utf8');
+  }
+  const review = shipReleaseReviewArtifact(readinessHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'release-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'ship-manager-v1.md'), shipManagerArtifact(readinessHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function shipReadinessArtifact(options: { status: 'ready' | 'blocked'; doctorBlockerCount: number; capabilityBlockerCount: number; repairBlockerCount: number; gapBlockerCount: number; migrationBlockerCount: number; release?: { ref: string; hash: string }; authorityAttempts: string[] }): string {
+  const releaseLines = options.release ? `releaseRef: ${options.release.ref}\nreleaseHash: ${options.release.hash}\n` : '';
+  const authorityLines = options.authorityAttempts.length > 0
+    ? `authorityAttempts:\n${options.authorityAttempts.map((attempt) => `  - ${attempt}`).join('\n')}\n`
+    : '';
+  return `---
+contract: sdd-ship-readiness-artifact-v1
+branch: master
+stage: ship
+kind: ship_readiness
+producer: ship-validator
+status: ${options.status}
+doctorBlockerCount: ${options.doctorBlockerCount}
+capabilityBlockerCount: ${options.capabilityBlockerCount}
+repairBlockerCount: ${options.repairBlockerCount}
+gapBlockerCount: ${options.gapBlockerCount}
+migrationBlockerCount: ${options.migrationBlockerCount}
+${releaseLines}${authorityLines}---
+
+# Ship Readiness
+
+Status: ${options.status}.
+`;
+}
+
+function shipReleaseReviewArtifact(readinessHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-ship-release-review-artifact-v1
+branch: master
+stage: ship
+kind: release_review
+producer: release-reviewer
+targetRef: .sdd/runs/master/ship/ship-readiness-v1.md
+targetHash: ${readinessHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Release Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function shipManagerArtifact(readinessHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-ship-manager-artifact-v1
+branch: master
+stage: ship
+kind: manager_closure_request
+producer: ship-manager
+targetRef: .sdd/runs/master/ship/ship-readiness-v1.md
+targetHash: ${readinessHash}
+reviewRef: .sdd/runs/master/ship/release-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Ship Manager Coordination
+
+Recommendation: ${recommendation}.
+`;
+}
+
+function reviewedSpec(): string {
+  return `---
+contract: sdd-spec-doc-v1
+title: Reviewed test spec
+---
+
+# Reviewed Test Spec
+
+This spec is produced by the spec-stage test fixture and must be preserved by runtime.
+`;
+}
+
+function reviewedPlan(): string {
+  return `---
+contract: sdd-plan-doc-v1
+title: Reviewed test plan
+---
+
+# Reviewed Test Plan
+
+This plan is produced by the plan-stage test fixture and must be preserved by runtime.
+`;
+}
+
+function reviewedTasks(options: { duplicate?: boolean } = {}): string {
+  const secondId = options.duplicate ? 'T1' : 'T2';
+  return `---
+contract: sdd-tasks-doc-v1
+title: Reviewed test tasks
+---
+
+# Reviewed Test Tasks
+
+## T1 — Implement first reviewed task
+
+\`\`\`sdd-task
+id: T1
+status: pending
+wave: 1
+implementation_wave: core
+validation_batch: core
+validation_timing: task_end
+requires_verify_before_next: true
+change_surface: backend_only
+depends_on: []
+affected_files:
+  - packages/core/src/example.ts
+validation:
+  - npm test
+risk: []
+acceptance_refs:
+  - AC-1
+plan_refs:
+  - PLAN-1
+file_ownership: []
+agent_fit: []
+verification_availability: []
+autonomy: supervised
+allowed_agents: []
+required_artifacts: []
+\`\`\`
+
+#### Boundary
+
+Implement only the reviewed T1 boundary.
+
+#### Acceptance
+
+- AC-1 is satisfied.
+
+## ${secondId} — Implement second reviewed task
+
+\`\`\`sdd-task
+id: ${secondId}
+status: pending
+wave: 1
+implementation_wave: core
+validation_batch: core
+validation_timing: task_end
+requires_verify_before_next: true
+change_surface: backend_only
+depends_on: []
+affected_files:
+  - packages/core/src/example-2.ts
+validation:
+  - npm test
+risk: []
+acceptance_refs:
+  - AC-2
+plan_refs:
+  - PLAN-2
+file_ownership: []
+agent_fit: []
+verification_availability: []
+autonomy: supervised
+allowed_agents: []
+required_artifacts: []
+\`\`\`
+
+#### Boundary
+
+Implement only the reviewed ${secondId} boundary.
+
+#### Acceptance
+
+- AC-2 is satisfied.
+`;
+}
+
+function reviewedVerify(tasksContent: string, options: { omitTaskId?: string } = {}): string {
+  const taskRows = ['T1', 'T2']
+    .filter((taskId) => taskId !== options.omitTaskId)
+    .map((taskId) => `| ${taskId} | AC-${taskId.slice(1)} | npm test | validation-report.md | available |`)
+    .join('\n');
+  const batches = ['T1', 'T2']
+    .filter((taskId) => taskId !== options.omitTaskId)
+    .map((taskId) => `  - task: ${taskId}`)
+    .join('\n');
+  return `---
+contract: ${VERIFY_DOCUMENT_CONTRACT_VERSION}
+version: 1.0.0
+branch: master
+author_role: verification-designer
+independent_from_roles:
+  - task-planner
+  - implementer
+---
+
+# Verify Contract: master
+
+## 1. Purpose
+
+Reviewed verification contract produced by the verifies-stage fixture.
+
+## 2. Verification Batches
+
+verification_batches:
+${batches}
+
+## 3. Task Verification Matrix
+
+| Task | Acceptance refs | Validation commands | Required artifacts | Verification availability |
+|---|---|---|---|---|
+${taskRows}
+
+## 4. Verification Rules
+
+- PASS requires policy-backed acceptance evidence.
+
+## 5. Out of Scope
+
+- This document does not authorize publish, push, tag, or release actions.
+`;
+}
+
+interface StageArtifactPairCase {
+  stage: SddStage;
+  reviewFile: string;
+  managerFile: string;
+  reviewKind: string;
+  reviewProducer: string;
+  managerProducer: string;
+  reviewContract: string;
+  managerContract: string;
+  targetRef: string;
+}
+
+const stageArtifactPairCases: StageArtifactPairCase[] = [
+  {
+    stage: 'tasks',
+    reviewFile: 'tasks-review-v1.md',
+    managerFile: 'tasks-manager-v1.md',
+    reviewKind: 'tasks_review',
+    reviewProducer: 'tasks-reviewer',
+    managerProducer: 'tasks-manager',
+    reviewContract: 'sdd-tasks-review-artifact-v1',
+    managerContract: 'sdd-tasks-manager-artifact-v1',
+    targetRef: 'specs/master/tasks.md'
+  },
+  {
+    stage: 'verifies',
+    reviewFile: 'verifies-review-v1.md',
+    managerFile: 'verifies-manager-v1.md',
+    reviewKind: 'verifies_review',
+    reviewProducer: 'verifies-reviewer',
+    managerProducer: 'verifies-manager',
+    reviewContract: 'sdd-verifies-review-artifact-v1',
+    managerContract: 'sdd-verifies-manager-artifact-v1',
+    targetRef: 'specs/master/verify.md'
+  },
+  {
+    stage: 'do',
+    reviewFile: 'code-review-v1.md',
+    managerFile: 'do-manager-v1.md',
+    reviewKind: 'code_review',
+    reviewProducer: 'code-reviewer',
+    managerProducer: 'do-manager',
+    reviewContract: 'sdd-do-code-review-artifact-v1',
+    managerContract: 'sdd-do-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/do/implementation-v1.md'
+  },
+  {
+    stage: 'test',
+    reviewFile: 'test-review-v1.md',
+    managerFile: 'test-manager-v1.md',
+    reviewKind: 'test_review',
+    reviewProducer: 'test-reviewer',
+    managerProducer: 'test-manager',
+    reviewContract: 'sdd-test-review-artifact-v1',
+    managerContract: 'sdd-test-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/test/test-execution-v1.md'
+  },
+  {
+    stage: 'goal-verify',
+    reviewFile: 'goal-review-v1.md',
+    managerFile: 'goal-verify-manager-v1.md',
+    reviewKind: 'goal_review',
+    reviewProducer: 'goal-reviewer',
+    managerProducer: 'goal-verify-manager',
+    reviewContract: 'sdd-goal-verify-review-artifact-v1',
+    managerContract: 'sdd-goal-verify-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/goal-verify/goal-verification-v1.md'
+  },
+  {
+    stage: 'ship',
+    reviewFile: 'release-review-v1.md',
+    managerFile: 'ship-manager-v1.md',
+    reviewKind: 'release_review',
+    reviewProducer: 'release-reviewer',
+    managerProducer: 'ship-manager',
+    reviewContract: 'sdd-ship-release-review-artifact-v1',
+    managerContract: 'sdd-ship-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/ship/ship-readiness-v1.md'
+  }
+];
+
+async function writeStageArtifactPair(root: string, stageCase: StageArtifactPairCase): Promise<void> {
+  const dir = path.join(root, '.sdd', 'runs', 'master', stageCase.stage);
+  await mkdir(dir, { recursive: true });
+  const targetHash = `target-hash-${stageCase.stage}`;
+  const review = stageReviewArtifact(stageCase, targetHash);
+  const reviewHash = hashDocumentContent(review);
+  await writeFile(path.join(dir, stageCase.reviewFile), review, 'utf8');
+  await writeFile(path.join(dir, stageCase.managerFile), stageManagerArtifact(stageCase, targetHash, reviewHash), 'utf8');
+}
+
+function stageReviewArtifact(stageCase: StageArtifactPairCase, targetHash: string): string {
+  return `---
+contract: ${stageCase.reviewContract}
+branch: master
+stage: ${stageCase.stage}
+kind: ${stageCase.reviewKind}
+producer: ${stageCase.reviewProducer}
+targetRef: ${stageCase.targetRef}
+targetHash: ${targetHash}
+verdict: approved
+findingCount: 0
+blockingCount: 0
+---
+
+# ${stageCase.stage} Review
+
+Verdict: approved.
+`;
+}
+
+function stageManagerArtifact(stageCase: StageArtifactPairCase, targetHash: string, reviewHash: string): string {
+  return `---
+contract: ${stageCase.managerContract}
+branch: master
+stage: ${stageCase.stage}
+kind: manager_closure_request
+producer: ${stageCase.managerProducer}
+targetRef: ${stageCase.targetRef}
+targetHash: ${targetHash}
+reviewRef: .sdd/runs/master/${stageCase.stage}/${stageCase.reviewFile}
+reviewHash: ${reviewHash}
+recommendation: close_stage
+---
+
+# ${stageCase.stage} Manager Coordination
+
+Recommendation: close_stage.
+`;
+}
+
+function testStageRun(id: string, scope: { branch: string }, status: 'completed' | 'failed', timestamp: string) {
+  return {
+    contract: 'sdd-stage-run-v1' as const,
+    id,
+    scope,
+    stage: 'do' as const,
+    ownerAgent: 'do-manager',
+    coMainAgents: ['implementer', 'code-reviewer'],
+    status,
+    inputRefs: [],
+    outputRefs: status === 'completed' ? [ref('artifact', '.sdd/runs/feature/do/implementation-v1.md', 'hash')] : [],
+    decisionRefs: [],
+    blockingReasons: status === 'failed' ? ['Later diagnostic rejection must not downgrade completed stage.'] : [],
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+}
+
+function ref(kind: RuntimeRefKind, value: string, hash?: string) {
+  return hash ? { kind, ref: value, hash } : { kind, ref: value };
+}
+
+async function markdownSnapshot(root: string): Promise<Map<string, string>> {
+  const entries = new Map<string, string>();
+  await collectMarkdownSnapshot(root, root, entries);
+  return entries;
+}
+
+async function collectMarkdownSnapshot(root: string, dir: string, entries: Map<string, string>): Promise<void> {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const absolute = path.join(dir, entry.name);
+    const relative = path.relative(root, absolute).replace(/\\/g, '/');
+    if (entry.isDirectory()) {
+      await collectMarkdownSnapshot(root, absolute, entries);
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      entries.set(relative, hashDocumentContent(await readFile(absolute, 'utf8')));
+    }
+  }
+}