sdd-agent-platform 0.4.1 → 0.5.0

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

@@ -0,0 +1,2964 @@
+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, 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,
+  buildPlanStageWorkOrder,
+  buildShipStageWorkOrder,
+  buildSpecStageWorkOrder,
+  buildTasksStageWorkOrder,
+  buildExecuteStageWorkOrder,
+  deriveSpecCollaborationProfile,
+  inspectFullStageChain,
+  inspectSpecCollaborationHealth,
+  reconcileExecuteCollaborationClosure,
+  reconcileShipCollaborationClosure,
+  reconcilePlanCollaborationClosure,
+  reconcileTasksCollaborationClosure,
+  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 { recordTaskExecutionProjectionBundleFromAcceptedTasks } from './task-execution-contract.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', ['execute', 'ship']), 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', 'execute', '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-reviewer']);
+  assert.deepEqual(workOrder.requiredOutputKinds, ['scout_context', 'spec_review', 'manager_closure_request']);
+  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('execute-completed', scope, 'completed', '2026-01-01T00:00:00.000Z');
+    const rejected = testStageRun('execute-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, 'execute');
+
+    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', 'execute', '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', 'tasks']), 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', 'execute', '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', 'execute', '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', 'execute', '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('spec closure does not require spec-reviewer approval as runtime truth', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']), generatedAt);
+  const team = stageClosure(profile);
+  const closureRequest = { ...team.closureRequest, reviewRefs: [], reviewResults: [] };
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest, generatedAt });
+
+  assert.equal(result.health, 'ready_for_plan');
+  assert.equal(result.rejection, null);
+  assert.equal(result.nextActions[0]?.reasonCode, 'stage_ready');
+});
+
+test('spec closure requires runtime close boundary facts for close-stage recommendation', () => {
+  const profile = deriveSpecCollaborationProfile(decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']), generatedAt);
+  const team = stageClosure(profile);
+  const closureRequest = { ...team.closureRequest, runtimeCloseBoundaryFacts: null };
+  const result = adjudicateSpecStageClosureRequest({ profile, closureRequest, generatedAt });
+
+  assert.equal(result.health, 'rejected');
+  assert.equal(result.rejection?.reasonCode, 'missing_refs');
+});
+
+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', 'execute', '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, 5);
+    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 final spec document without spec-stage side evidence', 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');
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-ready-closure',
+      outputCloseRequest: outputCloseRequest()
+    });
+    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.deepEqual(closure.artifactRefs, []);
+    assert.equal(registered.length, 0);
+    assert.equal(registeredContracts.length, 0);
+    assert.equal(closure.registeredCollaborationContracts.length, 0);
+    assert.equal(closure.adjudication.closureRefs?.collaborationContractRef, null);
+    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('spec closure rejects structurally complete but shallow spec document', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-closure-shallow-'));
+  try {
+    await initProject(root);
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), shallowSpec(), 'utf8');
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-shallow-spec-closure',
+      outputCloseRequest: outputCloseRequest()
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'not_accepted_wrong_ref');
+    assert.match(closure.adjudication.rejection?.explanation ?? '', /blocker:spec\.downstream_guesswork\.plan_would_rediscover_requirements/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready structural closure does not require collaboration contract for spec 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');
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-missing-contract-closure',
+      outputCloseRequest: outputCloseRequest()
+    });
+    const handoff = await inspectWorkflowStageHandoff(root, 'master');
+    const registeredContracts = await listRuntimeStageCollaborationContracts(root, { branchSlug: 'master', stage: 'spec' });
+
+    assert.equal(closure.adjudication.health, 'ready_for_plan');
+    assert.equal(closure.adjudication.closureRefs?.specAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedSpecRef?.ref, 'specs/master/spec.md');
+    assert.equal(closure.acceptedSpecRef?.hash, specHash);
+    assert.equal(registeredContracts.length, 0);
+    assert.equal(handoff.status, 'fresh');
+  } 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-review-agent/);
+  } 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 });
+      const registeredKinds = registered.map((artifact) => artifact.kind);
+
+      assert.equal(registeredKinds.includes(stageCase.reviewKind), true);
+      assert.equal(registeredKinds.includes('manager_closure_request'), true);
+      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', 'tasks']);
+    const profile = deriveSpecCollaborationProfile(riskDecision, generatedAt);
+    const blockingItem = candidateItem('before-plan-question', 'blocking_ambiguity');
+    const closureRequest = stageClosure(profile, { items: [blockingItem] }).closureRequest;
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-clarification-closure',
+      artifactRefs: ['.sdd/runs/master/spec/scout.md', '.sdd/runs/master/spec/spec-review-v1.md', '.sdd/runs/master/spec/spec-manager-v1.md'],
+      closureRequest,
+    });
+    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');
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    const profile = deriveSpecCollaborationProfile(riskDecision, generatedAt);
+    const staleClosureRequest = stageClosure(profile).closureRequest;
+
+    const closure = await reconcileSpecCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-hash-mismatch-closure',
+      closureRequest: staleClosureRequest
+    });
+    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', 'execute', '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');
+
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-ready-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    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(), []);
+    assert.equal(handoff?.payload.fromStage, 'plan');
+    assert.equal(handoff?.payload.toStage, 'tasks');
+    const acceptedPlanInputRef = handoff?.payload.requiredInputRefs.find((inputRef) => inputRef.ref === 'specs/master/plan.md');
+    assert.equal(acceptedPlanInputRef?.ref, 'specs/master/plan.md');
+    assert.equal(acceptedPlanInputRef?.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 accepts warning-only artifact-depth diagnostics without close trap', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-warning-only-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-warning-only');
+    const planContent = reviewedPlan()
+      .replace("Plan close accepts final plan.md V3 ref/hash and 'PlanRuntimeCloseBoundaryFacts'. No HTTP endpoint exists; the API surface is the TypeScript function contract plus runtime-store projection schema.", "The API shape uses the existing report endpoint. SQL uses existing joins and source fields selected by the accepted plan.")
+      .replace("No persisted business data is changed, but runtime projection state must remain consistent across close, rejection, and handoff publication.", "The database query reads report tables and aggregates rows.");
+    const planHash = hashDocumentContent(planContent);
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-warning-only-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'ready_for_tasks');
+    assert.equal(closure.acceptedPlanRef?.hash, planHash);
+    assert.equal(handoff?.payload.toStage, 'tasks');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects explicit implementation-time design decisions as blocker', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-design-leak-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-design-leak');
+    const planContent = reviewedPlan().replace("Plan close accepts final plan.md V3 ref/hash and 'PlanRuntimeCloseBoundaryFacts'. No HTTP endpoint exists; the API surface is the TypeScript function contract plus runtime-store projection schema.", 'Implementation will determine the final SQL join and response fields.');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-design-leak-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.match(closure.adjudication.rejection?.explanation ?? '', /blocker:plan\.downstream_guesswork\.tasks_or_execute_would_redesign/);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure accepts final plan document without plan-review side evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-without-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-without-review');
+    const planContent = reviewedPlan();
+    const planHash = hashDocumentContent(planContent);
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-without-review-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    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?.hash, planHash);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), []);
+    assert.equal(handoff?.payload.requiredInputRefs.find((inputRef) => inputRef.ref === 'specs/master/plan.md')?.hash, planHash);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure keeps side artifacts out of plan to tasks handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-side-artifacts-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-side-artifacts');
+    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-side-artifacts-closure',
+      artifactRefs: ['.sdd/runs/master/plan/plan-review-v1.md', '.sdd/runs/master/plan/plan-manager-v1.md'],
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'plan', 'tasks');
+
+    assert.equal(closure.adjudication.health, 'ready_for_tasks');
+    assert.deepEqual(handoff?.payload.outputRefs.map((outputRef) => outputRef.ref), ['specs/master/plan.md']);
+    assert.deepEqual(handoff?.payload.evidenceRefs, []);
+    assert.equal(handoff?.payload.requiredInputRefs.find((inputRef) => inputRef.ref === 'specs/master/spec.md')?.kind, 'document');
+    assert.equal(handoff?.payload.requiredInputRefs.find((inputRef) => inputRef.ref === 'specs/master/plan.md')?.hash, planHash);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects numbered forbidden task sections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-numbered-task-section-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-numbered-task-section');
+    const planContent = `${reviewedPlan()}\n## 18. Task Units\n\nT1 should not be owned by plan.\n`;
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-numbered-task-section-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_wrong_ref');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /forbidden task/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects task unit leakage inside allowed sections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-task-leakage-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-task-leakage');
+    const planContent = reviewedPlan().replace('Tasks must consume accepted spec and accepted plan refs only; task-stage owns task IDs, execution waves, dependency graph, and per-task acceptance.', 'Tasks must consume accepted spec and accepted plan refs only; task-stage owns task IDs, execution waves, dependency graph, and per-task acceptance.\n\n### T1: leaked task\nsourceRequirements:\n  - REQ-1');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-task-leakage-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_wrong_ref');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /forbidden task/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('plan closure rejects checkpoint that is not ready for tasks', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-checkpoint-not-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-checkpoint-not-ready');
+    const planContent = reviewedPlan().replace('- ready_for_tasks: true', '- ready_for_tasks: false');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-checkpoint-not-ready-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.planAcceptanceStatus, 'not_accepted_wrong_ref');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /ready_for_tasks/);
+  } 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', 'execute', 'ship']);
+    const planContent = reviewedPlan();
+
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), reviewedSpec(), 'utf8');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-missing-upstream-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    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', 'execute', '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();
+
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), planContent, 'utf8');
+
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-stale-upstream-closure',
+      outputCloseRequest: planOutputCloseRequest()
+    });
+    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 missing output close request without recording handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-plan-closure-missing-output-request-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedSpecClosure(root, riskDecision, 'run-spec-ready-for-plan-missing-output-request');
+    await writeFile(path.join(root, 'specs', 'master', 'plan.md'), reviewedPlan(), 'utf8');
+
+    const closure = await reconcilePlanCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-plan-missing-output-request-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_wrong_ref');
+    assert.equal(closure.acceptedPlanRef, null);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ready tasks closure accepts final tasks document and records tasks to execute handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', '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');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-ready-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    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', 'execute');
+
+    assert.equal(closure.adjudication.health, 'ready_for_execute');
+    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(), []);
+    assert.equal(handoff?.payload.fromStage, 'tasks');
+    assert.equal(handoff?.payload.toStage, 'execute');
+    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 accepts warning-only artifact-depth diagnostics without close trap', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-warning-only-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-warning-only');
+    const tasksContent = warningOnlyTasks();
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-warning-only-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    assert.equal(closure.adjudication.health, 'ready_for_execute');
+    assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+    assert.equal(handoff?.payload.toStage, 'execute');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure accepts semantic section aliases without fixed-heading close trap', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-section-aliases-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-section-aliases');
+    const tasksContent = reviewedTasks()
+      .replace('## 1. Split Basis', '## 1. Work Unit Split Basis')
+      .replace('## 3. Implementation Tasks', '## 3. Implementation Work Units')
+      .replace('## 4. Validation Tasks', '## 4. Validation Work Units')
+      .replace('## 5. Task Dependencies and Handoff', '## 5. Dependencies and Validation Handoff')
+      .replace('## 7. Open Execution Questions', '## 7. Open Questions')
+      .replace('## 8. Tasks Close Quality Evidence', '## 8. Close Quality Evidence');
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-section-aliases-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+
+    assert.equal(closure.adjudication.health, 'ready_for_execute');
+    assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure rejects ambiguous many-to-one validation mapping', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-ambiguous-validation-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-ambiguous-validation');
+    const tasksContent = reviewedTasks().replace('validationHandoff:\n  - T4', 'validationHandoff:\n  - T3');
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-ambiguous-validation-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.match(closure.adjudication.rejection?.explanation ?? '', /must validate exactly|must hand off only/);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure accepts broad execution slice after task-review reconciliation', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-reviewed-broad-slice-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-reviewed-broad-slice');
+    const tasksContent = oversizedCoarseTasks();
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-reviewed-broad-slice-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    assert.equal(closure.adjudication.health, 'ready_for_execute');
+    assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+    assert.equal(handoff?.payload.toStage, 'execute');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure rejects missing task-review reconciliation evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-missing-review-reconciliation-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-missing-review-reconciliation');
+    const tasksContent = reviewedTasks()
+      .replace('- task-review-agent verdict: approved\n', '')
+      .replace('- review_reconciliation: blocking findings resolved; review_blockers_remaining: []\n', '');
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-missing-review-reconciliation-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.match(closure.adjudication.rejection?.explanation ?? '', /task-review-agent verdict and tasks-manager review reconciliation/);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure rejects manager-declared execution guesswork before execute', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-execution-guesswork-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-execution-guesswork');
+    const tasksContent = warningOnlyTasks().replace('- downstream_execution_guesswork_remaining: []', '- downstream_execution_guesswork_remaining: ["SQL join and response fields unresolved"]');
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-execution-guesswork-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.match(closure.adjudication.rejection?.explanation ?? '', /downstream_execution_guesswork_remaining/);
+    assert.equal(handoff, null);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('tasks closure accepts final tasks document without tasks-review side evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-without-review-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-without-review');
+    const tasksContent = reviewedTasks();
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-without-review-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'tasks' });
+
+    assert.equal(closure.adjudication.health, 'ready_for_execute');
+    assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'accepted');
+    assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), []);
+    assert.equal(handoff?.payload.toStage, 'execute');
+  } 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', 'execute', '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();
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-stale-upstream-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    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 stale accepted spec from plan handoff', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-tasks-closure-stale-spec-upstream-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-stale-spec');
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), `${reviewedSpec()}\nStale spec after plan handoff.\n`, 'utf8');
+    const tasksContent = reviewedTasks();
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-stale-spec-upstream-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    assert.equal(closure.adjudication.health, 'rejected');
+    assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'not_accepted_missing_upstream');
+    assert.match(closure.adjudication.closureRefs.reasons.join(' '), /spec hash is 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', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-plan-ready-for-tasks-duplicate');
+    const tasksContent = reviewedTasks({ duplicate: true });
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+
+    const closure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-tasks-duplicate-closure',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'tasks', 'execute');
+
+    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('execute closure accepts completed task and validation projections without execute side evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-execute-closure-projection-ready-'));
+  try {
+    await initProject(root);
+    const riskDecision = decision('full', ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    await writeAcceptedPlanClosure(root, riskDecision, 'run-execute-projection-plan-ready');
+    const tasksContent = reviewedTasks({ completed: true, includeValidation: true });
+    const tasksHash = hashDocumentContent(tasksContent);
+    await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+    const tasksClosure = await reconcileTasksCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-execute-projection-tasks-ready',
+      outputCloseRequest: tasksOutputCloseRequest()
+    });
+    assert.equal(tasksClosure.acceptedTasksRef?.hash, tasksHash);
+    await recordTaskExecutionProjectionBundleFromAcceptedTasks(root, {
+      branch: 'master',
+      acceptedTasksRef: tasksClosure.acceptedTasksRef as RuntimeRef,
+      acceptedTasksHash: tasksHash,
+      generatedAt
+    });
+
+    const executeClosure = await reconcileExecuteCollaborationClosure(root, {
+      decision: riskDecision,
+      generatedAt,
+      runId: 'run-execute-projection-ready'
+    });
+    const handoff = await readWorkflowHandoffProjection(root, riskDecision.scope, 'execute', 'ship');
+    const registered = await listRuntimeStageArtifacts(root, { branchSlug: 'master', stage: 'execute' });
+
+    assert.equal(executeClosure.adjudication.health, 'ready_for_ship');
+    assert.equal(executeClosure.adjudication.closureRefs.executeAcceptanceStatus, 'accepted');
+    assert.equal(executeClosure.acceptedExecuteRef?.ref, 'phase10_3_task_dependency_graph_projection:master');
+    assert.deepEqual(registered.map((artifact) => artifact.kind).sort(), []);
+    assert.equal(handoff?.payload.fromStage, 'execute');
+    assert.equal(handoff?.payload.toStage, 'ship');
+  } 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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-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', 'execute', '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 writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-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', 'execute', 'ship']);
+    await writeAcceptedTasksClosure(root, riskDecision, 'run-full-chain-ready-for-execute');
+    const chain = await inspectFullStageChain(root, 'master');
+
+    assert.equal(chain.status, 'partial');
+    assert.equal(chain.finalHealth, 'ready_for_execute');
+    assert.equal(chain.projectionCounts.adjudications, 3);
+    assert.equal(chain.projectionCounts.completedStages, 3);
+    assert.equal(chain.projectionCounts.validatedCollaborationContracts, 0);
+    assert.equal(chain.projectionCounts.handoffs, 3);
+    assert.deepEqual(chain.stages.map((stage) => stage.stage), ['spec', 'plan', 'tasks', 'execute', 'ship']);
+    const acceptedRefs = chain.stages.map((stage) => stage.acceptedRef).filter((ref): ref is RuntimeRef => ref !== null);
+    assert.equal(acceptedRefs.every((ref) => !ref.ref.startsWith('runs/')), true);
+    assert.equal(acceptedRefs.every((ref) => ref.ref.includes('evidence/artifacts') === false), true);
+    assert.equal(acceptedRefs.every((ref) => ref.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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-markdown-immutable-execute-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', outputCloseRequest: outputCloseRequest() });
+    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 reconcileExecuteCollaborationClosure(root, { decision: riskDecision, generatedAt, runId: 'run-markdown-immutable-replay-execute' });
+    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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-ready-for-ship-stale');
+    await writeFile(path.join(root, '.sdd', 'runs', 'master', 'execute', 'evidence-judgment-v1.md'), `${evidenceJudgmentArtifact('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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-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', 'execute', 'ship']);
+    await writeAcceptedExecuteClosure(root, riskDecision, 'run-execute-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', 'execute', '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-manager',
+    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',
+    runtimeCloseBoundaryFacts: unresolvedAmbiguityIds.length > 0 ? null : {
+      contract: 'sdd-spec-runtime-close-boundary-facts-v1',
+      scope: profile.scope,
+      finalSpecRef: { kind: 'document', ref: 'specs/master/spec.md', hash: 'test-spec-hash' },
+      finalSpecHash: 'test-spec-hash',
+      templateContract: 'sdd-spec-doc-v3',
+      blockingBeforePlanCount: 0,
+      sectionCloseDeclaration: 'present',
+      reviewSignal: 'present',
+      runtimeTruthOwner: 'Runtime Kernel'
+    },
+    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');
+  const closure = await reconcileSpecCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId,
+    outputCloseRequest: outputCloseRequest()
+  });
+  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');
+
+  const closure = await reconcilePlanCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId,
+    outputCloseRequest: planOutputCloseRequest()
+  });
+  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');
+  const closure = await reconcileTasksCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId,
+    outputCloseRequest: tasksOutputCloseRequest()
+  });
+  assert.equal(closure.adjudication.closureRefs.tasksAcceptanceStatus, 'accepted');
+  assert.equal(closure.acceptedTasksRef?.hash, tasksHash);
+}
+
+
+
+async function writeAcceptedExecuteClosure(root: string, riskDecision: LifecycleRiskDecision, runId: string): Promise<{ acceptedExecuteRef: RuntimeRef }> {
+  await writeAcceptedPlanClosure(root, riskDecision, `${runId}-plan`);
+  const tasksContent = reviewedTasks({ completed: true, includeValidation: true });
+  const tasksHash = hashDocumentContent(tasksContent);
+  await writeFile(path.join(root, 'specs', 'master', 'tasks.md'), tasksContent, 'utf8');
+  const tasksClosure = await reconcileTasksCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId: `${runId}-tasks`,
+    outputCloseRequest: tasksOutputCloseRequest()
+  });
+  assert.equal(tasksClosure.adjudication.closureRefs.tasksAcceptanceStatus, 'accepted');
+  assert.equal(tasksClosure.acceptedTasksRef?.hash, tasksHash);
+  await recordTaskExecutionProjectionBundleFromAcceptedTasks(root, {
+    branch: 'master',
+    acceptedTasksRef: tasksClosure.acceptedTasksRef as RuntimeRef,
+    acceptedTasksHash: tasksHash,
+    generatedAt
+  });
+  await writeExecuteEvidenceJudgmentArtifacts(root, {});
+  const closure = await reconcileExecuteCollaborationClosure(root, {
+    decision: riskDecision,
+    generatedAt,
+    runId
+  });
+  assert.equal(closure.adjudication.health, 'ready_for_ship');
+  assert.equal(closure.adjudication.closureRefs.executeAcceptanceStatus, 'accepted');
+  assert.equal(closure.adjudication.closureRefs.truthAlignmentProjectionRef?.kind, 'projection');
+  assert.ok(closure.acceptedExecuteRef);
+  return { acceptedExecuteRef: closure.acceptedExecuteRef };
+}
+
+
+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', 'execute', '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-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', 'execute', '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 === 'execute') return buildExecuteStageWorkOrder(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}
+finalSpecRef: specs/master/spec.md
+finalSpecHash: ${specHash}
+templateContract: sdd-spec-doc-v3
+blockingBeforePlanCount: 0
+sectionCloseDeclaration: present
+reviewSignal: present
+runtimeTruthOwner: Runtime Kernel
+---
+
+# 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-review-agent
+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: task-review-agent
+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 writeExecuteEvidenceJudgmentArtifacts(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', 'execute');
+  await mkdir(dir, { recursive: true });
+  if (!options.omitContract) {
+    await writeStageCollaborationContract(root, 'execute', ['.sdd/runs/master/execute/evidence-judgment-v1.md', '.sdd/runs/master/execute/evidence-judgment-review-v1.md', '.sdd/runs/master/execute/evidence-judgment-manager-v1.md']);
+  }
+  const verification = evidenceJudgmentArtifact(options.status ?? 'passed', options.coverageComplete ?? true, options.durableGapCount ?? 0, options.openGapCount ?? 0);
+  const verificationHash = hashDocumentContent(verification);
+  if (!options.omitVerification) {
+    await writeFile(path.join(dir, 'evidence-judgment-v1.md'), verification, 'utf8');
+  }
+  const review = evidenceReviewArtifact(verificationHash, options.verdict ?? 'approved', options.blockingCount ?? 0);
+  const reviewHash = hashDocumentContent(review);
+  if (!options.omitReview) {
+    await writeFile(path.join(dir, 'evidence-judgment-review-v1.md'), review, 'utf8');
+  }
+  await writeFile(path.join(dir, 'evidence-judgment-manager-v1.md'), evidenceJudgmentManagerArtifact(verificationHash, reviewHash, options.recommendation ?? 'close_stage'), 'utf8');
+}
+
+function evidenceJudgmentArtifact(status: 'passed' | 'failed', coverageComplete: boolean, durableGapCount: number, openGapCount: number): string {
+  return `---
+contract: sdd-execute-evidence-judgment-artifact-v1
+branch: master
+stage: execute
+kind: evidence_judgment
+producer: evidence-validator
+status: ${status}
+coverageComplete: ${coverageComplete}
+durableGapCount: ${durableGapCount}
+openGapCount: ${openGapCount}
+---
+
+# Evidence Judgment
+
+Coverage complete: ${coverageComplete}.
+`;
+}
+
+function evidenceReviewArtifact(verificationHash: string, verdict: SpecReviewResult['verdict'], blockingCount: number): string {
+  return `---
+contract: sdd-execute-evidence-judgment-review-artifact-v1
+branch: master
+stage: execute
+kind: evidence_review
+producer: evidence-reviewer
+targetRef: .sdd/runs/master/execute/evidence-judgment-v1.md
+targetHash: ${verificationHash}
+verdict: ${verdict}
+findingCount: ${blockingCount}
+blockingCount: ${blockingCount}
+---
+
+# Goal Review
+
+Verdict: ${verdict}.
+`;
+}
+
+function evidenceJudgmentManagerArtifact(verificationHash: string, reviewHash: string, recommendation: SpecManagerCoordinationRecord['recommendation']): string {
+  return `---
+contract: sdd-execute-manager-artifact-v1
+branch: master
+stage: execute
+kind: manager_closure_request
+producer: execute-manager
+targetRef: .sdd/runs/master/execute/evidence-judgment-v1.md
+targetHash: ${verificationHash}
+reviewRef: .sdd/runs/master/execute/evidence-judgment-review-v1.md
+reviewHash: ${reviewHash}
+recommendation: ${recommendation}
+---
+
+# Execute Evidence Judgment 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-v3
+title: Reviewed test spec
+---
+
+# Reviewed Test Spec
+
+## Problem Reframing / Intent Discovery
+
+Surface request, reframed problem, inferred real intent, and observable success are explicit for the reviewed fixture.
+
+## Change Delta
+
+Current behavior, desired behavior, delta, unchanged behavior, and non-goals are explicit.
+
+## Scope
+
+In Scope: reviewed spec closure. Out of Scope: implementation planning.
+
+## Requirements
+
+| ID | Requirement | Priority | Source |
+|---|---|---|---|
+| REQ-1 | Runtime close accepts the reviewed spec. | Must | test |
+
+## Acceptance Criteria / Evidence Targets
+
+| ID | Acceptance | Covers | Evidence Target | Priority |
+|---|---|---|---|---|
+| AC-1 | Runtime accepts the final spec ref and hash. | REQ-1 | stage close result | Must |
+
+## Definitions / Rules
+
+The final spec is the only primary runtime spec artifact.
+
+## Planning Constraints / Signals
+
+Plan consumes the accepted spec ref/hash only.
+
+## Open Questions / Ambiguity Ledger
+
+No blocking user decisions remain. Researchable uncertainty is resolved by scout evidence or explicitly logged. Safe assumptions are listed when used, and deferred questions are routed to plan, tasks, or execute verification.
+
+## Close Quality Evidence
+
+- requirement_review_sufficient: true
+- problem_reframed: true
+- domain_rules_confirmed_or_routed: true
+- acceptance_evidence_targets_defined: true
+- ambiguity_routed: true
+- downstream_business_guesswork_remaining: []
+- ready_for_plan: true
+`;
+}
+
+function shallowSpec(): string {
+  return `---
+contract: sdd-spec-doc-v3
+title: Shallow test spec
+---
+
+# Shallow Test Spec
+
+## Problem Reframing / Intent Discovery
+
+Do the requested change.
+
+## Change Delta
+
+Some behavior changes.
+
+## Scope
+
+In scope: change.
+
+## Requirements
+
+| ID | Requirement | Priority | Source |
+|---|---|---|---|
+| REQ-1 | Change the behavior. | Must | user |
+
+## Acceptance Criteria / Evidence Targets
+
+| ID | Acceptance | Covers | Priority |
+|---|---|---|---|
+| AC-1 | It works. | REQ-1 | Must |
+
+## Definitions / Rules
+
+None.
+
+## Planning Constraints / Signals
+
+None.
+
+## Open Questions / Ambiguity Ledger
+
+None.
+
+## Close Quality Evidence
+
+- problem_reframed: true
+`;
+}
+
+function outputCloseRequest(branch = 'master') {
+  return {
+    finalSpecRef: `specs/${branch}/spec.md`,
+    sectionCloseDeclaration: 'present',
+    reviewSignal: 'present',
+    blockingBeforePlanCount: 0
+  };
+}
+
+function planOutputCloseRequest(branch = 'master') {
+  return {
+    finalPlanRef: `specs/${branch}/plan.md`,
+    planCloseQualityEvidence: 'present',
+    reviewSignal: 'present',
+    blockingBeforeTasksCount: 0
+  };
+}
+
+function tasksOutputCloseRequest(branch = 'master') {
+  return {
+    finalTasksRef: `specs/${branch}/tasks.md`,
+    dependencyGraphStatus: 'present',
+    validationSignalsStatus: 'present',
+    reviewSignal: 'present',
+    blockingBeforeExecuteCount: 0
+  };
+}
+
+function reviewedPlan(): string {
+  return `---
+contract: sdd-plan-doc-v3
+title: Reviewed test plan
+---
+
+# Reviewed Test Plan
+
+## 0. Metadata
+
+- spec_id: test-spec
+- plan_id: test-plan
+- branch: master
+- lifecycle_profile: compact
+- risk_level: low
+- owner: plan-manager
+- reviewers: []
+- scout_domains: []
+- created_at: 2026-06-11T00:00:00.000Z
+- updated_at: 2026-06-11T00:00:00.000Z
+
+## 1. Upstream Spec Trace
+
+| Spec Item | Plan Section | Strategy Response |
+|---|---|---|
+| AC-1 | §4 Target Design Overview | Use accepted upstream truth for plan closure. |
+
+## 2. Planning Problem / Strategy Framing
+
+This fixture verifies plan close against an accepted spec handoff without making side evidence authoritative.
+
+## 3. Current Implementation Map
+
+Observed evidence: 'packages/core/src/stage-collaboration.ts' owns 'reconcilePlanCollaborationClosure', 'validateAcceptedPlanArtifact', 'PlanRuntimeCloseBoundaryFacts', and runtime projection writes. 'packages/core/src/storage/runtime-store.ts' owns projection persistence. The plan reuses runtime ref/hash conventions and changes only plan close validation depth; it does not reuse side evidence as runtime truth. Scout gap: none for this fixture; code surfaces are grounded by direct test fixtures.
+## 4. Target Design Overview
+
+Use the accepted spec ref/hash as upstream truth and keep plan-stage side traces out of downstream consumption.
+
+## 5. Change Topology / Responsibility Boundaries
+
+Plan close remains output-centered around final plan.md V3. Tasks-stage owns decomposition and execution topology.
+
+## 6. Interface / API / Schema Design
+
+Plan close accepts final plan.md V3 ref/hash and 'PlanRuntimeCloseBoundaryFacts'. No HTTP endpoint exists; the API surface is the TypeScript function contract plus runtime-store projection schema.
+
+| Source table / input field | Runtime field / output mapping | Owner | Rule |
+|---|---|---|---|
+| 'PlanRuntimeCloseBoundaryFacts.branch' | 'branch' / 'scopeKey' | 'reconcilePlanCollaborationClosure' | Selects the workflow partition. |
+| 'acceptedSpecRef' | 'upstreamSpecRef' | 'validateAcceptedPlanArtifact' | Must match the accepted spec document ref. |
+| 'acceptedSpecHash' | 'upstreamSpecHash' | 'validateAcceptedPlanArtifact' | Must match the stored accepted spec hash. |
+| 'finalPlanRef' / 'acceptedPlanRef' | 'acceptedPlanRef' | runtime-store projection schema | Must point to 'specs/master/plan.md'. |
+| 'finalPlanHash' / 'acceptedPlanHash' | 'acceptedPlanHash' and 'contentHash' | runtime-store projection schema | Must match canonical file hash before handoff. |
+| 'blockingBeforeTasksCount' | 'readyForTasks' status | plan adjudication projection | Zero blockers maps to 'ready_for_tasks'. |
+## 7. State / Data / Concurrency Design
+
+No persisted business data is changed, but runtime projection state must remain consistent across close, rejection, and handoff publication.
+
+| State / data key | Rule | Failure / rollback behavior |
+|---|---|---|
+| 'partitionKey' and 'scopeKey' | Branch-scoped runtime state isolates 'master' from other partitions. | Wrong key leaves existing handoff stale and does not publish a new handoff. |
+| 'projectionType' and 'ownerStage' | plan adjudication and workflow handoff stay separate records. | Partial failure must not publish plan->tasks without 'acceptedPlanRef'. |
+| 'acceptedPlanRef' and 'contentHash' | Hash equality is required before runtime accepts the plan artifact. | Hash mismatch rejects close and preserves the previous projection state. |
+| 'handoffStatus' and 'readyForTasks' | 'ready_for_tasks' is only derived after zero blockers and valid plan evidence. | Blocking status routes back to plan repair instead of tasks. |
+| 'supersededAt' and 'rollbackState' | Superseding or deleting plan-stage projections is the rollback path. | Downstream tasks projections are not edited as plan rollback. |
+## 8. Key Design Decisions
+
+| Decision | Reason | Tradeoff | Rejected alternatives |
+|---|---|---|---|
+| Validate final plan.md only | Keep side findings non-authoritative | Requires dense plan document | Required plan side evidence |
+
+## 9. Alternatives Considered
+
+| Alternative | Why rejected |
+|---|---|
+| Close from side evidence | Would make side logs authoritative again. |
+
+## 10. Risk Controls
+
+| Risk | Impact | Design Control | Validation Hook | Task-stage Constraint |
+|---|---|---|---|---|
+| Thin plan fixture | Tasks lose design guidance and execute guesses runtime behavior. | Require concrete surfaces, mappings, state/failure rules, and scenario validation before close. | stage-collaboration tests assert accepted and rejected plan closures. | tasks-stage must consume accepted plan ref/hash and must not derive from side logs. |
+
+## 11. Validation Strategy
+
+| Scenario | Input Data / User Action | Expected API / UI / SQL Result | Command / Evidence | Proves | Does Not Prove |
+|---|---|---|---|---|---|
+| Accepted plan close | 'finalPlanRef=specs/master/plan.md', matching 'finalPlanHash', zero blockers | Runtime returns 'ready_for_tasks' and records plan->tasks handoff | stage-collaboration focused test | Proves ref/hash and close evidence are accepted. | Does not prove application feature behavior. |
+| Stale plan close | 'finalPlanHash' differs from canonical plan content | Runtime rejects close and does not publish a fresh handoff | stage-collaboration stale hash test | Proves failure routing and rollback preservation. | Does not prove all storage failures. |
+
+## 12. Rollout / Rollback / Compatibility
+
+This fixture has no rollout surface beyond regression validation.
+
+## 13. Task-stage Constraints
+
+Tasks must consume accepted spec and accepted plan refs only; task-stage owns task IDs, execution waves, dependency graph, and per-task acceptance.
+
+Task slicing boundary: keep runtime artifact validation, projection write, and handoff inspection in one rollback unit unless a later task explicitly proves independent rollback safety. Dependency rationale: tasks that consume plan close output must wait for accepted 'acceptedPlanRef' and 'contentHash' evidence. Validation coverage must include accepted and rejected close scenarios. Risky seam: never let side evidence replace the canonical plan ref/hash.
+
+Forbidden: task IDs, task lists, execution waves, dependency graph, taskClass, sdd-task blocks, implementation checklist.
+
+## 14. Open Questions / User Decisions
+
+| ID | Question / Decision | Owner | Blocks |
+|---|---|---|---|
+
+## 15. Plan Close Quality Evidence
+
+- technical_design_sufficient: true
+- code_surfaces_grounded: true
+- field_api_sql_mapping_complete: true
+- state_failure_rollback_model_complete: true
+- scenario_validation_matrix_complete: true
+- risk_controls_tied_to_validation: true
+- downstream_design_guesswork_remaining: []
+- task_list_leakage_checked: true
+- ready_for_tasks: true
+`;
+}
+
+function reviewedTasks(options: { duplicate?: boolean; completed?: boolean; includeValidation?: boolean } = {}): string {
+  const secondId = options.duplicate ? 'T1' : 'T2';
+  const status = options.completed ? 'completed' : 'pending';
+  const validationTasks = `${reviewedValidationTask(status, 'T1', 'T3', 'packages/core/src/example.ts', 'REQ-1', 'AC-1', 'PLAN-1')}${reviewedValidationTask(status, secondId, 'T4', 'packages/core/src/example-2.ts', 'REQ-2', 'AC-2', 'PLAN-2')}`;
+  return `---
+contract: sdd-tasks-doc-v2
+title: Reviewed test tasks
+---
+
+# Reviewed Test Tasks
+
+## 1. Split Basis
+
+The tasks are split from the accepted spec and plan into implementation work first, followed by a separate validation task. Split chain: PLAN-1 / PLAN-2 plan decisions -> work-unit boundary -> dependency and rollback rationale -> completion evidence -> failure route.
+
+## 2. Execution Order Overview
+
+| Wave | Tasks | Type | Why now |
+|---|---|---|---|
+| 1 | T1, ${secondId} | implementation | Implement the accepted plan boundaries before validation. |
+| 2 | T3, T4 | validation | Validate each accepted implementation rollback unit one-to-one after T1 and ${secondId}. |
+
+## 3. Implementation Tasks
+
+### T1 — Implement first reviewed task
+
+**Type**: implementation / core  
+**Execution order**: Wave 1  
+**Dependencies**: none  
+**Routing hint**: runtime, backend  
+
+**Why this task exists**
+
+T1 implements the first accepted plan decision and risk boundary without running the final validation. This work-unit context preserves the design part from PLAN-1 and execute must not reinterpret the upstream scope.
+
+**Spec context**
+
+Covers REQ-1 and contributes to AC-1.
+
+**Plan context**
+
+Keep the implementation inside PLAN-1 and hand the result to T3 for validation.
+
+**Implementation scope**
+
+- Allowed code changes: packages/core/src/example.ts only.
+
+- Forbidden files: packages/core/src/example-2.ts and unrelated runtime storage files.
+**Do not do**
+
+- Do not run full validation in this implementation task.
+- Do not change unrelated files.
+
+**Completion evidence**
+
+- Code review confirms the T1 boundary and basic code sanity passes.
+- Observable completion means the affected area is updated and ready for T3; what does not count as completion is running only the final validation without implementation evidence.
+
+**Handoff**
+
+T1 hands off to T3 for validation.
+
+**Rollback unit**
+
+T1 rollback unit is packages/core/src/example.ts; it is reverted together with T3 evidence if validation shows this boundary caused failure.
+
+\`\`\`sdd-task
+id: T1
+status: ${status}
+taskClass: implementation
+unitType: core
+wave: 1
+dependencies: []
+validationHandoff:
+  - T3
+routingHints:
+  - runtime
+  - backend
+affectedAreas:
+  - packages/core/src/example.ts
+sourceRequirements:
+  - REQ-1
+sourceAcceptanceCriteria:
+  - AC-1
+planRefs:
+  - PLAN-1
+change_surface: backend_only
+depends_on: []
+affected_files:
+  - packages/core/src/example.ts
+validation:
+  - code review
+risk: []
+acceptance_refs:
+  - AC-1
+plan_refs:
+  - PLAN-1
+\`\`\`
+
+#### Boundary
+
+Implement only the reviewed T1 boundary with allowed files and forbidden scope preserved.
+
+#### Acceptance
+
+- AC-1 is handed off to T3 for validation.
+
+### ${secondId} — Implement second reviewed task
+
+**Type**: implementation / core  
+**Execution order**: Wave 1  
+**Dependencies**: none  
+**Routing hint**: runtime, backend  
+
+**Why this task exists**
+
+${secondId} implements the second accepted plan decision and risk boundary without running the final validation. This work-unit context preserves the design part from PLAN-2 and execute must not reinterpret the upstream scope.
+
+**Spec context**
+
+Covers REQ-2 and contributes to AC-2.
+
+**Plan context**
+
+Keep the implementation inside PLAN-2 and hand the result to T4 for validation.
+
+**Implementation scope**
+
+- Allowed code changes: packages/core/src/example-2.ts only.
+
+- Forbidden files: packages/core/src/example.ts and unrelated runtime storage files.
+**Do not do**
+
+- Do not run full validation in this implementation task.
+- Do not change unrelated files.
+
+**Completion evidence**
+
+- Code review confirms the ${secondId} boundary and basic code sanity passes.
+- Observable completion means the affected area is updated and ready for T4; what does not count as completion is running only the final validation without implementation evidence.
+
+**Handoff**
+
+${secondId} hands off to T4 for validation.
+
+**Rollback unit**
+
+${secondId} rollback unit is packages/core/src/example-2.ts; it is reverted together with T4 evidence if validation shows this boundary caused failure.
+
+\`\`\`sdd-task
+id: ${secondId}
+status: ${status}
+taskClass: implementation
+unitType: core
+wave: 1
+dependencies: []
+validationHandoff:
+  - T4
+routingHints:
+  - runtime
+  - backend
+affectedAreas:
+  - packages/core/src/example-2.ts
+sourceRequirements:
+  - REQ-2
+sourceAcceptanceCriteria:
+  - AC-2
+planRefs:
+  - PLAN-2
+change_surface: backend_only
+depends_on: []
+affected_files:
+  - packages/core/src/example-2.ts
+validation:
+  - code review
+risk: []
+acceptance_refs:
+  - AC-2
+plan_refs:
+  - PLAN-2
+\`\`\`
+
+#### Boundary
+
+Implement only the reviewed ${secondId} boundary with allowed files and forbidden scope preserved.
+
+#### Acceptance
+
+- AC-2 is handed off to T4 for validation.
+
+## 4. Validation Tasks
+
+${validationTasks}## 5. Task Dependencies and Handoff
+
+T1 and ${secondId} run in Wave 1 because they unlock independent implementation surfaces. T3 depends on T1, and T4 depends on ${secondId}, because validation must map one-to-one to each implementation rollback unit. Parallel implementation is safe only while the two rollback units stay separate.
+
+## 6. Coverage Check
+
+| Source | Covered by | Work-unit rationale | Completion / validation evidence |
+|---|---|---|---|
+| REQ-1 / AC-1 | T1, T3 | PLAN-1 implementation plus independent validation | T1 completion evidence and T3 expected result |
+| REQ-2 / AC-2 | ${secondId}, T4 | PLAN-2 implementation plus independent validation | ${secondId} completion evidence and T4 expected result |
+| PLAN-1 / PLAN-2 | T1, ${secondId}, T3, T4 | plan decisions mapped to rollback-separated tasks | validation handoff verifies each work unit one-to-one |
+
+## 7. Open Execution Questions
+
+No blocking execution questions before execute. Failures route to implementation task, tasks boundary repair, plan repair, spec/user decision, or environment diagnostic route according to the failure routing above.
+
+## 8. Tasks Close Quality Evidence
+
+- task_decomposition_sufficient: true
+- work_units_have_context: true
+- upstream_trace_complete: true
+- boundaries_and_rollback_units_defined: true
+- dependency_rationale_complete: true
+- completion_evidence_defined: true
+- validation_expected_results_defined: true
+- failure_routes_defined: true
+- task-review-agent verdict: approved
+- review_reconciliation: blocking findings resolved; review_blockers_remaining: []
+- downstream_execution_guesswork_remaining: []
+- ready_for_execute: true
+`;
+}
+
+function warningOnlyTasks(): string {
+  return [
+    '---',
+    'contract: sdd-tasks-doc-v2',
+    'title: Warning-only tasks',
+    '---',
+    '',
+    '# Warning-only Tasks',
+    '',
+    '## Split Basis',
+    '',
+    'Split accepted plan into one implementation and one validation task.',
+    '',
+    '## Execution Order Overview',
+    '',
+    'Wave 1 runs T1. Wave 2 runs T2.',
+    '',
+    '## Implementation Tasks',
+    '',
+    '### T1 — Implement minimal report path',
+    '',
+    'Change only packages/core/src/example.ts.',
+    '',
+    '```sdd-task',
+    'id: T1',
+    'status: pending',
+    'taskClass: implementation',
+    'unitType: core',
+    'wave: 1',
+    'dependencies: []',
+    'validationHandoff:',
+    '  - T2',
+    'affectedAreas:',
+    '  - packages/core/src/example.ts',
+    'affected_files:',
+    '  - packages/core/src/example.ts',
+    'validation:',
+    '  - code review',
+    '```',
+    '',
+    '#### Boundary',
+    '',
+    'Start from the existing minimal report path. Change only packages/core/src/example.ts and do not modify unrelated runtime storage.',
+    '',
+    '#### Acceptance',
+    '',
+    '- Completion evidence: code review confirms the T1 boundary and T2 validation remains the proof task.',
+    '',
+    '## Validation Tasks',
+    '',
+    '### T2 — Validate minimal report path',
+    '',
+    'Run the selected check and route failures to tasks repair, plan repair, spec/user decision, or environment diagnostic.',
+    '',
+    '```sdd-task',
+    'id: T2',
+    'status: pending',
+    'taskClass: validation',
+    'unitType: validation',
+    'wave: 2',
+    'dependencies:',
+    '  - T1',
+    'validatesImplementationTasks:',
+    '  - T1',
+    'affectedAreas:',
+    '  - packages/core/src/example.ts',
+    'affected_files:',
+    '  - packages/core/src/example.ts',
+    'validation:',
+    '  - npm test',
+    '```',
+    '',
+    '#### Boundary',
+    '',
+    'Validate only T1 output and do not expand implementation scope.',
+    '',
+    '#### Acceptance',
+    '',
+    '- Expected result: selected validation check passes for T1 output; this does not prove release readiness.',
+    '',
+    '## Task Dependencies and Handoff',
+    '',
+    'T2 depends on T1.',
+    '',
+    '## Coverage Check',
+    '',
+    'T1 and T2 cover the accepted minimal report path.',
+    '',
+    '## Open Execution Questions',
+    '',
+    'No blocking execution questions. Failure route: tasks repair, plan repair, spec/user decision, or environment diagnostic.',
+    '',
+    '## Tasks Close Quality Evidence',
+    '',
+    '- task-review-agent verdict: approved',
+    '- review_reconciliation: blocking findings resolved; review_blockers_remaining: []',
+    '- downstream_execution_guesswork_remaining: []',
+    ''
+  ].join('\n');
+}
+
+function oversizedCoarseTasks(): string {
+  return warningOnlyTasks()
+    .replace(
+      'Change only packages/core/src/example.ts.',
+      'Change Controller, Service, Mapper, DTO, VO, mapper XML, SQL, JSP, and UI configuration in one task. Affected surfaces: ReportController, ReportService, ReportMapper, ReportDTO, ReportVO, mapper XML, permission SQL, JSP, and UI route.'
+    )
+    .replace(
+      'Start from the existing minimal report path. Change only packages/core/src/example.ts and do not modify unrelated runtime storage.',
+      'Start from the existing report path. Change backend API, service logic, mapper SQL, XML wiring, permission SQL, JSP, and UI route in this one task. Do not modify unrelated runtime storage.'
+    );
+}
+
+function reviewedValidationTask(status: string, implementationId: string, validationId: string, affectedFile: string, sourceRequirement: string, acceptanceRef: string, planRef: string): string {
+  return `### ${validationId} — Validate ${implementationId} output
+
+**Type**: validation<br>
+**Execution order**: Wave 2<br>
+**Dependencies**: ${implementationId}
+
+**Validates implementation task**
+
+- ${implementationId}
+
+**Validation target**
+
+Validate ${acceptanceRef} against the implementation output from ${implementationId}; expected result is that targeted tests pass and acceptance behavior matches the accepted plan.
+
+**Validation method**
+
+- npm test
+
+**Pass criteria**
+
+The targeted validation passes, no blocking acceptance gap remains, and evidence is enough to accept ${implementationId}; it does not prove unrelated release readiness.
+
+**Failure routing**
+
+- Runtime behavior failures return to ${implementationId}.
+- Boundary errors route to tasks repair; missing technical design routes to plan repair; unclear business rule routes to spec/user decision; environment failures route to diagnostic handling.
+
+\`\`\`sdd-task
+id: ${validationId}
+status: ${status}
+taskClass: validation
+unitType: validation
+wave: 2
+dependencies:
+  - ${implementationId}
+validatesImplementationTasks:
+  - ${implementationId}
+routingHints:
+  - validation
+affectedAreas:
+  - ${affectedFile}
+sourceRequirements:
+  - ${sourceRequirement}
+sourceAcceptanceCriteria:
+  - ${acceptanceRef}
+planRefs:
+  - ${planRef}
+change_surface: backend_only
+depends_on:
+  - ${implementationId}
+affected_files:
+  - ${affectedFile}
+validation:
+  - npm test
+risk: []
+acceptance_refs:
+  - ${acceptanceRef}
+plan_refs:
+  - ${planRef}
+\`\`\`
+
+#### Boundary
+
+Validate only ${implementationId} output.
+
+#### Acceptance
+
+- ${acceptanceRef} is validated.
+
+`;
+}
+
+function reviewedVerify(tasksContent: string, options: { omitTaskId?: string } = {}): string {
+  const tasks = reviewedVerifyTasks(tasksContent).filter((task) => task.id !== options.omitTaskId);
+  const taskRows = tasks
+    .map((task) => `| ${task.id} | ${task.acceptanceRefs.length > 0 ? task.acceptanceRefs.join('<br>') : 'none'} | ${task.validationCommands.length > 0 ? task.validationCommands.join('<br>') : 'npm test'} | validation-report.md | available |`)
+    .join('\n');
+  const batches = tasks
+    .map((task) => `  - task: ${task.id}`)
+    .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 tasks-stage verification design 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.
+`;
+}
+
+function reviewedVerifyTasks(tasksContent: string): Array<{ id: string; acceptanceRefs: string[]; validationCommands: string[] }> {
+  return Array.from(tasksContent.matchAll(/```sdd-task\s*\r?\n([\s\S]*?)```/g))
+    .map((match) => match[1])
+    .map((block) => ({
+      id: blockScalarValue(block, 'id'),
+      acceptanceRefs: blockListValue(block, ['sourceAcceptanceCriteria', 'source_acceptance_criteria', 'acceptance_refs']),
+      validationCommands: blockListValue(block, ['validation'])
+    }))
+    .filter((task): task is { id: string; acceptanceRefs: string[]; validationCommands: string[] } => Boolean(task.id));
+}
+
+function blockScalarValue(block: string, key: string): string | null {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = block.match(new RegExp(`^\\s*${escapedKey}:\\s*(.+?)\\s*$`, 'm'));
+  return match ? cleanBlockValue(match[1]) : null;
+}
+
+function blockListValue(block: string, keys: string[]): string[] {
+  const lines = block.split(/\r?\n/);
+  for (const key of keys) {
+    const start = lines.findIndex((line) => new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:`).test(line));
+    if (start === -1) {
+      continue;
+    }
+    const inline = lines[start].split(':').slice(1).join(':').trim();
+    if (inline && inline !== '[]') {
+      return inline.startsWith('[') && inline.endsWith(']')
+        ? inline.slice(1, -1).split(',').map(cleanBlockValue).filter(Boolean)
+        : [cleanBlockValue(inline)];
+    }
+    const values: string[] = [];
+    for (const line of lines.slice(start + 1)) {
+      if (/^\s*[A-Za-z_][\w]*:\s*/.test(line)) {
+        break;
+      }
+      const item = line.trim().match(/^-\s+(.+)$/)?.[1];
+      if (item) {
+        values.push(cleanBlockValue(item));
+      }
+    }
+    return values;
+  }
+  return [];
+}
+
+function cleanBlockValue(value: string): string {
+  return value.trim().replace(/^["'`]|["'`]$/g, '');
+}
+
+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: 'task-review-agent',
+    managerProducer: 'tasks-manager',
+    reviewContract: 'sdd-tasks-review-artifact-v1',
+    managerContract: 'sdd-tasks-manager-artifact-v1',
+    targetRef: 'specs/master/tasks.md'
+  },
+  {
+    stage: 'execute',
+    reviewFile: 'code-review-v1.md',
+    managerFile: 'execute-manager-v1.md',
+    reviewKind: 'code_review',
+    reviewProducer: 'code-reviewer',
+    managerProducer: 'execute-manager',
+    reviewContract: 'sdd-execute-code-review-artifact-v1',
+    managerContract: 'sdd-execute-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/execute/implementation-v1.md'
+  },
+  {
+    stage: 'execute',
+    reviewFile: 'test-review-v1.md',
+    managerFile: 'execute-manager-v1.md',
+    reviewKind: 'test_review',
+    reviewProducer: 'test-reviewer',
+    managerProducer: 'execute-manager',
+    reviewContract: 'sdd-execute-test-review-artifact-v1',
+    managerContract: 'sdd-execute-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/execute/test-execution-v1.md'
+  },
+  {
+    stage: 'execute',
+    reviewFile: 'evidence-judgment-review-v1.md',
+    managerFile: 'evidence-judgment-manager-v1.md',
+    reviewKind: 'evidence_review',
+    reviewProducer: 'evidence-reviewer',
+    managerProducer: 'execute-manager',
+    reviewContract: 'sdd-execute-evidence-judgment-review-artifact-v1',
+    managerContract: 'sdd-execute-manager-artifact-v1',
+    targetRef: '.sdd/runs/master/execute/evidence-judgment-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: 'execute' as const,
+    ownerAgent: 'execute-manager',
+    coMainAgents: ['implementer', 'code-reviewer'],
+    status,
+    inputRefs: [],
+    outputRefs: status === 'completed' ? [ref('artifact', '.sdd/runs/feature/execute/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')));
+    }
+  }
+}