sdd-agent-platform 0.4.1 → 0.5.0

package/node_modules/@sdd-agent-platform/core/dist/stage-collaboration.js

@@ -0,0 +1,4018 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { LIFECYCLE_DECISION_CONTRACT, LIFECYCLE_DECISION_VERSION, STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION, STAGE_RUN_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION } from './contracts.js';
+import { LIFECYCLE_RISK_DECISION_PROJECTION_TYPE, lifecycleRiskDecisionScopeKey, recordLifecycleRiskDecisionProjection } from './risk/kernel.js';
+import { createRun } from './run-state/run-state.js';
+import { normalizePortablePath } from './path-safety.js';
+import { getBranchStageEvidenceDir, normalizeBranchStageEvidenceRef, toBranchStageEvidenceRef } from './runtime-paths.js';
+import { resolveSddContext } from './sdd-docs/context.js';
+import { evaluatePlanArtifactDepth, evaluateSpecArtifactDepth, formatArtifactDepthBlockingIssues } from './sdd-docs/artifact-depth.js';
+import { hashDocumentContent, hashSemanticDocument, hashTasksContract } from './sdd-docs/document-hashes.js';
+import { parseSddTasksMarkdown } from './sdd-docs/task-parser.js';
+import { EXECUTION_LANE_PROJECTION_TYPE, TASK_DEPENDENCY_GRAPH_PROJECTION_TYPE, TASK_UNIT_PROJECTION_TYPE, executionLaneScopeKey, readTaskDependencyGraphProjection, taskDependencyGraphScopeKey } from './task-execution-contract.js';
+import { readWorkflowHandoffProjection, recordStageRunProjection, recordWorkflowHandoffProjection, STAGE_RUN_PROJECTION_TYPE, stageRunScopeKey, WORKFLOW_HANDOFF_PROJECTION_TYPE, workflowHandoffScopeKey } from './stage-runtime/runtime.js';
+import { listRuntimeProjections, recordRuntimeArtifactPayload, recordRuntimeProjectionEnvelope, recordRuntimeStageArtifact, recordRuntimeStageCollaborationContract, runtimeScopedId } from './storage/runtime-store.js';
+import { readMarkdownArtifact, validateStageArtifactFrontmatter } from './stage-artifacts.js';
+import { readStageCollaborationContract, validateStageCollaborationContractFrontmatter } from './stage-collaboration-contracts.js';
+export const SPEC_STAGE_MANAGER = 'spec-manager';
+export const SPEC_STAGE_REVIEW_AGENT = 'spec-reviewer';
+export const SPEC_STAGE_SCOUT_AGENT = 'scout';
+export const SPEC_STAGE_AGENT_TEAM = [SPEC_STAGE_SCOUT_AGENT, SPEC_STAGE_REVIEW_AGENT];
+export const SPEC_STAGE_REQUIRED_CAPABILITIES = ['norm_discovery', 'uncertainty_resolution'];
+export const SPEC_STAGE_OPTIONAL_CAPABILITIES = ['context_curation', 'solution-design', 'frontend-engineering', 'security-engineering', 'ui-ux-product-design'];
+export const SPEC_STAGE_MATERIAL_PACKS = ['project-norms', 'uncertainty-map', 'baseline-solution-design', 'baseline-frontend-engineering', 'baseline-security-engineering', 'baseline-ui-ux-product-design'];
+export const STAGE_COLLABORATION_RUNTIME_PRODUCER_VERSION = 'phase9.1-stage-collaboration-runtime-v1';
+export const SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_1_spec_collaboration_adjudication';
+export const PLAN_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_2_plan_collaboration_adjudication';
+export const PLAN_STAGE_MANAGER = 'plan-manager';
+export const PLAN_STAGE_SCOUT_AGENT = 'plan-scout';
+export const PLAN_STAGE_REVIEW_AGENT = 'plan-review-agent';
+export const PLAN_STAGE_AGENT_TEAM = [PLAN_STAGE_SCOUT_AGENT, PLAN_STAGE_REVIEW_AGENT];
+export const PLAN_SCOUT_DOMAINS = ['architecture-runtime', 'backend-api', 'frontend-ui', 'database-migration', 'security', 'performance', 'testing-validation'];
+export const PLAN_STAGE_REQUIRED_CAPABILITIES = ['plan-strategy', 'plan-pressure-review'];
+export const PLAN_STAGE_OPTIONAL_CAPABILITIES = [...PLAN_SCOUT_DOMAINS];
+export const PLAN_STAGE_MATERIAL_PACKS = ['project-norms', 'plan-section-rubric', 'plan-scout-domain-packs'];
+export const TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_3_tasks_collaboration_adjudication';
+export const TASKS_STAGE_MANAGER = 'tasks-manager';
+export const TASKS_STAGE_REVIEW_AGENT = 'task-review-agent';
+export const TASKS_STAGE_SLICER_AGENT = 'task-slicer';
+export const EXECUTE_IMPLEMENTER_AGENT = 'implementer';
+export const EXECUTE_CODE_REVIEW_AGENT = 'code-reviewer';
+export const EXECUTE_DEBUGGER_AGENT = 'debugger';
+export const EXECUTE_TEST_RUNNER_AGENT = 'test-runner';
+export const EXECUTE_VALIDATOR_AGENT = 'validator';
+export const EXECUTE_TEST_REVIEW_AGENT = 'test-reviewer';
+export const EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase10_execute_collaboration_adjudication';
+export const EXECUTE_EVIDENCE_JUDGMENT_VALIDATOR_AGENT = 'evidence-validator';
+export const EXECUTE_EVIDENCE_JUDGMENT_REVIEW_AGENT = 'evidence-reviewer';
+export const TRUTH_ALIGNMENT_PROJECTION_TYPE = 'phase9_12_truth_alignment';
+export const TRUTH_ALIGNMENT_CONTRACT = 'sdd-truth-alignment-v1';
+export const SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_9_ship_collaboration_adjudication';
+export const SHIP_STAGE_MANAGER = 'ship-manager';
+export const SHIP_STAGE_VALIDATOR_AGENT = 'ship-validator';
+export const SHIP_STAGE_REVIEW_AGENT = 'release-reviewer';
+const TRUTH_ALIGNMENT_STATUSES = ['aligned', 'drift_detected', 'update_required', 'blocked'];
+const TRUTH_ALIGNMENT_SEMANTIC_IMPACTS = ['none', 'bounded', 'material'];
+const TRUTH_ALIGNMENT_OWNER_STAGES = ['spec', 'plan', 'tasks', 'execute', 'ship'];
+export function deriveSpecCollaborationProfile(decision, generatedAt = new Date().toISOString()) {
+    const required = decision.requiredStages.includes('spec');
+    const intensity = specIntensity(decision, required);
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        stage: 'spec',
+        scope: decision.scope,
+        lifecycleProfile: decision.profile,
+        intensity,
+        required,
+        requiresStageClosure: intensity !== 'noop' && intensity !== 'blocked',
+        allowedProposalKinds: intensity === 'noop' ? [] : ['advisory_finding', 'blocking_ambiguity', 'capability_suggestion', 'handoff_proposal'],
+        stageManager: intensity === 'noop' || intensity === 'blocked' ? null : SPEC_STAGE_MANAGER,
+        agentTeam: specMemberAgents(intensity),
+        requiredCapabilities: specRequiredCapabilities(intensity),
+        optionalCapabilities: specOptionalCapabilities(intensity),
+        materialPackIds: specMaterialPackIds(intensity),
+        collaborationPlan: specCollaborationPlan(intensity),
+        inputRefs: decision.inputRefs,
+        reasons: specProfileReasons(decision, required, intensity),
+        generatedAt
+    };
+}
+export function buildSpecStageWorkOrder(profile, profileRef, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('spec-work-order', profile.scope),
+        stage: 'spec',
+        scope: profile.scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: specRequiredOutputKinds(profile.intensity),
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        stageManager: SPEC_STAGE_MANAGER,
+        agentTeam: profile.agentTeam,
+        requiredCapabilities: profile.requiredCapabilities,
+        optionalCapabilities: profile.optionalCapabilities,
+        materialPackIds: profile.materialPackIds,
+        collaborationPlan: profile.collaborationPlan,
+        inputRefs: profile.inputRefs,
+        generatedAt
+    };
+}
+export function planCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'plan'].join(':');
+}
+export function buildPlanStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString(), intensity = 'scout-first') {
+    const collaborationPlan = planCollaborationPlan(intensity);
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('plan-work-order', scope),
+        stage: 'plan',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: planRequiredOutputKinds(intensity),
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: PLAN_STAGE_MANAGER,
+        agentTeam: planMemberAgents(intensity),
+        planScoutDomains: planScoutDomains(intensity),
+        requiredCapabilities: planRequiredCapabilities(intensity),
+        optionalCapabilities: planOptionalCapabilities(intensity),
+        materialPackIds: planMaterialPackIds(intensity),
+        collaborationPlan,
+        generatedAt
+    };
+}
+export function tasksCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'tasks'].join(':');
+}
+export function buildTasksStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('tasks-work-order', scope),
+        stage: 'tasks',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['tasks_context', 'tasks_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: TASKS_STAGE_MANAGER,
+        agentTeam: [TASKS_STAGE_SLICER_AGENT, TASKS_STAGE_REVIEW_AGENT],
+        requiredCapabilities: ['task-decomposition', 'acceptance-mapping'],
+        optionalCapabilities: ['dependency-analysis', 'parallelization-planning'],
+        materialPackIds: ['project-norms', 'baseline-task-slicing', 'baseline-acceptance-mapping'],
+        generatedAt
+    };
+}
+export function executeCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'execute'].join(':');
+}
+export function buildExecuteStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('execute-work-order', scope),
+        stage: 'execute',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['implementation_evidence', 'code_review', 'validation_evidence', 'checkpoint_decision', 'evidence_judgment', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: 'execute-manager',
+        agentTeam: [EXECUTE_IMPLEMENTER_AGENT, EXECUTE_CODE_REVIEW_AGENT, EXECUTE_DEBUGGER_AGENT, EXECUTE_TEST_RUNNER_AGENT, EXECUTE_VALIDATOR_AGENT, EXECUTE_TEST_REVIEW_AGENT, EXECUTE_EVIDENCE_JUDGMENT_VALIDATOR_AGENT, EXECUTE_EVIDENCE_JUDGMENT_REVIEW_AGENT],
+        requiredCapabilities: ['implementation', 'code-review', 'validation', 'evidence-judgment'],
+        optionalCapabilities: ['debugging', 'checkpoint-review', 'frontend-engineering', 'security-engineering'],
+        materialPackIds: ['accepted-task-contract', 'execute-lane-contract', 'validation-contract', 'checkpoint-policy', 'evidence-judgment-policy'],
+        generatedAt
+    };
+}
+export function truthAlignmentScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'truth-alignment'].join(':');
+}
+function buildTruthAlignmentProjection(scope, input) {
+    const acceptedRealityRefs = uniqueRuntimeRefs([input.acceptedEvidenceJudgmentRef, ...input.artifactRefs].filter((ref) => ref !== null));
+    return {
+        contract: TRUTH_ALIGNMENT_CONTRACT,
+        branch: scope.branch,
+        sourceStage: 'execute',
+        declaredTruthRefs: uniqueRuntimeRefs(input.declaredTruthRefs),
+        acceptedRealityRefs,
+        status: input.status,
+        ownerStage: input.ownerStage,
+        semanticImpact: input.semanticImpact,
+        staleRefs: uniqueRuntimeRefs(input.staleRefs),
+        invalidatesStages: [...new Set(input.invalidatesStages)],
+        reasons: input.reasons,
+        createdAt: input.generatedAt
+    };
+}
+export function shipCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'ship'].join(':');
+}
+export function buildShipStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('ship-work-order', scope),
+        stage: 'ship',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['ship_readiness', 'release_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: SHIP_STAGE_MANAGER,
+        agentTeam: [SHIP_STAGE_VALIDATOR_AGENT, SHIP_STAGE_REVIEW_AGENT],
+        requiredCapabilities: ['ship-readiness', 'release-readiness'],
+        optionalCapabilities: ['release-note-review', 'migration-readiness', 'operational-readiness'],
+        materialPackIds: ['project-norms', 'baseline-ship-readiness', 'baseline-release-review'],
+        generatedAt
+    };
+}
+export function specCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'spec'].join(':');
+}
+export async function recordSpecCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: specCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.1-stage-collaboration-runtime',
+        producerVersion: STAGE_COLLABORATION_RUNTIME_PRODUCER_VERSION,
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordPlanCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: PLAN_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: planCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.2-plan-stage-collaboration-runtime',
+        producerVersion: 'phase9.2-plan-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordTasksCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: tasksCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.3-tasks-stage-collaboration-runtime',
+        producerVersion: 'phase9.3-tasks-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordExecuteCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: executeCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase10-execute-stage-collaboration-runtime',
+        producerVersion: 'phase10-execute-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordTruthAlignmentProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: TRUTH_ALIGNMENT_PROJECTION_TYPE,
+        scopeKey: truthAlignmentScopeKey({ branch: result.branch }),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.12-truth-alignment-runtime-projection',
+        producerVersion: 'phase9.12-truth-alignment-runtime-projection-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function readTruthAlignmentProjection(projectRoot, scope) {
+    const scopeKey = truthAlignmentScopeKey({ branch: scope.branch });
+    const projections = await listRuntimeProjections(projectRoot, [TRUTH_ALIGNMENT_PROJECTION_TYPE]);
+    return projections
+        .map((projection) => projection.payload)
+        .filter((envelope) => envelope?.projectionType === TRUTH_ALIGNMENT_PROJECTION_TYPE && (envelope.scopeKey === scopeKey || envelope.payload?.branch === scope.branch))
+        .sort((left, right) => right.generatedAt.localeCompare(left.generatedAt))[0] ?? null;
+}
+export async function recordShipCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: shipCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.9-ship-stage-collaboration-runtime',
+        producerVersion: 'phase9.9-ship-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function reconcileSpecCollaborationClosure(projectRoot, input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const context = await resolveSddContext(projectRoot, { branch: input.decision.scope.branch, branchSource: 'cli_option' });
+    const decision = {
+        ...input.decision,
+        scope: { ...input.decision.scope, branch: context.rawBranch }
+    };
+    const run = await createRun(projectRoot, {
+        runId: input.runId,
+        branch: context.rawBranch,
+        lifecycleDecision: runLifecycleDecisionRecord(decision)
+    });
+    const runRef = { kind: 'run', ref: run.runId };
+    const profile = deriveSpecCollaborationProfile(decision, generatedAt);
+    const profileRef = { kind: 'projection', ref: `${SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${specCollaborationScopeKey(profile.scope)}:profile` };
+    const workOrder = profile.stageManager ? buildSpecStageWorkOrder(profile, profileRef, generatedAt) : null;
+    const registeredCollaborationContracts = input.collaborationContractRefs && input.collaborationContractRefs.length > 0
+        ? await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'spec', workOrder, input.collaborationContractRefs, generatedAt)
+        : [];
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerSpecStageArtifacts(projectRoot, context.rawBranch, profile, input.artifactRefs, run.runId, generatedAt);
+    const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
+    const outputClosure = await buildOutputCenteredSpecClosureRequest(projectRoot, profile, workOrder, context.partition, input.outputCloseRequest, generatedAt);
+    const closureRequest = input.closureRequest ?? outputClosure;
+    const coordination = input.coordination ?? deriveRegisteredSpecManagerCoordination(profile, workOrder, registeredArtifacts, generatedAt);
+    const candidate = closureRequest?.candidate ?? null;
+    const reviews = closureRequest?.reviewResults ?? [];
+    const capabilityFindings = closureRequest?.capabilityFindings ?? [];
+    let adjudication = adjudicateSpecStageClosureRequest({
+        profile,
+        closureRequest,
+        answerRefs: input.answerRefs,
+        generatedAt
+    });
+    const specAcceptance = await validateAcceptedSpecArtifact(projectRoot, {
+        partition: context.partition,
+        adjudication,
+        closureRequest,
+        registeredArtifacts,
+        validatedCollaborationContract
+    });
+    if (specAcceptance.rejectionIssue) {
+        adjudication = rejected({ profile, closureRequest, answerRefs: input.answerRefs }, specAcceptance.rejectionIssue.reasonCode, specAcceptance.rejectionIssue.explanation, specAcceptance.rejectionIssue.requiredNextAction, specAcceptance.rejectionIssue.fallbackRoute, generatedAt, true);
+    }
+    const adjudicationProjectionRef = specAdjudicationProjectionRef(adjudication.scope);
+    const lifecycleRiskProjectionRef = {
+        kind: 'projection',
+        ref: `${LIFECYCLE_RISK_DECISION_PROJECTION_TYPE}:${lifecycleRiskDecisionScopeKey(decision.scope)}`
+    };
+    const outputRefs = [specAcceptance.acceptedSpecRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildClosureStageRun(profile, adjudication, {
+        runId: run.runId,
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        generatedAt
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = specAcceptance.specAcceptanceStatus === 'accepted' && adjudication.health === 'ready_for_plan'
+        ? buildClosureWorkflowHandoff(profile, decision, adjudication, {
+            outputRefs,
+            requiredInputRefs: specAcceptance.acceptedSpecRef ? [specAcceptance.acceptedSpecRef] : [],
+            evidenceRefs: artifactRefs,
+            riskDecisionRef: lifecycleRiskProjectionRef,
+            generatedAt
+        })
+        : null;
+    const workflowHandoffProjectionRef = handoff
+        ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(handoff.scope, handoff.fromStage, handoff.toStage)}` }
+        : undefined;
+    const closureRefs = {
+        runRef,
+        acceptedSpecRef: specAcceptance.acceptedSpecRef,
+        specAcceptanceStatus: specAcceptance.specAcceptanceStatus,
+        specHash: specAcceptance.specHash,
+        specContractHash: specAcceptance.specContractHash,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: specAcceptance.reasons
+    };
+    const enrichedAdjudication = { ...adjudication, closureRefs };
+    await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+    await recordStageRunProjection(projectRoot, stageRun);
+    if (handoff) {
+        await recordWorkflowHandoffProjection(projectRoot, handoff);
+    }
+    const projection = await recordSpecCollaborationAdjudicationProjection(projectRoot, enrichedAdjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        profile,
+        workOrder,
+        coordination,
+        candidate,
+        reviews,
+        capabilityFindings,
+        closureRequest,
+        adjudication: enrichedAdjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedSpecRef: specAcceptance.acceptedSpecRef
+    };
+}
+export async function reconcilePlanCollaborationClosure(projectRoot, input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const context = await resolveSddContext(projectRoot, { branch: input.decision.scope.branch, branchSource: 'cli_option' });
+    const decision = {
+        ...input.decision,
+        scope: { ...input.decision.scope, branch: context.rawBranch }
+    };
+    const run = await createRun(projectRoot, {
+        runId: input.runId,
+        branch: context.rawBranch,
+        lifecycleDecision: runLifecycleDecisionRecord(decision)
+    });
+    const runRef = { kind: 'run', ref: run.runId };
+    const planRequired = decision.requiredStages.includes('plan');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('plan');
+    const acceptedSpecHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'spec', 'plan');
+    const workOrderInputRefs = acceptedSpecHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${PLAN_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${planCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = planRequired && !blocked ? buildPlanStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'plan', null, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'plan', input.artifactRefs, false, run.runId, generatedAt);
+    const closureRequest = await buildOutputCenteredPlanClosureRequest(projectRoot, decision.scope, workOrder, context.partition, acceptedSpecHandoffEnvelope?.payload ?? null, input.outputCloseRequest, generatedAt);
+    const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
+    const lifecycleRiskProjectionRef = {
+        kind: 'projection',
+        ref: `${LIFECYCLE_RISK_DECISION_PROJECTION_TYPE}:${lifecycleRiskDecisionScopeKey(decision.scope)}`
+    };
+    const adjudicationProjectionRef = planAdjudicationProjectionRef(decision.scope);
+    const planAcceptance = await validateAcceptedPlanArtifact(projectRoot, {
+        partition: context.partition,
+        required: planRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedSpecHandoff: acceptedSpecHandoffEnvelope?.payload ?? null,
+        closureRequest,
+    });
+    const health = planAcceptance.planAcceptanceStatus === 'accepted'
+        ? 'ready_for_tasks'
+        : !planRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const outputRefs = [planAcceptance.acceptedPlanRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildPlanClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedSpecHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: planAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const acceptedSpecRef = acceptedSpecRefFromHandoff(context.partition, acceptedSpecHandoffEnvelope?.payload ?? null);
+    const handoffOutputRefs = [planAcceptance.acceptedPlanRef].filter((ref) => ref !== null);
+    const handoffRequiredInputRefs = [acceptedSpecRef, planAcceptance.acceptedPlanRef].filter((ref) => ref !== null);
+    const handoff = planAcceptance.planAcceptanceStatus === 'accepted'
+        ? buildPlanWorkflowHandoff(decision.scope, decision, {
+            outputRefs: handoffOutputRefs,
+            requiredInputRefs: handoffRequiredInputRefs,
+            evidenceRefs: [],
+            riskDecisionRef: lifecycleRiskProjectionRef,
+            generatedAt
+        })
+        : null;
+    const workflowHandoffProjectionRef = handoff
+        ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(handoff.scope, handoff.fromStage, handoff.toStage)}` }
+        : undefined;
+    const rejection = planAcceptance.rejectionIssue
+        ? buildStageRejection('plan', decision.scope, null, planAcceptance.rejectionIssue.reasonCode, planAcceptance.rejectionIssue.explanation, planAcceptance.rejectionIssue.requiredNextAction, planAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedPlanRef: planAcceptance.acceptedPlanRef,
+        planAcceptanceStatus: planAcceptance.planAcceptanceStatus,
+        planHash: planAcceptance.planHash,
+        planContractHash: planAcceptance.planContractHash,
+        acceptedSpecHandoffRef: acceptedSpecHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'spec', 'plan')}` } : null,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: planAcceptance.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('plan-adjudication', decision.scope, health, generatedAt),
+        stage: 'plan',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('plan-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'plan',
+            scope: decision.scope,
+            status: health === 'ready_for_tasks' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: [planAcceptance.acceptedPlanRef, adjudicationProjectionRef].filter((ref) => ref !== null),
+            advisoryRefs: [],
+            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('context') || ref.ref.includes('capability')),
+            blockingReasons: health === 'ready_for_tasks' || health === 'no-op' ? [] : planAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('plan', decision.scope, generatedAt, health === 'ready_for_tasks' ? ['stage_ready', 'handoff_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
+        closureRefs,
+        createdAt: generatedAt
+    };
+    await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+    await recordStageRunProjection(projectRoot, stageRun);
+    if (handoff) {
+        await recordWorkflowHandoffProjection(projectRoot, handoff);
+    }
+    const projection = await recordPlanCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedPlanRef: planAcceptance.acceptedPlanRef
+    };
+}
+export async function reconcileTasksCollaborationClosure(projectRoot, input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const context = await resolveSddContext(projectRoot, { branch: input.decision.scope.branch, branchSource: 'cli_option' });
+    const decision = {
+        ...input.decision,
+        scope: { ...input.decision.scope, branch: context.rawBranch }
+    };
+    const run = await createRun(projectRoot, {
+        runId: input.runId,
+        branch: context.rawBranch,
+        lifecycleDecision: runLifecycleDecisionRecord(decision)
+    });
+    const runRef = { kind: 'run', ref: run.runId };
+    const tasksRequired = decision.requiredStages.includes('tasks');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('tasks');
+    const acceptedPlanHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'plan', 'tasks');
+    const workOrderInputRefs = acceptedPlanHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${tasksCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = tasksRequired && !blocked ? buildTasksStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'tasks', null, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'tasks', input.artifactRefs, false, run.runId, generatedAt);
+    const closureRequest = await buildOutputCenteredTasksClosureRequest(projectRoot, decision.scope, workOrder, context.partition, acceptedPlanHandoffEnvelope?.payload ?? null, input.outputCloseRequest, generatedAt);
+    const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
+    const lifecycleRiskProjectionRef = {
+        kind: 'projection',
+        ref: `${LIFECYCLE_RISK_DECISION_PROJECTION_TYPE}:${lifecycleRiskDecisionScopeKey(decision.scope)}`
+    };
+    const adjudicationProjectionRef = tasksAdjudicationProjectionRef(decision.scope);
+    const tasksAcceptance = await validateAcceptedTasksArtifact(projectRoot, {
+        partition: context.partition,
+        required: tasksRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedPlanHandoff: acceptedPlanHandoffEnvelope?.payload ?? null,
+        closureRequest
+    });
+    const health = tasksAcceptance.tasksAcceptanceStatus === 'accepted'
+        ? 'ready_for_execute'
+        : !tasksRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const outputRefs = [tasksAcceptance.acceptedTasksRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildTasksClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedPlanHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: tasksAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = tasksAcceptance.tasksAcceptanceStatus === 'accepted'
+        ? buildTasksWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: tasksAcceptance.acceptedTasksRef ? [tasksAcceptance.acceptedTasksRef] : [],
+            evidenceRefs: artifactRefs,
+            riskDecisionRef: lifecycleRiskProjectionRef,
+            generatedAt
+        })
+        : null;
+    const workflowHandoffProjectionRef = handoff
+        ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(handoff.scope, handoff.fromStage, handoff.toStage)}` }
+        : undefined;
+    const rejection = tasksAcceptance.rejectionIssue
+        ? buildStageRejection('tasks', decision.scope, null, tasksAcceptance.rejectionIssue.reasonCode, tasksAcceptance.rejectionIssue.explanation, tasksAcceptance.rejectionIssue.requiredNextAction, tasksAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedTasksRef: tasksAcceptance.acceptedTasksRef,
+        tasksAcceptanceStatus: tasksAcceptance.tasksAcceptanceStatus,
+        tasksHash: tasksAcceptance.tasksHash,
+        tasksContractHash: tasksAcceptance.tasksContractHash,
+        acceptedPlanHandoffRef: acceptedPlanHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'plan', 'tasks')}` } : null,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: tasksAcceptance.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('tasks-adjudication', decision.scope, health, generatedAt),
+        stage: 'tasks',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('tasks-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'tasks',
+            scope: decision.scope,
+            status: health === 'ready_for_execute' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: outputRefs,
+            advisoryRefs: [],
+            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('context') || ref.ref.includes('capability')),
+            blockingReasons: health === 'ready_for_execute' || health === 'no-op' ? [] : tasksAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('tasks', decision.scope, generatedAt, health === 'ready_for_execute' ? ['stage_ready', 'handoff_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
+        closureRefs,
+        createdAt: generatedAt
+    };
+    await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+    await recordStageRunProjection(projectRoot, stageRun);
+    if (handoff) {
+        await recordWorkflowHandoffProjection(projectRoot, handoff);
+    }
+    const projection = await recordTasksCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedTasksRef: tasksAcceptance.acceptedTasksRef
+    };
+}
+export async function reconcileExecuteCollaborationClosure(projectRoot, input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const context = await resolveSddContext(projectRoot, { branch: input.decision.scope.branch, branchSource: 'cli_option' });
+    const decision = {
+        ...input.decision,
+        scope: { ...input.decision.scope, branch: context.rawBranch }
+    };
+    const run = await createRun(projectRoot, {
+        runId: input.runId,
+        branch: context.rawBranch,
+        lifecycleDecision: runLifecycleDecisionRecord(decision)
+    });
+    const runRef = { kind: 'run', ref: run.runId };
+    const executeRequired = decision.requiredStages.includes('execute');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('execute');
+    const acceptedTasksHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'tasks', 'execute');
+    const workOrderInputRefs = acceptedTasksHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${executeCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = executeRequired && !blocked ? buildExecuteStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'execute', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'execute', input.artifactRefs, Boolean(workOrder), run.runId, generatedAt);
+    const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
+    const lifecycleRiskProjectionRef = {
+        kind: 'projection',
+        ref: `${LIFECYCLE_RISK_DECISION_PROJECTION_TYPE}:${lifecycleRiskDecisionScopeKey(decision.scope)}`
+    };
+    const adjudicationProjectionRef = executeAdjudicationProjectionRef(decision.scope);
+    const executeAcceptance = await validateAcceptedExecuteArtifact(projectRoot, {
+        partition: context.partition,
+        required: executeRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedTasksHandoff: acceptedTasksHandoffEnvelope?.payload ?? null
+    });
+    const health = executeAcceptance.executeAcceptanceStatus === 'accepted'
+        ? 'ready_for_ship'
+        : !executeRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const acceptedEvidenceJudgmentArtifact = latestStageArtifact(registeredArtifacts, 'evidence_judgment');
+    const acceptedEvidenceJudgmentRef = executeAcceptance.executeAcceptanceStatus === 'accepted' && acceptedEvidenceJudgmentArtifact
+        ? { kind: 'artifact', ref: acceptedEvidenceJudgmentArtifact.ref, hash: acceptedEvidenceJudgmentArtifact.hash }
+        : null;
+    const truthAlignmentProjection = acceptedEvidenceJudgmentRef
+        ? buildTruthAlignmentProjection(decision.scope, {
+            acceptedEvidenceJudgmentRef: acceptedEvidenceJudgmentRef,
+            declaredTruthRefs: await collectTruthAlignmentDeclaredTruthRefs(projectRoot, context.rawBranch, acceptedTasksHandoffEnvelope?.payload ?? null),
+            artifactRefs,
+            status: 'aligned',
+            ownerStage: null,
+            semanticImpact: 'none',
+            staleRefs: [],
+            invalidatesStages: [],
+            reasons: ['Accepted execute evidence judgment is structurally aligned with declared upstream truth refs.'],
+            generatedAt
+        })
+        : null;
+    const truthAlignmentProjectionRef = truthAlignmentProjection
+        ? { kind: 'projection', ref: `${TRUTH_ALIGNMENT_PROJECTION_TYPE}:${truthAlignmentScopeKey({ branch: decision.scope.branch })}` }
+        : null;
+    const outputRefs = [executeAcceptance.acceptedExecuteRef, truthAlignmentProjectionRef, adjudicationProjectionRef, collaborationContractRef, ...executeAcceptance.laneEvidenceRefs, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildExecuteClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedTasksHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: executeAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = executeAcceptance.executeAcceptanceStatus === 'accepted'
+        ? buildExecuteWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: executeAcceptance.acceptedExecuteRef ? [executeAcceptance.acceptedExecuteRef, ...executeAcceptance.laneEvidenceRefs] : executeAcceptance.laneEvidenceRefs,
+            evidenceRefs: artifactRefs,
+            riskDecisionRef: lifecycleRiskProjectionRef,
+            generatedAt
+        })
+        : null;
+    const workflowHandoffProjectionRef = handoff
+        ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(handoff.scope, handoff.fromStage, handoff.toStage)}` }
+        : undefined;
+    const rejection = executeAcceptance.rejectionIssue
+        ? buildStageRejection('execute', decision.scope, null, executeAcceptance.rejectionIssue.reasonCode, executeAcceptance.rejectionIssue.explanation, executeAcceptance.rejectionIssue.requiredNextAction, executeAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedExecuteRef: executeAcceptance.acceptedExecuteRef,
+        executeAcceptanceStatus: executeAcceptance.executeAcceptanceStatus,
+        acceptedTasksHandoffRef: acceptedTasksHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'tasks', 'execute')}` } : null,
+        truthAlignmentProjectionRef,
+        laneEvidenceRefs: executeAcceptance.laneEvidenceRefs,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: executeAcceptance.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('execute-adjudication', decision.scope, health, generatedAt),
+        stage: 'execute',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('execute-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'execute',
+            scope: decision.scope,
+            status: health === 'ready_for_ship' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: outputRefs,
+            advisoryRefs: [],
+            capabilityRefs: executeAcceptance.laneEvidenceRefs,
+            blockingReasons: health === 'ready_for_ship' || health === 'no-op' ? [] : executeAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('execute', decision.scope, generatedAt, health === 'ready_for_ship' ? ['stage_ready', 'handoff_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
+        closureRefs,
+        createdAt: generatedAt
+    };
+    await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+    await recordStageRunProjection(projectRoot, stageRun);
+    if (truthAlignmentProjection) {
+        await recordTruthAlignmentProjection(projectRoot, truthAlignmentProjection);
+    }
+    if (handoff) {
+        await recordWorkflowHandoffProjection(projectRoot, handoff);
+    }
+    const projection = await recordExecuteCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedExecuteRef: executeAcceptance.acceptedExecuteRef
+    };
+}
+export async function reconcileShipCollaborationClosure(projectRoot, input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const context = await resolveSddContext(projectRoot, { branch: input.decision.scope.branch, branchSource: 'cli_option' });
+    const decision = {
+        ...input.decision,
+        scope: { ...input.decision.scope, branch: context.rawBranch }
+    };
+    const run = await createRun(projectRoot, {
+        runId: input.runId,
+        branch: context.rawBranch,
+        lifecycleDecision: runLifecycleDecisionRecord(decision)
+    });
+    const runRef = { kind: 'run', ref: run.runId };
+    const shipRequired = decision.requiredStages.includes('ship');
+    const openShipBlockers = shipBlockerCount(decision);
+    const blockedReason = openShipBlockers > 0
+        ? 'Lifecycle risk decision has open ship blockers.'
+        : 'Lifecycle risk decision blocks ship closure.';
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('ship') || openShipBlockers > 0;
+    const truthAlignmentEnvelope = await readTruthAlignmentProjection(projectRoot, decision.scope);
+    const workOrderInputRefs = truthAlignmentEnvelope?.payload.acceptedRealityRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${shipCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = shipRequired && !blocked ? buildShipStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'ship', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'ship', input.artifactRefs, Boolean(workOrder), run.runId, generatedAt);
+    const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
+    const lifecycleRiskProjectionRef = {
+        kind: 'projection',
+        ref: `${LIFECYCLE_RISK_DECISION_PROJECTION_TYPE}:${lifecycleRiskDecisionScopeKey(decision.scope)}`
+    };
+    const adjudicationProjectionRef = shipAdjudicationProjectionRef(decision.scope);
+    const shipReadiness = await validateAcceptedShipReadinessArtifact(projectRoot, {
+        partition: context.partition,
+        required: shipRequired,
+        blocked,
+        blockedReason,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        truthAlignment: truthAlignmentEnvelope?.payload ?? null
+    });
+    const health = shipReadiness.shipReadinessStatus === 'accepted'
+        ? 'ship_ready'
+        : !shipRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const truthAlignmentProjectionRef = truthAlignmentEnvelope ? { kind: 'projection', ref: `${TRUTH_ALIGNMENT_PROJECTION_TYPE}:${truthAlignmentScopeKey({ branch: decision.scope.branch })}` } : null;
+    const outputRefs = [shipReadiness.acceptedShipReadinessRef, shipReadiness.releaseDocumentRef, truthAlignmentProjectionRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildShipClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: truthAlignmentEnvelope?.payload.acceptedRealityRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: shipReadiness.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const rejection = shipReadiness.rejectionIssue
+        ? buildStageRejection('ship', decision.scope, null, shipReadiness.rejectionIssue.reasonCode, shipReadiness.rejectionIssue.explanation, shipReadiness.rejectionIssue.requiredNextAction, shipReadiness.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedShipReadinessRef: shipReadiness.acceptedShipReadinessRef,
+        shipReadinessStatus: shipReadiness.shipReadinessStatus,
+        shipReadinessHash: shipReadiness.shipReadinessHash,
+        releaseDocumentRef: shipReadiness.releaseDocumentRef,
+        truthAlignmentProjectionRef,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        reasons: shipReadiness.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('ship-adjudication', decision.scope, health, generatedAt),
+        stage: 'ship',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('ship-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'ship',
+            scope: decision.scope,
+            status: health === 'ship_ready' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: outputRefs,
+            advisoryRefs: [],
+            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('ship') || ref.ref.includes('release') || ref.ref.includes('capability')),
+            blockingReasons: health === 'ship_ready' || health === 'no-op' ? [] : shipReadiness.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: null,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('ship', decision.scope, generatedAt, health === 'ship_ready' ? ['stage_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
+        closureRefs,
+        createdAt: generatedAt
+    };
+    await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+    await recordStageRunProjection(projectRoot, stageRun);
+    const projection = await recordShipCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedShipReadinessRef: shipReadiness.acceptedShipReadinessRef,
+        releaseDocumentRef: shipReadiness.releaseDocumentRef
+    };
+}
+const FULL_STAGE_CHAIN = [
+    { stage: 'spec', expectedHealth: 'ready_for_plan', projectionType: SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'plan', expectedHealth: 'ready_for_tasks', projectionType: PLAN_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'tasks', expectedHealth: 'ready_for_execute', projectionType: TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'execute', expectedHealth: 'ready_for_ship', projectionType: EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'ship', expectedHealth: 'ship_ready', projectionType: SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE }
+];
+export async function inspectFullStageChain(projectRoot, branch) {
+    const projections = await listRuntimeProjections(projectRoot, FULL_STAGE_CHAIN.map((item) => item.projectionType));
+    const envelopes = projections
+        .map((projection) => projection.payload)
+        .filter((envelope) => envelope?.payload?.scope?.branch === branch);
+    const stages = FULL_STAGE_CHAIN.map((item) => fullStageChainStage(item, latestStageChainEnvelope(envelopes, item.projectionType, item.stage)));
+    const completedStages = stages.filter((stage) => stage.status === 'completed' && stage.health === stage.expectedHealth).length;
+    const validatedCollaborationContracts = stages.filter((stage) => stage.collaborationContractStatus === 'validated').length;
+    const handoffs = stages.filter((stage) => stage.handoffProjectionRef !== null).length;
+    const status = fullStageChainStatus(stages);
+    return {
+        contract: 'sdd-full-stage-chain-diagnostic-v1',
+        branch,
+        status,
+        stages,
+        projectionCounts: {
+            adjudications: stages.filter((stage) => stage.projectionRef !== null).length,
+            completedStages,
+            validatedCollaborationContracts,
+            handoffs
+        },
+        finalHealth: fullStageChainFinalHealth(stages),
+        reasons: fullStageChainReasons(status, stages)
+    };
+}
+async function collectTruthAlignmentDeclaredTruthRefs(projectRoot, branch, testHandoff) {
+    const projectionTypes = FULL_STAGE_CHAIN
+        .filter((item) => item.stage !== 'ship')
+        .map((item) => item.projectionType);
+    const projections = await listRuntimeProjections(projectRoot, projectionTypes);
+    const envelopes = projections
+        .map((projection) => projection.payload)
+        .filter((envelope) => envelope?.payload?.scope?.branch === branch);
+    const acceptedRefs = FULL_STAGE_CHAIN
+        .filter((item) => item.stage !== 'ship')
+        .map((item) => latestStageChainEnvelope(envelopes, item.projectionType, item.stage))
+        .map((envelope) => envelope ? acceptedRefFromAdjudication(envelope.payload.stage, envelope.payload) : null)
+        .filter((ref) => ref !== null);
+    return uniqueRuntimeRefs([...acceptedRefs, ...(testHandoff?.requiredInputRefs ?? [])]);
+}
+function latestStageChainEnvelope(envelopes, projectionType, stage) {
+    return envelopes
+        .filter((envelope) => envelope.projectionType === projectionType && envelope.payload.stage === stage)
+        .sort((left, right) => right.generatedAt.localeCompare(left.generatedAt))[0] ?? null;
+}
+function fullStageChainStage(item, envelope) {
+    const adjudication = envelope?.payload ?? null;
+    const closureRefs = (adjudication?.closureRefs ?? {});
+    const collaborationContractRef = runtimeRefValue(closureRefs.collaborationContractRef);
+    const handoff = adjudication?.handoffPacket ? {
+        fromStage: adjudication.handoffPacket.fromStage,
+        toStage: adjudication.handoffPacket.toStage,
+        status: adjudication.handoffPacket.status
+    } : null;
+    const acceptedRef = adjudication ? acceptedRefFromAdjudication(item.stage, adjudication) : null;
+    return {
+        stage: item.stage,
+        expectedHealth: item.expectedHealth,
+        projectionType: item.projectionType,
+        projectionRef: envelope ? { kind: 'projection', ref: `${envelope.projectionType}:${envelope.scopeKey}` } : null,
+        health: adjudication?.health ?? null,
+        status: adjudication?.stageDecision?.status ?? null,
+        acceptedRef,
+        acceptedHash: acceptedRef?.hash ?? null,
+        collaborationContractRef,
+        collaborationContractStatus: collaborationContractRef ? 'validated' : 'missing',
+        handoff,
+        handoffProjectionRef: runtimeRefValue(closureRefs.workflowHandoffProjectionRef),
+        reasons: Array.isArray(closureRefs.reasons) ? closureRefs.reasons.filter((reason) => typeof reason === 'string') : adjudication?.rejection ? [adjudication.rejection.explanation] : []
+    };
+}
+function acceptedRefFromAdjudication(stage, adjudication) {
+    const closureRefs = (adjudication.closureRefs ?? {});
+    const keyByStage = {
+        spec: 'acceptedSpecRef',
+        plan: 'acceptedPlanRef',
+        tasks: 'acceptedTasksRef',
+        execute: 'acceptedExecuteRef',
+        ship: 'acceptedShipReadinessRef'
+    };
+    return runtimeRefValue(closureRefs[keyByStage[stage]]) ?? adjudication.stageDecision?.acceptedDecisionRefs[0] ?? null;
+}
+function runtimeRefValue(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const candidate = value;
+    if (typeof candidate.kind !== 'string' || typeof candidate.ref !== 'string') {
+        return null;
+    }
+    return {
+        kind: candidate.kind,
+        ref: candidate.ref,
+        hash: typeof candidate.hash === 'string' ? candidate.hash : undefined
+    };
+}
+function fullStageChainFinalHealth(stages) {
+    return [...stages]
+        .reverse()
+        .find((stage) => stage.status === 'completed' && stage.health === stage.expectedHealth)?.health ?? null;
+}
+function fullStageChainStatus(stages) {
+    if (stages.every((stage) => stage.projectionRef === null)) {
+        return 'missing';
+    }
+    if (stages.some((stage) => stage.status === 'rejected' || stage.health === 'rejected')) {
+        return 'rejected';
+    }
+    if (stages.some((stage) => stage.status === 'blocked' || stage.health === 'blocked')) {
+        return 'blocked';
+    }
+    if (stages.every((stage) => stage.status === 'completed' && stage.health === stage.expectedHealth && stage.collaborationContractStatus === 'validated')) {
+        return 'ready';
+    }
+    return 'partial';
+}
+function fullStageChainReasons(status, stages) {
+    if (status === 'missing') {
+        return ['No Phase 9 stage collaboration adjudication projections found.'];
+    }
+    if (status === 'ready') {
+        return ['Active Phase 9 stage chain is closed through ship_ready with validated collaboration contracts.'];
+    }
+    return stages
+        .filter((stage) => stage.status !== 'completed' || stage.health !== stage.expectedHealth || stage.collaborationContractStatus !== 'validated')
+        .map((stage) => `${stage.stage} is ${stage.health ?? 'missing'}; expected ${stage.expectedHealth}; collaboration_contract=${stage.collaborationContractStatus}.`);
+}
+export async function inspectSpecCollaborationHealth(projectRoot, branch) {
+    const projections = await listRuntimeProjections(projectRoot, [SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE]);
+    const envelopes = projections
+        .map((projection) => projection.payload)
+        .filter((envelope) => envelope?.payload?.scope?.branch === branch);
+    const latest = envelopes[0]?.payload ?? null;
+    if (!latest) {
+        return {
+            status: 'missing',
+            branch,
+            latest: null,
+            projectionCount: envelopes.length,
+            latestClarificationGateId: null,
+            latestHandoffId: null,
+            latestRejectionReason: null,
+            reasons: ['No spec collaboration adjudication projection found.']
+        };
+    }
+    if (latest.contract !== STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION) {
+        return {
+            status: 'incompatible',
+            branch,
+            latest,
+            projectionCount: envelopes.length,
+            latestClarificationGateId: latest.clarificationGate?.gateId ?? null,
+            latestHandoffId: latest.handoffPacket?.handoffId ?? null,
+            latestRejectionReason: latest.rejection?.reasonCode ?? null,
+            reasons: ['Latest spec collaboration projection has an incompatible contract.']
+        };
+    }
+    return {
+        status: latest.health,
+        branch,
+        latest,
+        projectionCount: envelopes.length,
+        latestClarificationGateId: latest.clarificationGate?.gateId ?? null,
+        latestHandoffId: latest.handoffPacket?.handoffId ?? null,
+        latestRejectionReason: latest.rejection?.reasonCode ?? null,
+        reasons: specCollaborationDiagnosticReasons(latest)
+    };
+}
+export function adjudicateSpecStageClosureRequest(input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    if (input.profile.intensity === 'blocked') {
+        return rejected(input, 'blocked_lifecycle', 'Lifecycle risk decision blocks spec collaboration.', 'Resolve lifecycle blockers before retrying spec collaboration.', 'runtime-blocked', generatedAt, false);
+    }
+    if (!input.profile.required) {
+        return noOpResult(input.profile, generatedAt);
+    }
+    const closureIssue = validateStageClosureRequest(input);
+    if (closureIssue) {
+        return rejected(input, closureIssue.reasonCode, closureIssue.explanation, closureIssue.requiredNextAction, closureIssue.fallbackRoute, generatedAt, closureIssue.retryAllowed);
+    }
+    const closureRequest = input.closureRequest;
+    const acceptedItems = closureRequest.candidate?.acceptedItems ?? [];
+    const blockingItems = acceptedItems.filter((item) => item.kind === 'blocking_ambiguity' || closureRequest.unresolvedAmbiguityIds.includes(item.id));
+    if (blockingItems.length > 0 && (input.answerRefs ?? []).length === 0) {
+        const clarificationGate = {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            gateId: stableId('spec-clarification', input.profile.scope, closureRequest.closureRequestId, generatedAt),
+            stage: 'spec',
+            scope: input.profile.scope,
+            status: 'needs_clarification',
+            questions: blockingItems.map((item) => item.summary),
+            blockingItemIds: blockingItems.map((item) => item.id),
+            requiredResponder: 'user',
+            createdAt: generatedAt,
+            answerRefs: []
+        };
+        return baseResult(input.profile, generatedAt, {
+            health: 'needs_clarification',
+            acceptedItemIds: acceptedItems.filter((item) => item.kind !== 'blocking_ambiguity').map((item) => item.id),
+            clarificationGate,
+            nextActions: buildRuntimeNextActions(input.profile, generatedAt, ['unresolved_ambiguity'])
+        });
+    }
+    const acceptedItemIds = acceptedItems.map((item) => item.id);
+    const decisionRecord = buildSpecDecisionRecord(input.profile, closureRequest, input.answerRefs ?? [], acceptedItemIds, generatedAt);
+    const stageDecision = buildStageRuntimeDecision(input.profile, closureRequest, decisionRecord, generatedAt);
+    const handoffPacket = buildStageHandoffPacket(input.profile, closureRequest, decisionRecord, generatedAt);
+    return baseResult(input.profile, generatedAt, {
+        health: 'ready_for_plan',
+        acceptedItemIds,
+        specDecisionRecord: decisionRecord,
+        stageDecision,
+        handoffPacket,
+        nextActions: buildRuntimeNextActions(input.profile, generatedAt, ['stage_ready', 'handoff_ready'])
+    });
+}
+function planMemberAgents(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return [PLAN_STAGE_REVIEW_AGENT];
+    }
+    return [PLAN_STAGE_SCOUT_AGENT, PLAN_STAGE_REVIEW_AGENT];
+}
+function planScoutDomains(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked' || intensity === 'lightweight') {
+        return [];
+    }
+    if (intensity === 'scout-first') {
+        return ['architecture-runtime', 'testing-validation'];
+    }
+    return ['architecture-runtime', 'backend-api', 'database-migration', 'security', 'testing-validation'];
+}
+function planRequiredOutputKinds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['plan_review', 'manager_closure_request'];
+    }
+    return ['plan_context', 'plan_review', 'manager_closure_request'];
+}
+function planRequiredCapabilities(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['plan-strategy', 'plan-pressure-review'];
+    }
+    return ['plan-strategy', 'plan-pressure-review', ...planScoutDomains(intensity)];
+}
+function planOptionalCapabilities(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    return PLAN_SCOUT_DOMAINS.filter((domain) => !planScoutDomains(intensity).includes(domain));
+}
+function planMaterialPackIds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['project-norms', 'plan-section-rubric'];
+    }
+    return [...PLAN_STAGE_MATERIAL_PACKS];
+}
+function planCollaborationPlan(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return { topology: 'none', participants: [], maxParallelism: 0, fanIn: 'runtime_adjudication' };
+    }
+    const requiredCapabilities = planRequiredCapabilities(intensity);
+    const optionalCapabilities = planOptionalCapabilities(intensity);
+    const materialPackIds = planMaterialPackIds(intensity);
+    const participants = [
+        { id: PLAN_STAGE_MANAGER, kind: 'agent', role: 'plan-stage-manager', required: true, capabilityDomain: 'plan-strategy', parallelGroup: null },
+        ...planMemberAgents(intensity).map((agent) => ({
+            id: agent,
+            kind: 'subagent',
+            role: planAgentRole(agent),
+            required: agent === PLAN_STAGE_REVIEW_AGENT,
+            capabilityDomain: planAgentCapability(agent),
+            parallelGroup: planAgentParallelGroup(agent)
+        })),
+        ...requiredCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'required-capability-review', required: true, capabilityDomain: capability, parallelGroup: 'capability-review' })),
+        ...optionalCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'optional-capability-review', required: false, capabilityDomain: capability, parallelGroup: 'capability-review' })),
+        ...materialPackIds.map((packId) => ({ id: packId, kind: 'material-pack', role: 'capability-material', required: false, parallelGroup: 'material-pack' }))
+    ];
+    const topology = intensity === 'lightweight' ? 'team-lite' : intensity === 'scout-first' ? 'parallel-research' : 'team-required';
+    return { topology, participants, maxParallelism: topology === 'team-lite' ? 2 : 3, fanIn: 'runtime_adjudication' };
+}
+function planAgentRole(agent) {
+    switch (agent) {
+        case PLAN_STAGE_SCOUT_AGENT:
+            return 'domain-evidence-scout';
+        case PLAN_STAGE_REVIEW_AGENT:
+            return 'plan-pressure-reviewer';
+    }
+}
+function planAgentCapability(agent) {
+    switch (agent) {
+        case PLAN_STAGE_SCOUT_AGENT:
+            return 'architecture-runtime';
+        case PLAN_STAGE_REVIEW_AGENT:
+            return 'plan-pressure-review';
+    }
+}
+function planAgentParallelGroup(agent) {
+    switch (agent) {
+        case PLAN_STAGE_SCOUT_AGENT:
+            return 'domain-scouting';
+        case PLAN_STAGE_REVIEW_AGENT:
+            return 'review';
+    }
+}
+function specIntensity(decision, required) {
+    if (decision.profile === 'blocked' || decision.blockedStages.includes('spec')) {
+        return 'blocked';
+    }
+    if (!required || decision.profile === 'direct') {
+        return 'noop';
+    }
+    if (decision.profile === 'compact') {
+        return 'lightweight';
+    }
+    if (decision.profile === 'research') {
+        return 'scout-first';
+    }
+    return 'team-required';
+}
+function specProfileReasons(decision, required, intensity) {
+    if (intensity === 'blocked') {
+        return ['Lifecycle risk decision blocks spec collaboration.', ...decision.reasons];
+    }
+    if (!required) {
+        return ['Spec stage is not required by lifecycle risk decision.', ...decision.reasons];
+    }
+    if (intensity === 'scout-first') {
+        return ['Research profile requires spec-stage uncertainty discovery before plan handoff.', ...decision.reasons];
+    }
+    if (intensity === 'team-required') {
+        return ['Full lifecycle requires runtime-adjudicated spec collaboration before plan handoff.', ...decision.reasons];
+    }
+    return ['Spec collaboration can remain lightweight for this lifecycle decision.', ...decision.reasons];
+}
+function specMemberAgents(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return [SPEC_STAGE_REVIEW_AGENT];
+    }
+    return [SPEC_STAGE_SCOUT_AGENT, SPEC_STAGE_REVIEW_AGENT];
+}
+function specRequiredOutputKinds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['spec_review', 'manager_closure_request'];
+    }
+    return ['scout_context', 'spec_review', 'manager_closure_request'];
+}
+function specRequiredCapabilities(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['norm_discovery'];
+    }
+    return SPEC_STAGE_REQUIRED_CAPABILITIES;
+}
+function specOptionalCapabilities(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['uncertainty_resolution', 'context_curation'];
+    }
+    return SPEC_STAGE_OPTIONAL_CAPABILITIES;
+}
+function specMaterialPackIds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['project-norms', 'uncertainty-map'];
+    }
+    return [...SPEC_STAGE_MATERIAL_PACKS];
+}
+function specCollaborationPlan(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return { topology: 'none', participants: [], maxParallelism: 0, fanIn: 'runtime_adjudication' };
+    }
+    const requiredCapabilities = specRequiredCapabilities(intensity);
+    const optionalCapabilities = specOptionalCapabilities(intensity);
+    const materialPackIds = specMaterialPackIds(intensity);
+    const participants = [
+        { id: SPEC_STAGE_MANAGER, kind: 'agent', role: 'spec-stage-manager', required: true, capabilityDomain: 'uncertainty_resolution', parallelGroup: null },
+        ...specMemberAgents(intensity).map((agent) => ({
+            id: agent,
+            kind: 'subagent',
+            role: agent === SPEC_STAGE_SCOUT_AGENT ? 'bounded-context-scout' : 'spec-document-reviewer',
+            required: true,
+            capabilityDomain: agent === SPEC_STAGE_SCOUT_AGENT ? 'context_curation' : 'uncertainty_resolution',
+            parallelGroup: agent === SPEC_STAGE_SCOUT_AGENT ? 'discovery' : 'review'
+        })),
+        ...requiredCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'required-capability-review', required: true, capabilityDomain: capability, parallelGroup: 'capability-review' })),
+        ...optionalCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'optional-capability-review', required: false, capabilityDomain: capability, parallelGroup: 'capability-review' })),
+        ...materialPackIds.map((packId) => ({ id: packId, kind: 'material-pack', role: 'capability-material', required: false, parallelGroup: 'material-pack' }))
+    ];
+    const topology = intensity === 'lightweight' ? 'team-lite' : intensity === 'scout-first' ? 'parallel-research' : 'team-required';
+    return { topology, participants, maxParallelism: topology === 'team-lite' ? 2 : 4, fanIn: 'runtime_adjudication' };
+}
+function validateStageClosureRequest(input) {
+    const request = input.closureRequest;
+    if (!request) {
+        return { reasonCode: 'invalid_proposal', explanation: 'Spec stage closure requires a StageClosureRequest from spec-manager.', requiredNextAction: 'Submit spec-manager closure request with final spec ref/hash and runtime close boundary facts.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    if (request.stage !== 'spec') {
+        return { reasonCode: 'unsupported_stage', explanation: `Spec runtime cannot close ${request.stage} closure requests.`, requiredNextAction: 'Route the closure request to the matching stage runtime.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    if (request.authorityAttempts.length > 0) {
+        return { reasonCode: 'authority_violation', explanation: `Spec stage closure attempted workflow authority: ${request.authorityAttempts.join(', ')}.`, requiredNextAction: 'Remove workflow-authority attempts from manager and agent-team outputs.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    if (request.candidate && request.candidate.stage !== 'spec') {
+        return { reasonCode: 'unsupported_stage', explanation: `Spec runtime cannot close ${request.candidate.stage} candidates.`, requiredNextAction: 'Route the candidate to the matching stage runtime.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    const unsupported = request.candidate?.acceptedItems.find((item) => !input.profile.allowedProposalKinds.includes(item.kind));
+    if (unsupported) {
+        return { reasonCode: 'invalid_proposal', explanation: `Spec candidate item ${unsupported.id} uses unsupported kind ${unsupported.kind}.`, requiredNextAction: 'Submit only allowed spec candidate item kinds for this profile.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    const missingItemRef = request.candidate?.acceptedItems.find((item) => item.refs.length === 0);
+    if (missingItemRef) {
+        return { reasonCode: 'missing_refs', explanation: `Spec candidate item ${missingItemRef.id} has no refs.`, requiredNextAction: 'Attach source refs to every candidate item.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    if (request.managerRecommendation === 'close_stage' && !request.runtimeCloseBoundaryFacts) {
+        return { reasonCode: 'missing_refs', explanation: 'Spec stage close request is missing runtime close boundary facts for the final spec.md V3.', requiredNextAction: 'Ask spec-manager to submit finalSpecRef/finalSpecHash, section close declaration, review signal presence, and blockingBeforePlanCount=0.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    return null;
+}
+function noOpResult(profile, generatedAt) {
+    const decisionRecord = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        decisionId: stableId('spec-decision', profile.scope, 'noop', generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        source: 'runtime-noop',
+        acceptedItemIds: [],
+        answerRefs: [],
+        decisionRefs: profile.inputRefs,
+        mustNotAssume: [],
+        createdAt: generatedAt
+    };
+    const stageDecision = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        decisionId: stableId('spec-stage-decision', profile.scope, 'noop', generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        status: 'skipped',
+        health: 'no-op',
+        acceptedDecisionRefs: decisionRecord.decisionRefs,
+        advisoryRefs: [],
+        capabilityRefs: [],
+        blockingReasons: [],
+        createdAt: generatedAt
+    };
+    return baseResult(profile, generatedAt, { health: 'no-op', specDecisionRecord: decisionRecord, stageDecision });
+}
+function buildSpecDecisionRecord(profile, closureRequest, answerRefs, acceptedItemIds, generatedAt) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        decisionId: stableId('spec-decision', profile.scope, closureRequest.closureRequestId, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        source: answerRefs.length > 0 ? 'clarification-answer' : 'stage-closure-request',
+        acceptedItemIds,
+        answerRefs,
+        decisionRefs: closureDecisionRefs(closureRequest, answerRefs),
+        mustNotAssume: closureRequest.candidate?.acceptedItems.filter((item) => item.kind === 'blocking_ambiguity').map((item) => item.summary) ?? [],
+        createdAt: generatedAt
+    };
+}
+function buildStageRuntimeDecision(profile, closureRequest, decisionRecord, generatedAt) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        decisionId: stableId('spec-stage-decision', profile.scope, closureRequest.closureRequestId, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        status: 'completed',
+        health: 'ready_for_plan',
+        acceptedDecisionRefs: decisionRecord.decisionRefs,
+        advisoryRefs: refsByCandidateKind(closureRequest, 'advisory_finding'),
+        capabilityRefs: refsByCandidateKind(closureRequest, 'capability_suggestion'),
+        blockingReasons: [],
+        createdAt: generatedAt
+    };
+}
+function buildStageHandoffPacket(profile, closureRequest, decisionRecord, generatedAt) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        handoffId: stableId('spec-plan-handoff', profile.scope, closureRequest.closureRequestId, generatedAt),
+        scope: profile.scope,
+        fromStage: 'spec',
+        toStage: 'plan',
+        status: 'proposed',
+        acceptedSpecDecisionRefs: decisionRecord.decisionRefs,
+        advisoryRefs: refsByCandidateKind(closureRequest, 'advisory_finding'),
+        capabilityRefs: refsByCandidateKind(closureRequest, 'capability_suggestion'),
+        unresolvedRisks: [],
+        mustNotAssume: decisionRecord.mustNotAssume,
+        recommendedNextStageRoles: recommendedPlanRoles(profile),
+        createdAt: generatedAt
+    };
+}
+function refsByCandidateKind(closureRequest, kind) {
+    return closureRequest.candidate?.acceptedItems.filter((item) => item.kind === kind).flatMap((item) => item.refs) ?? [];
+}
+function closureDecisionRefs(closureRequest, answerRefs) {
+    return [
+        closureRequest.workOrderRef,
+        closureRequest.coordinationRef,
+        closureRequest.candidateRef,
+        ...closureRequest.reviewRefs,
+        ...closureRequest.capabilityFindingRefs,
+        ...closureRequest.evidenceRefs,
+        ...answerRefs
+    ].filter((ref) => ref !== null);
+}
+function recommendedPlanRoles(profile) {
+    if (profile.intensity === 'scout-first') {
+        return ['role.norm-scout', 'role.uncertainty-reviewer'];
+    }
+    if (profile.intensity === 'team-required') {
+        return ['role.norm-scout', 'role.performance-planner', 'role.verification-designer'];
+    }
+    return [];
+}
+function rejected(input, reasonCode, explanation, requiredNextAction, fallbackRoute, generatedAt, retryAllowed) {
+    const closureRequestId = input.closureRequest?.closureRequestId ?? null;
+    const rejection = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        rejectionId: stableId('spec-rejection', input.profile.scope, closureRequestId ?? reasonCode, generatedAt),
+        stage: 'spec',
+        scope: input.profile.scope,
+        closureRequestId,
+        reasonCode,
+        explanation,
+        requiredNextAction,
+        retryAllowed,
+        retryBudgetRemaining: retryAllowed ? input.retryBudgetRemaining ?? 1 : 0,
+        fallbackRoute,
+        createdAt: generatedAt
+    };
+    return baseResult(input.profile, generatedAt, {
+        health: reasonCode === 'blocked_lifecycle' ? 'blocked' : 'rejected',
+        rejection,
+        nextActions: buildRuntimeNextActions(input.profile, generatedAt, [rejectionReasonToNextActionReason(reasonCode)])
+    });
+}
+function baseResult(profile, generatedAt, overrides) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('spec-adjudication', profile.scope, overrides.health ?? 'unknown', generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        health: overrides.health ?? 'rejected',
+        acceptedItemIds: overrides.acceptedItemIds ?? [],
+        clarificationGate: overrides.clarificationGate ?? null,
+        specDecisionRecord: overrides.specDecisionRecord ?? null,
+        stageDecision: overrides.stageDecision ?? null,
+        handoffPacket: overrides.handoffPacket ?? null,
+        rejection: overrides.rejection ?? null,
+        nextActions: overrides.nextActions ?? [],
+        createdAt: generatedAt
+    };
+}
+function rejectionReasonToNextActionReason(reasonCode) {
+    if (reasonCode === 'authority_violation') {
+        return 'authority_violation';
+    }
+    if (reasonCode === 'missing_required_review') {
+        return 'missing_required_review';
+    }
+    if (reasonCode === 'missing_refs') {
+        return 'insufficient_evidence';
+    }
+    if (reasonCode === 'blocked_lifecycle') {
+        return 'graph_illegal';
+    }
+    return 'manager_rework_required';
+}
+function buildRuntimeNextActions(profile, generatedAt, reasonCodes) {
+    return reasonCodes
+        .map((reasonCode, index) => ({
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        actionId: stableId('spec-next-action', profile.scope, reasonCode, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        kind: nextActionKind(reasonCode),
+        owner: nextActionOwner(reasonCode),
+        actionScope: nextActionScope(reasonCode),
+        reasonCode,
+        priority: {
+            reasonRank: reasonCodeRank(reasonCode),
+            upstreamDistance: 0,
+            actionRank: actionKindRank(nextActionKind(reasonCode)),
+            stableOrder: index
+        },
+        requiredInputs: nextActionRequiredInputs(reasonCode),
+        blockedBy: [],
+        createdAt: generatedAt
+    }))
+        .sort(compareRuntimeNextAction);
+}
+function compareRuntimeNextAction(left, right) {
+    return left.priority.reasonRank - right.priority.reasonRank
+        || left.priority.upstreamDistance - right.priority.upstreamDistance
+        || left.priority.actionRank - right.priority.actionRank
+        || left.priority.stableOrder - right.priority.stableOrder;
+}
+function reasonCodeRank(reasonCode) {
+    const order = ['authority_violation', 'graph_illegal', 'scope_unresolved', 'ambiguous_target', 'missing_canonical_artifact', 'stale_upstream', 'missing_handoff', 'missing_required_review', 'unresolved_conflict', 'unresolved_ambiguity', 'insufficient_evidence', 'manager_rework_required', 'human_required', 'stage_ready', 'handoff_ready', 'report_only'];
+    return order.indexOf(reasonCode);
+}
+function nextActionKind(reasonCode) {
+    if (reasonCode === 'authority_violation' || reasonCode === 'graph_illegal') {
+        return 'reject_proposal';
+    }
+    if (reasonCode === 'missing_required_review') {
+        return 'collect_required_review';
+    }
+    if (reasonCode === 'unresolved_ambiguity') {
+        return 'ask_user_clarification';
+    }
+    if (reasonCode === 'handoff_ready') {
+        return 'create_handoff';
+    }
+    if (reasonCode === 'stage_ready') {
+        return 'commit_stage_closure';
+    }
+    if (reasonCode === 'stale_upstream') {
+        return 'refresh_upstream_stage';
+    }
+    if (reasonCode === 'report_only') {
+        return 'report_status';
+    }
+    return 'request_manager_rework';
+}
+function nextActionOwner(reasonCode) {
+    if (reasonCode === 'unresolved_ambiguity' || reasonCode === 'human_required') {
+        return 'user';
+    }
+    if (reasonCode === 'stage_ready' || reasonCode === 'handoff_ready' || reasonCode === 'report_only') {
+        return 'runtime';
+    }
+    if (reasonCode === 'scope_unresolved' || reasonCode === 'ambiguous_target') {
+        return 'orchestrator';
+    }
+    return 'stage-manager';
+}
+function nextActionScope(reasonCode) {
+    if (reasonCode === 'unresolved_ambiguity' || reasonCode === 'human_required') {
+        return 'human';
+    }
+    if (reasonCode === 'stage_ready' || reasonCode === 'handoff_ready') {
+        return 'runtime';
+    }
+    if (reasonCode === 'scope_unresolved' || reasonCode === 'ambiguous_target') {
+        return 'global';
+    }
+    return 'stage';
+}
+function actionKindRank(kind) {
+    const order = ['reject_proposal', 'refresh_upstream_stage', 'collect_required_review', 'resolve_ambiguity', 'request_manager_rework', 'ask_user_clarification', 'commit_stage_closure', 'create_handoff', 'report_status'];
+    return order.indexOf(kind);
+}
+function nextActionRequiredInputs(reasonCode) {
+    if (reasonCode === 'missing_required_review') {
+        return ['SpecReviewResult'];
+    }
+    if (reasonCode === 'unresolved_ambiguity') {
+        return ['ClarificationGate answer'];
+    }
+    if (reasonCode === 'insufficient_evidence') {
+        return ['runtime evidence refs'];
+    }
+    return [];
+}
+function specCollaborationDiagnosticReasons(result) {
+    if (result.health === 'no-op') {
+        return ['Spec collaboration is not required for this lifecycle decision.'];
+    }
+    if (result.health === 'needs_clarification') {
+        return result.clarificationGate?.questions ?? ['Spec collaboration is waiting for clarification.'];
+    }
+    if (result.health === 'ready_for_plan') {
+        return [`Spec collaboration is ready for plan handoff ${result.handoffPacket?.handoffId ?? 'none'}.`];
+    }
+    if (result.health === 'blocked') {
+        return [result.rejection?.explanation ?? 'Spec collaboration is blocked.'];
+    }
+    return [result.rejection?.explanation ?? 'Spec collaboration proposal was rejected.'];
+}
+async function registerStageCollaborationContracts(projectRoot, branch, stage, workOrder, contractRefs, registeredAt) {
+    const refs = await collectStageCollaborationContractRefs(projectRoot, branch, stage, contractRefs, Boolean(workOrder));
+    const records = [];
+    for (const ref of refs) {
+        const artifact = await readStageCollaborationContract(projectRoot, ref);
+        const record = validateStageCollaborationContractFrontmatter({
+            branch,
+            stage,
+            ref: artifact.ref,
+            hash: artifact.hash,
+            frontmatter: artifact.frontmatter,
+            workOrder,
+            registeredAt
+        });
+        records.push(await recordRuntimeStageCollaborationContract(projectRoot, record));
+    }
+    return records;
+}
+async function collectStageCollaborationContractRefs(projectRoot, branch, stage, contractRefs, required) {
+    if (contractRefs && contractRefs.length > 0) {
+        return [...new Set(contractRefs.map(normalizeBranchStageEvidenceRef))];
+    }
+    if (!required) {
+        return [];
+    }
+    const dir = getBranchStageEvidenceDir(projectRoot, branch, stage);
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+    return files
+        .filter((fileName) => isStageCollaborationContractFile(stage, fileName))
+        .sort(compareStageEvidenceFileNames)
+        .map((fileName) => toBranchStageEvidenceRef(branch, stage, fileName));
+}
+async function registerSpecStageArtifacts(projectRoot, branch, profile, artifactRefs, runId, registeredAt) {
+    const refs = await collectSpecStageEvidenceRefs(projectRoot, branch, profile, artifactRefs);
+    const records = [];
+    for (const ref of refs) {
+        const artifact = await readMarkdownArtifact(projectRoot, ref);
+        const record = validateStageArtifactFrontmatter({
+            branch,
+            stage: 'spec',
+            ref: artifact.ref,
+            hash: artifact.hash,
+            frontmatter: artifact.frontmatter,
+            registeredAt
+        });
+        records.push(await recordRuntimeStageArtifact(projectRoot, record));
+        await recordRegisteredStageArtifactPayload(projectRoot, runId, artifact, record);
+    }
+    return records;
+}
+async function collectSpecStageEvidenceRefs(projectRoot, branch, profile, artifactRefs) {
+    void projectRoot;
+    void branch;
+    void profile;
+    if (artifactRefs && artifactRefs.length > 0) {
+        return [...new Set(artifactRefs.map(normalizeBranchStageEvidenceRef))];
+    }
+    return [];
+}
+async function registerBranchStageArtifacts(projectRoot, branch, stage, artifactRefs, required, runId, registeredAt) {
+    const refs = await collectBranchStageEvidenceRefs(projectRoot, branch, stage, artifactRefs, required);
+    const records = [];
+    for (const ref of refs) {
+        const artifact = await readMarkdownArtifact(projectRoot, ref);
+        const record = validateStageArtifactFrontmatter({
+            branch,
+            stage,
+            ref: artifact.ref,
+            hash: artifact.hash,
+            frontmatter: artifact.frontmatter,
+            registeredAt
+        });
+        records.push(await recordRuntimeStageArtifact(projectRoot, record));
+        await recordRegisteredStageArtifactPayload(projectRoot, runId, artifact, record);
+    }
+    return records;
+}
+async function recordRegisteredStageArtifactPayload(projectRoot, runId, artifact, record) {
+    const physicalPayloadPath = `runtime.sqlite:${runId}:${artifact.ref}`;
+    await recordRuntimeArtifactPayload(projectRoot, {
+        payloadId: runtimeScopedId(runId, artifact.ref, artifact.hash),
+        runId,
+        sourceRunId: runId,
+        branchSlug: record.branch,
+        taskId: null,
+        logicalRef: artifact.ref,
+        physicalPayloadPath,
+        artifactRole: record.kind,
+        digest: artifact.hash,
+        status: 'active',
+        payload: { logicalRef: artifact.ref, physicalPayloadPath, storage: 'runtime.sqlite', source: 'branch_stage_evidence', content: artifact.content }
+    });
+}
+async function collectBranchStageEvidenceRefs(projectRoot, branch, stage, artifactRefs, required) {
+    if (artifactRefs && artifactRefs.length > 0) {
+        return [...new Set(artifactRefs.map(normalizeBranchStageEvidenceRef).filter((ref) => !isStageCollaborationContractFile(stage, ref.split('/').pop() ?? ref)))];
+    }
+    if (!required) {
+        return [];
+    }
+    const dir = getBranchStageEvidenceDir(projectRoot, branch, stage);
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+    const candidateRefs = files
+        .filter((fileName) => fileName.endsWith('.md') && !isStageCollaborationContractFile(stage, fileName))
+        .sort(compareStageEvidenceFileNames)
+        .map((fileName) => toBranchStageEvidenceRef(branch, stage, fileName));
+    const checkedRefs = await Promise.all(candidateRefs.map(async (ref) => (await isMarkdownStageArtifactCandidate(projectRoot, ref)) ? ref : null));
+    return checkedRefs.filter((ref) => ref !== null);
+}
+async function isMarkdownStageArtifactCandidate(projectRoot, ref) {
+    const content = await readFile(path.join(projectRoot, normalizeBranchStageEvidenceRef(ref)), 'utf8');
+    return /^---\r?\n/.test(content);
+}
+function isSpecStageEvidenceFile(fileName) {
+    return fileName === 'scout.md' || /^spec-review-v\d+\.md$/.test(fileName) || /^spec-manager-v\d+\.md$/.test(fileName);
+}
+function isStageCollaborationContractFile(stage, fileName) {
+    return fileName === `${stage}-collaboration-contract.md` || new RegExp(`^${escapeRegex(stage)}-collaboration-contract-v\\d+\\.md$`).test(fileName);
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function compareStageEvidenceFileNames(left, right) {
+    return stageEvidenceVersion(left) - stageEvidenceVersion(right) || left.localeCompare(right);
+}
+function stageEvidenceVersion(fileNameOrRef) {
+    const fileName = fileNameOrRef.split('/').pop() ?? fileNameOrRef;
+    const match = /-v(\d+)\.md$/.exec(fileName);
+    return match ? Number(match[1]) : 0;
+}
+function runtimeRefForStageArtifact(record) {
+    return { kind: 'artifact', ref: record.ref, hash: record.hash };
+}
+function runtimeRefForStageCollaborationContract(record) {
+    return { kind: 'artifact', ref: record.ref, hash: record.hash };
+}
+async function buildOutputCenteredSpecClosureRequest(projectRoot, profile, workOrder, partition, request, generatedAt) {
+    if (!request) {
+        return null;
+    }
+    const expectedSpecRef = `specs/${partition}/spec.md`;
+    if (request.finalSpecRef && request.finalSpecRef !== expectedSpecRef) {
+        return null;
+    }
+    if (request.sectionCloseDeclaration !== 'present' || request.reviewSignal !== 'present' || request.blockingBeforePlanCount !== 0) {
+        return null;
+    }
+    const content = await readOptionalText(path.join(projectRoot, 'specs', partition, 'spec.md'));
+    if (content === null) {
+        return null;
+    }
+    const specHash = hashDocumentContent(content);
+    const finalSpecRef = { kind: 'document', ref: expectedSpecRef, hash: specHash };
+    const facts = {
+        contract: 'sdd-spec-runtime-close-boundary-facts-v1',
+        scope: profile.scope,
+        finalSpecRef,
+        finalSpecHash: specHash,
+        templateContract: 'sdd-spec-doc-v3',
+        blockingBeforePlanCount: 0,
+        sectionCloseDeclaration: 'present',
+        reviewSignal: 'present',
+        runtimeTruthOwner: 'Runtime Kernel'
+    };
+    const acceptedItems = [{
+            id: 'accepted-spec',
+            kind: 'handoff_proposal',
+            summary: 'Spec-manager submitted final spec.md V3 for runtime ref/hash acceptance.',
+            refs: [finalSpecRef]
+        }];
+    const candidate = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        candidateId: stableId('spec-document-candidate', profile.scope, expectedSpecRef, specHash, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        producedBy: SPEC_STAGE_MANAGER,
+        inputRefs: profile.inputRefs,
+        evidenceRefs: [],
+        acceptedItems,
+        generatedAt
+    };
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        closureRequestId: stableId('spec-closure-request', profile.scope, expectedSpecRef, specHash, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        submittedBy: 'host-adapter',
+        workOrderRef: workOrder ? { kind: 'projection', ref: `spec-work-order:${workOrder.workOrderId}` } : { kind: 'projection', ref: `spec-work-order:${specCollaborationScopeKey(profile.scope)}` },
+        coordinationRef: null,
+        candidateRef: finalSpecRef,
+        reviewRefs: [],
+        capabilityFindingRefs: [],
+        evidenceRefs: [],
+        candidate,
+        reviewResults: [],
+        capabilityFindings: [],
+        unresolvedAmbiguityIds: [],
+        authorityAttempts: [],
+        managerRecommendation: 'close_stage',
+        runtimeCloseBoundaryFacts: facts,
+        generatedAt
+    };
+}
+async function buildOutputCenteredPlanClosureRequest(projectRoot, scope, workOrder, partition, acceptedSpecHandoff, request, generatedAt) {
+    if (!request) {
+        return null;
+    }
+    const expectedPlanRef = `specs/${partition}/plan.md`;
+    if (request.finalPlanRef && request.finalPlanRef !== expectedPlanRef) {
+        return null;
+    }
+    if (request.planCloseQualityEvidence !== 'present' || request.reviewSignal !== 'present' || request.blockingBeforeTasksCount !== 0) {
+        return null;
+    }
+    const acceptedSpecRef = acceptedSpecRefFromHandoff(partition, acceptedSpecHandoff);
+    if (!acceptedSpecRef) {
+        return null;
+    }
+    const content = await readOptionalText(path.join(projectRoot, 'specs', partition, 'plan.md'));
+    if (content === null) {
+        return null;
+    }
+    const planHash = hashDocumentContent(content);
+    const finalPlanRef = { kind: 'document', ref: expectedPlanRef, hash: planHash };
+    const facts = {
+        contract: 'sdd-plan-runtime-close-boundary-facts-v1',
+        scope,
+        acceptedSpecRef,
+        finalPlanRef,
+        finalPlanHash: planHash,
+        templateContract: 'sdd-plan-doc-v3',
+        blockingBeforeTasksCount: 0,
+        planCloseQualityEvidence: 'present',
+        reviewSignal: 'present',
+        runtimeTruthOwner: 'Runtime Kernel'
+    };
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        closureRequestId: stableId('plan-closure-request', scope, expectedPlanRef, planHash, generatedAt),
+        stage: 'plan',
+        scope,
+        submittedBy: 'host-adapter',
+        workOrderRef: workOrder ? { kind: 'projection', ref: `plan-work-order:${workOrder.workOrderId}` } : { kind: 'projection', ref: `plan-work-order:${planCollaborationScopeKey(scope)}` },
+        coordinationRef: null,
+        candidateRef: finalPlanRef,
+        reviewRefs: [],
+        capabilityFindingRefs: [],
+        evidenceRefs: [],
+        candidate: null,
+        reviewResults: [],
+        capabilityFindings: [],
+        unresolvedAmbiguityIds: [],
+        authorityAttempts: [],
+        managerRecommendation: 'close_stage',
+        runtimeCloseBoundaryFacts: facts,
+        generatedAt
+    };
+}
+async function buildOutputCenteredTasksClosureRequest(projectRoot, scope, workOrder, partition, acceptedPlanHandoff, request, generatedAt) {
+    if (!request) {
+        return null;
+    }
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (request.finalTasksRef && request.finalTasksRef !== expectedTasksRef) {
+        return null;
+    }
+    if (request.dependencyGraphStatus !== 'present' || request.validationSignalsStatus !== 'present' || request.reviewSignal !== 'present' || request.blockingBeforeExecuteCount !== 0) {
+        return null;
+    }
+    const acceptedPlanRef = acceptedPlanRefFromHandoff(partition, acceptedPlanHandoff);
+    const acceptedSpecRef = acceptedSpecRefFromPlanHandoff(acceptedPlanHandoff);
+    if (!acceptedPlanRef || !acceptedSpecRef) {
+        return null;
+    }
+    const content = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (content === null) {
+        return null;
+    }
+    const taskModel = parseSddTasksMarkdown(content, { tasksPath: expectedTasksRef });
+    const tasksHash = hashDocumentContent(content);
+    const finalTasksRef = { kind: 'document', ref: expectedTasksRef, hash: tasksHash };
+    const facts = {
+        contract: 'sdd-tasks-runtime-close-boundary-facts-v1',
+        scope,
+        acceptedSpecRef,
+        acceptedPlanRef,
+        finalTasksRef,
+        finalTasksHash: tasksHash,
+        templateContract: 'sdd-tasks-doc-v2',
+        taskUnitCount: taskModel.tasks.length,
+        blockingBeforeExecuteCount: 0,
+        dependencyGraphStatus: 'present',
+        validationSignalsStatus: 'present',
+        reviewSignal: 'present',
+        runtimeTruthOwner: 'Runtime Kernel'
+    };
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        closureRequestId: stableId('tasks-closure-request', scope, expectedTasksRef, tasksHash, generatedAt),
+        stage: 'tasks',
+        scope,
+        submittedBy: 'host-adapter',
+        workOrderRef: workOrder ? { kind: 'projection', ref: `tasks-work-order:${workOrder.workOrderId}` } : { kind: 'projection', ref: `tasks-work-order:${tasksCollaborationScopeKey(scope)}` },
+        coordinationRef: null,
+        candidateRef: finalTasksRef,
+        reviewRefs: [],
+        capabilityFindingRefs: [],
+        evidenceRefs: [],
+        candidate: null,
+        reviewResults: [],
+        capabilityFindings: [],
+        unresolvedAmbiguityIds: [],
+        authorityAttempts: [],
+        managerRecommendation: 'close_stage',
+        runtimeCloseBoundaryFacts: facts,
+        generatedAt
+    };
+}
+function acceptedSpecRefFromHandoff(partition, handoff) {
+    const expectedSpecRef = `specs/${partition}/spec.md`;
+    return handoff?.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedSpecRef)
+        ?? handoff?.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedSpecRef)
+        ?? null;
+}
+function acceptedPlanRefFromHandoff(partition, handoff) {
+    const expectedPlanRef = `specs/${partition}/plan.md`;
+    return handoff?.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedPlanRef)
+        ?? handoff?.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedPlanRef)
+        ?? null;
+}
+function acceptedSpecRefFromPlanHandoff(handoff) {
+    return handoff?.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref.endsWith('/spec.md'))
+        ?? handoff?.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref.endsWith('/spec.md'))
+        ?? null;
+}
+function latestValidatedStageCollaborationContract(records) {
+    return records
+        .filter((record) => record.status === 'validated')
+        .sort((left, right) => stageEvidenceVersion(right.ref) - stageEvidenceVersion(left.ref) || right.registeredAt.localeCompare(left.registeredAt))[0] ?? null;
+}
+function deriveRegisteredSpecManagerCoordination(profile, workOrder, records, generatedAt) {
+    const manager = latestStageArtifact(records, 'manager_closure_request');
+    if (!manager || !workOrder) {
+        return null;
+    }
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        coordinationId: stableId('spec-manager-coordination', profile.scope, manager.ref, manager.hash, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        stageManager: SPEC_STAGE_MANAGER,
+        workOrderRef: { kind: 'projection', ref: `spec-work-order:${workOrder.workOrderId}` },
+        agentTeamRefs: records.filter((record) => record.ref !== manager.ref).map(runtimeRefForStageArtifact),
+        recommendation: manager.recommendation ?? 'blocked',
+        generatedAt
+    };
+}
+function latestStageArtifact(records, kind) {
+    return records
+        .filter((record) => record.kind === kind)
+        .sort((left, right) => stageEvidenceVersion(right.ref) - stageEvidenceVersion(left.ref) || right.registeredAt.localeCompare(left.registeredAt))[0] ?? null;
+}
+async function validateAcceptedSpecArtifact(projectRoot, input) {
+    if (input.adjudication.health !== 'ready_for_plan') {
+        return {
+            acceptedSpecRef: null,
+            specAcceptanceStatus: specArtifactStatusForHealth(input.adjudication.health),
+            specHash: null,
+            specContractHash: null,
+            reasons: [`Spec artifact was not accepted because adjudication health is ${input.adjudication.health}.`]
+        };
+    }
+    const expectedRef = `specs/${input.partition}/spec.md`;
+    const boundaryFacts = input.closureRequest?.runtimeCloseBoundaryFacts ?? null;
+    if (!boundaryFacts || boundaryFacts.contract !== 'sdd-spec-runtime-close-boundary-facts-v1') {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready spec closure must include runtime close boundary facts for the final spec.md V3.', 'Submit finalSpecRef/finalSpecHash, section close declaration, review signal presence, and blockingBeforePlanCount=0 before closure.');
+    }
+    if (!validSpecRuntimeCloseBoundaryFacts(boundaryFacts, input.partition, expectedRef)) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Spec runtime close boundary facts do not match the final spec.md V3 acceptance contract.', 'Refresh spec close facts so finalSpecRef/finalSpecHash, template contract, section close declaration, review signal, and blocking count match runtime requirements.');
+    }
+    const specPath = path.join(projectRoot, 'specs', input.partition, 'spec.md');
+    const content = await readOptionalText(specPath);
+    if (content === null) {
+        return rejectedSpecArtifact('not_accepted_missing_spec', 'missing_refs', `Final spec.md V3 artifact is missing at ${expectedRef}.`, 'Produce specs/<branch>/spec.md before requesting runtime closure.');
+    }
+    if (isManagedStarterSpec(content)) {
+        return rejectedSpecArtifact('not_accepted_starter_spec', 'invalid_proposal', `Canonical spec artifact at ${expectedRef} is still the managed starter spec.`, 'Replace starter spec.md with final semantic spec.md V3 content before closure.');
+    }
+    const specHash = hashDocumentContent(content);
+    const expectedHashes = [boundaryFacts.finalSpecHash, boundaryFacts.finalSpecRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== specHash);
+    if (mismatchedHash) {
+        return rejectedSpecArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Final spec.md V3 hash mismatch for ${expectedRef}: expected ${mismatchedHash}, actual ${specHash}.`, 'Refresh spec close facts with the current spec.md hash before closure.');
+    }
+    const specV3Errors = validateSpecDocumentV3(content);
+    if (specV3Errors.length > 0) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Final spec.md does not satisfy sdd-spec-doc-v3: ${specV3Errors.join('; ')}.`, 'Rewrite specs/<branch>/spec.md as final spec.md V3 with required semantic sections before closure.');
+    }
+    return {
+        acceptedSpecRef: { kind: 'document', ref: expectedRef, hash: specHash },
+        specAcceptanceStatus: 'accepted',
+        specHash,
+        specContractHash: hashSemanticDocument(content),
+        reasons: [`Runtime accepted final spec.md V3 artifact ${expectedRef}.`]
+    };
+}
+function validSpecRuntimeCloseBoundaryFacts(facts, partition, expectedSpecRef) {
+    return facts.contract === 'sdd-spec-runtime-close-boundary-facts-v1'
+        && facts.scope.branch === partition
+        && facts.finalSpecRef.kind === 'document'
+        && facts.finalSpecRef.ref === expectedSpecRef
+        && Boolean(facts.finalSpecRef.hash)
+        && facts.finalSpecHash === facts.finalSpecRef.hash
+        && facts.templateContract === 'sdd-spec-doc-v3'
+        && facts.blockingBeforePlanCount === 0
+        && facts.sectionCloseDeclaration === 'present'
+        && facts.reviewSignal === 'present'
+        && facts.runtimeTruthOwner === 'Runtime Kernel';
+}
+function validPlanRuntimeCloseBoundaryFacts(facts, partition, expectedPlanRef, acceptedSpecRef) {
+    return facts.contract === 'sdd-plan-runtime-close-boundary-facts-v1'
+        && facts.scope.branch === partition
+        && facts.acceptedSpecRef.kind === acceptedSpecRef.kind
+        && facts.acceptedSpecRef.ref === acceptedSpecRef.ref
+        && facts.acceptedSpecRef.hash === acceptedSpecRef.hash
+        && facts.finalPlanRef.kind === 'document'
+        && facts.finalPlanRef.ref === expectedPlanRef
+        && Boolean(facts.finalPlanRef.hash)
+        && facts.finalPlanHash === facts.finalPlanRef.hash
+        && facts.templateContract === 'sdd-plan-doc-v3'
+        && facts.blockingBeforeTasksCount === 0
+        && facts.planCloseQualityEvidence === 'present'
+        && facts.reviewSignal === 'present'
+        && facts.runtimeTruthOwner === 'Runtime Kernel';
+}
+function validTasksRuntimeCloseBoundaryFacts(facts, partition, expectedTasksRef, acceptedSpecRef, acceptedPlanRef, taskUnitCount) {
+    return facts.contract === 'sdd-tasks-runtime-close-boundary-facts-v1'
+        && facts.scope.branch === partition
+        && facts.acceptedSpecRef.kind === acceptedSpecRef.kind
+        && facts.acceptedSpecRef.ref === acceptedSpecRef.ref
+        && facts.acceptedSpecRef.hash === acceptedSpecRef.hash
+        && facts.acceptedPlanRef.kind === acceptedPlanRef.kind
+        && facts.acceptedPlanRef.ref === acceptedPlanRef.ref
+        && facts.acceptedPlanRef.hash === acceptedPlanRef.hash
+        && facts.finalTasksRef.kind === 'document'
+        && facts.finalTasksRef.ref === expectedTasksRef
+        && Boolean(facts.finalTasksRef.hash)
+        && facts.finalTasksHash === facts.finalTasksRef.hash
+        && facts.templateContract === 'sdd-tasks-doc-v2'
+        && facts.taskUnitCount === taskUnitCount
+        && facts.taskUnitCount > 0
+        && facts.blockingBeforeExecuteCount === 0
+        && facts.dependencyGraphStatus === 'present'
+        && facts.validationSignalsStatus === 'present'
+        && facts.reviewSignal === 'present'
+        && facts.runtimeTruthOwner === 'Runtime Kernel';
+}
+function rejectedSpecArtifact(specAcceptanceStatus, reasonCode, explanation, requiredNextAction) {
+    return {
+        acceptedSpecRef: null,
+        specAcceptanceStatus,
+        specHash: null,
+        specContractHash: null,
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute: 'revise-proposal'
+        }
+    };
+}
+async function validateAcceptedPlanArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedPlanRef: null,
+            planAcceptanceStatus: 'not_required_noop',
+            planHash: null,
+            planContractHash: null,
+            reasons: ['Plan artifact was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedPlanArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks plan closure.', 'Resolve lifecycle blockers before requesting plan-stage closure.', 'runtime-blocked');
+    }
+    const upstreamIssue = await validateAcceptedSpecHandoff(projectRoot, input.partition, input.acceptedSpecHandoff);
+    if (upstreamIssue) {
+        return rejectedPlanArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh spec-stage closure and provide a fresh spec -> plan handoff before plan closure.');
+    }
+    const expectedRef = `specs/${input.partition}/plan.md`;
+    const acceptedSpecRef = acceptedSpecRefFromHandoff(input.partition, input.acceptedSpecHandoff);
+    if (!acceptedSpecRef) {
+        return rejectedPlanArtifact('not_accepted_missing_upstream', 'missing_refs', 'Plan closure requires accepted spec ref/hash from runtime handoff.', 'Refresh spec-stage closure and provide a fresh spec -> plan handoff before plan closure.');
+    }
+    const boundaryFacts = input.closureRequest?.runtimeCloseBoundaryFacts;
+    if (!boundaryFacts || boundaryFacts.contract !== 'sdd-plan-runtime-close-boundary-facts-v1') {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Plan close request is missing runtime boundary facts for final plan.md V3.', 'Submit finalPlanRef/finalPlanHash, acceptedSpecRef, plan close quality evidence, review signal, and blockingBeforeTasksCount=0.');
+    }
+    if (!validPlanRuntimeCloseBoundaryFacts(boundaryFacts, input.partition, expectedRef, acceptedSpecRef)) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Plan close boundary facts must reference accepted spec and final ${expectedRef}.`, 'Refresh the output close request from current runtime handoff and specs/<branch>/plan.md.');
+    }
+    const planPath = path.join(projectRoot, 'specs', input.partition, 'plan.md');
+    const content = await readOptionalText(planPath);
+    if (content === null) {
+        return rejectedPlanArtifact('not_accepted_missing_plan', 'missing_refs', `Canonical plan artifact is missing at ${expectedRef}.`, 'Produce specs/<branch>/plan.md before requesting runtime closure.');
+    }
+    if (isManagedStarterSpec(content)) {
+        return rejectedPlanArtifact('not_accepted_starter_plan', 'invalid_proposal', `Canonical plan artifact at ${expectedRef} is still the managed starter document.`, 'Replace starter plan.md with semantic plan content before closure.');
+    }
+    const documentErrors = validatePlanDocumentV3(content, boundaryFacts);
+    if (documentErrors.length > 0) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Canonical plan artifact at ${expectedRef} is not a valid sdd-plan-doc-v3: ${documentErrors.join('; ')}.`, 'Rewrite specs/<branch>/plan.md as plan.md V3 before requesting runtime closure.');
+    }
+    const planHash = hashDocumentContent(content);
+    if (boundaryFacts.finalPlanHash !== planHash || boundaryFacts.finalPlanRef.hash !== planHash) {
+        return rejectedPlanArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Final plan hash mismatch for ${expectedRef}: expected ${boundaryFacts.finalPlanHash}, actual ${planHash}.`, 'Refresh plan close request with the current plan.md hash before closure.');
+    }
+    return {
+        acceptedPlanRef: { kind: 'document', ref: expectedRef, hash: planHash },
+        planAcceptanceStatus: 'accepted',
+        planHash,
+        planContractHash: hashSemanticDocument(content),
+        reasons: [`Runtime accepted reviewed canonical plan artifact ${expectedRef}.`]
+    };
+}
+async function validateAcceptedTasksArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedTasksRef: null,
+            tasksAcceptanceStatus: 'not_required_noop',
+            tasksHash: null,
+            tasksContractHash: null,
+            reasons: ['Tasks artifact was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedTasksArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks tasks closure.', 'Resolve lifecycle blockers before requesting tasks-stage closure.', 'runtime-blocked');
+    }
+    const upstreamIssue = await validateAcceptedPlanHandoff(projectRoot, input.partition, input.acceptedPlanHandoff);
+    if (upstreamIssue) {
+        return rejectedTasksArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh plan-stage closure and provide a fresh plan -> tasks handoff before tasks closure.');
+    }
+    const expectedRef = `specs/${input.partition}/tasks.md`;
+    const acceptedPlanRef = acceptedPlanRefFromHandoff(input.partition, input.acceptedPlanHandoff);
+    const acceptedSpecRef = acceptedSpecRefFromPlanHandoff(input.acceptedPlanHandoff);
+    if (!acceptedPlanRef || !acceptedSpecRef) {
+        return rejectedTasksArtifact('not_accepted_missing_upstream', 'missing_refs', 'Tasks closure requires accepted spec and plan ref/hash from runtime handoff.', 'Refresh plan-stage closure and provide a fresh plan -> tasks handoff before tasks closure.');
+    }
+    const tasksPath = path.join(projectRoot, 'specs', input.partition, 'tasks.md');
+    const content = await readOptionalText(tasksPath);
+    const boundaryFacts = input.closureRequest?.runtimeCloseBoundaryFacts;
+    if (!boundaryFacts || boundaryFacts.contract !== 'sdd-tasks-runtime-close-boundary-facts-v1') {
+        const closeEvidenceErrors = [];
+        if (content !== null) {
+            validateTasksDepthSignals(content, closeEvidenceErrors);
+        }
+        const closeEvidenceExplanation = closeEvidenceErrors.join('\n');
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', closeEvidenceExplanation || 'Tasks close request is missing runtime boundary facts for final tasks.md V2.', 'Submit finalTasksRef/finalTasksHash, acceptedSpecRef, acceptedPlanRef, taskUnitCount, dependencyGraphStatus, validationSignalsStatus, reviewSignal, and blockingBeforeExecuteCount=0.');
+    }
+    if (content === null) {
+        return rejectedTasksArtifact('not_accepted_missing_tasks', 'missing_refs', `Reviewed canonical tasks artifact is missing at ${expectedRef}.`, 'Produce and review specs/<branch>/tasks.md before requesting runtime closure.');
+    }
+    if (isManagedStarterSpec(content)) {
+        return rejectedTasksArtifact('not_accepted_starter_tasks', 'invalid_proposal', `Canonical tasks artifact at ${expectedRef} is still the managed starter document.`, 'Replace starter tasks.md with reviewed executable task contracts before closure.');
+    }
+    const tasksV2Errors = validateTasksDocumentV2(content, expectedRef);
+    if (tasksV2Errors.length > 0) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Final tasks.md does not satisfy sdd-tasks-doc-v2: ${tasksV2Errors.join('; ')}.`, 'Rewrite specs/<branch>/tasks.md as final tasks.md V2 with required execution topology sections before closure.');
+    }
+    const taskModel = parseSddTasksMarkdown(content, { tasksPath: expectedRef });
+    const duplicateIdGap = taskModel.gaps.find((gap) => gap.field === 'id' && /Duplicate task id/i.test(gap.message));
+    if (duplicateIdGap) {
+        return rejectedTasksArtifact('not_accepted_duplicate_task_ids', 'invalid_proposal', duplicateIdGap.message, duplicateIdGap.recommendation);
+    }
+    const blockingTaskGap = taskModel.tasks.length === 0
+        ? { message: `Reviewed tasks artifact ${expectedRef} contains no executable sdd-task blocks.`, recommendation: 'Add at least one reviewed sdd-task block before closure.' }
+        : taskModel.gaps.find((gap) => gap.severity === 'blocking') ?? null;
+    if (blockingTaskGap) {
+        return rejectedTasksArtifact('not_accepted_invalid_task_ids', 'invalid_proposal', blockingTaskGap.message, blockingTaskGap.recommendation);
+    }
+    const tasksHash = hashDocumentContent(content);
+    if (!validTasksRuntimeCloseBoundaryFacts(boundaryFacts, input.partition, expectedRef, acceptedSpecRef, acceptedPlanRef, taskModel.tasks.length)) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Tasks close boundary facts must reference accepted spec, accepted plan, final ${expectedRef}, and parsed task unit count.`, 'Refresh the output close request from current runtime handoff and specs/<branch>/tasks.md.');
+    }
+    if (boundaryFacts.finalTasksHash !== tasksHash || boundaryFacts.finalTasksRef.hash !== tasksHash) {
+        return rejectedTasksArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Final tasks hash mismatch for ${expectedRef}: expected ${boundaryFacts.finalTasksHash}, actual ${tasksHash}.`, 'Refresh tasks close request with the current tasks.md hash before closure.');
+    }
+    const tasksContractHash = hashTasksContract(content);
+    if (!tasksContractHash) {
+        return rejectedTasksArtifact('not_accepted_invalid_task_ids', 'invalid_proposal', `Reviewed tasks artifact ${expectedRef} does not produce a task contract hash.`, 'Refresh tasks.md with reviewed executable task contracts before closure.');
+    }
+    return {
+        acceptedTasksRef: { kind: 'document', ref: expectedRef, hash: tasksHash },
+        tasksAcceptanceStatus: 'accepted',
+        tasksHash,
+        tasksContractHash,
+        reasons: [`Runtime accepted reviewed canonical tasks artifact ${expectedRef}.`]
+    };
+}
+async function validateAcceptedExecuteArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedExecuteRef: null,
+            executeAcceptanceStatus: 'not_required_noop',
+            laneEvidenceRefs: [],
+            reasons: ['Execute evidence was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedExecuteArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute closure.', 'Resolve lifecycle blockers before requesting execute-stage closure.', 'runtime-blocked');
+    }
+    const upstreamIssue = await validateAcceptedExecuteTasksHandoff(projectRoot, input.partition, input.acceptedTasksHandoff);
+    if (upstreamIssue) {
+        return rejectedExecuteArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh tasks-stage closure and provide a fresh tasks -> execute handoff before execute closure.');
+    }
+    return validateExecuteProjectionReadiness(projectRoot, input.partition, input.acceptedTasksHandoff);
+}
+async function validateExecuteProjectionReadiness(projectRoot, partition, acceptedTasksHandoff) {
+    const acceptedTasksRef = acceptedTasksRefFromExecuteHandoff(acceptedTasksHandoff);
+    if (!acceptedTasksRef?.hash) {
+        return rejectedExecuteArtifact('not_accepted_missing_upstream', 'missing_refs', 'Execute close requires a tasks -> execute handoff carrying accepted tasks ref/hash.', 'Refresh tasks-stage closure before requesting execute close.');
+    }
+    const [projectionRecords, dependencyGraphEnvelope] = await Promise.all([
+        listRuntimeProjections(projectRoot, [TASK_UNIT_PROJECTION_TYPE, EXECUTION_LANE_PROJECTION_TYPE]),
+        readTaskDependencyGraphProjection(projectRoot, partition)
+    ]);
+    if (!dependencyGraphEnvelope || dependencyGraphEnvelope.payload.tasksHash !== acceptedTasksRef.hash) {
+        return rejectedExecuteArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute dependency graph must be derived from accepted ${acceptedTasksRef.ref}.`, 'Rebuild execute task projections from the accepted tasks ref/hash before closing execute.');
+    }
+    const taskUnits = projectionRecords
+        .filter((record) => record.projectionType === TASK_UNIT_PROJECTION_TYPE && record.scopeKey.startsWith(`${partition}:`))
+        .map((record) => runtimeProjectionPayload(record.payload))
+        .filter((unit) => Boolean(unit))
+        .filter((unit) => unit.sourceRef.ref === acceptedTasksRef.ref && unit.sourceRef.hash === acceptedTasksRef.hash);
+    if (taskUnits.length === 0) {
+        return rejectedExecuteArtifact('not_accepted_wrong_ref', 'missing_refs', `No TaskUnitProjection records match accepted ${acceptedTasksRef.ref}.`, 'Rebuild execute task projections from the accepted tasks ref/hash before closing execute.');
+    }
+    const executionLanes = projectionRecords
+        .filter((record) => record.projectionType === EXECUTION_LANE_PROJECTION_TYPE && record.scopeKey.startsWith(`${partition}:`))
+        .map((record) => runtimeProjectionPayload(record.payload))
+        .filter((lane) => Boolean(lane));
+    const laneEvidenceRefs = executionLanes.map((lane) => ({ kind: 'projection', ref: `${EXECUTION_LANE_PROJECTION_TYPE}:${executionLaneScopeKey(partition, lane.laneId)}` }));
+    const invalidTaskIds = uniqueStrings([...dependencyGraphEnvelope.payload.invalidTaskIds, ...taskUnits.filter((unit) => unit.dependencyState === 'invalid').map((unit) => unit.taskId)]);
+    if (invalidTaskIds.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Execute task projections contain invalid task units: ${invalidTaskIds.join(', ')}.`, 'Repair accepted tasks.md and rebuild task projections before closing execute.');
+    }
+    const implementationUnits = taskUnits.filter((unit) => unit.unit.agentRouting.board === 'implementation');
+    const validationUnits = taskUnits.filter((unit) => unit.unit.agentRouting.board === 'validation');
+    if (implementationUnits.length === 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_implementation', 'missing_refs', 'Execute close requires at least one implementation-board task unit from accepted tasks.md.', 'Route accepted implementation tasks before closing execute.');
+    }
+    if (validationUnits.length === 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_validation', 'missing_refs', 'Execute close requires at least one validation-board task unit from accepted tasks.md.', 'Route implementation validation and goal validation tasks before closing execute.');
+    }
+    const incompleteImplementation = implementationUnits.filter((unit) => !isImplementationComplete(unit)).map((unit) => unit.taskId);
+    if (incompleteImplementation.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_implementation', 'missing_refs', `Implementation board is not complete for task units: ${incompleteImplementation.join(', ')}.`, 'Run implementation/review/debug lanes until implementation task units are implemented or validated before execute close.');
+    }
+    const openCheckpointIds = taskUnits.filter((unit) => unit.checkpointState === 'open' || unit.checkpointState === 'locked').map((unit) => `${unit.taskId}:checkpoint`);
+    if (openCheckpointIds.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_checkpoint', 'invalid_proposal', `Execute checkpoints are still open: ${openCheckpointIds.join(', ')}.`, 'Satisfy or resolve execute checkpoints before closing execute.');
+    }
+    const incompleteValidation = validationUnits.filter((unit) => !isValidationComplete(unit)).map((unit) => unit.taskId);
+    if (incompleteValidation.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_validation', 'missing_refs', `Validation board is not complete for task units: ${incompleteValidation.join(', ')}.`, 'Run validation and goal-validation lanes until validation task units are validated before execute close.');
+    }
+    const acceptedExecuteRef = {
+        kind: 'projection',
+        ref: `${TASK_DEPENDENCY_GRAPH_PROJECTION_TYPE}:${taskDependencyGraphScopeKey(partition)}`,
+        hash: dependencyGraphEnvelope.payload.tasksHash
+    };
+    return {
+        acceptedExecuteRef,
+        executeAcceptanceStatus: 'accepted',
+        laneEvidenceRefs,
+        reasons: [`Runtime accepted execute task/lane projections for ${acceptedTasksRef.ref}.`]
+    };
+}
+async function validateAcceptedDoArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedImplementationRef: null,
+            implementationAcceptanceStatus: 'not_required_noop',
+            implementationHash: null,
+            changedFileRefs: [],
+            reasons: ['Implementation artifact was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedDoArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute closure.', 'Resolve lifecycle blockers before requesting execute closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready execute implementation closure must be backed by a validated execute StageCollaborationContract.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/execute-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const upstreamIssue = await validateAcceptedTasksExecuteHandoff(projectRoot, input.partition, input.acceptedTasksHandoff);
+    if (upstreamIssue) {
+        return rejectedDoArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh tasks closure and provide a fresh tasks -> execute handoff before execute closure.');
+    }
+    const implementation = latestStageArtifact(input.registeredArtifacts, 'implementation_evidence');
+    if (!implementation) {
+        return rejectedDoArtifact('not_accepted_missing_implementation', 'missing_refs', 'Ready execute implementation closure must be backed by a registered implementer evidence artifact.', 'Ask implementer to write .sdd/runs/<branch>/execute/implementation-vN.md and register it before closure.');
+    }
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready execute implementation closure must be backed by a registered execute-manager closure artifact.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/execute-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedDoArtifact('not_accepted_rejected', 'invalid_proposal', `Execute-manager recommendation ${manager.recommendation ?? 'none'} cannot accept implementation state for execute validation handoff.`, 'Ask execute-manager to submit a close_stage recommendation after review blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'code_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh execute-manager closure artifact so reviewRef/reviewHash point at the registered code review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'code_review');
+    if (!approvedReview) {
+        return rejectedDoArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready execute implementation closure must include a registered code-reviewer artifact referenced by execute-manager.', 'Ask code-reviewer to write .sdd/runs/<branch>/execute/code-review-vN.md and ask execute-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedDoArtifact('not_accepted_missing_review', 'missing_required_review', `Code-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept implementation state.`, 'Resolve review blockers and register an approved code-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== implementation.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== implementation.ref) {
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready execute implementation closure must reference reviewed ${implementation.ref} as the implementation evidence artifact.`, 'Refresh code-reviewer and execute-manager artifacts so targetRef points at the implementation evidence artifact.');
+    }
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== implementation.hash);
+    if (mismatchedHash) {
+        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed implementation evidence hash mismatch for ${implementation.ref}: expected ${mismatchedHash}, actual ${implementation.hash}.`, 'Refresh code-reviewer and execute-manager artifacts with the current implementation evidence hash before closure.');
+    }
+    const changedFileParse = parseImplementationChangedFileRefs(implementation);
+    if (changedFileParse.issue) {
+        return rejectedDoArtifact('not_accepted_boundary_violation', 'invalid_proposal', changedFileParse.issue, 'Refresh implementation evidence with changedFiles entries that include safe refs and current hashes.');
+    }
+    const changedFileRefs = changedFileParse.refs;
+    const boundaryIssue = validateAllowedChangedFileRefs(changedFileRefs, input.allowedChangedFileRefs);
+    if (boundaryIssue) {
+        return rejectedDoArtifact('not_accepted_boundary_violation', 'invalid_proposal', boundaryIssue, 'Restrict execute implementation evidence to the task boundary or update the allowed changed-file refs.');
+    }
+    const changedFileHashIssue = await validateChangedFileHashes(projectRoot, changedFileRefs);
+    if (changedFileHashIssue) {
+        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', changedFileHashIssue, 'Refresh implementation, code-reviewer, and execute-manager artifacts with current changed-file hashes before closure.');
+    }
+    return {
+        acceptedImplementationRef: { kind: 'artifact', ref: implementation.ref, hash: implementation.hash },
+        implementationAcceptanceStatus: 'accepted',
+        implementationHash: implementation.hash,
+        changedFileRefs,
+        reasons: [`Runtime accepted reviewed implementation evidence ${implementation.ref}.`]
+    };
+}
+async function validateAcceptedTestArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedTestEvidenceRef: null,
+            testAcceptanceStatus: 'not_required_noop',
+            testEvidenceHash: null,
+            reasons: ['Test evidence was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedTestArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute validation closure.', 'Resolve lifecycle blockers before requesting execute validation closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute validation closure must be backed by a validated execute StageCollaborationContract.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/validation-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const upstreamIssue = await validateAcceptedDoHandoff(projectRoot, input.partition, input.acceptedDoHandoff);
+    if (upstreamIssue) {
+        return rejectedTestArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh execute implementation closure before execute validation closure.');
+    }
+    const execution = latestStageArtifact(input.registeredArtifacts, 'test_execution');
+    if (!execution) {
+        return rejectedTestArtifact('not_accepted_missing_execution', 'missing_refs', 'Ready execute validation closure must be backed by a registered validation execution artifact.', 'Ask validator to write .sdd/runs/<branch>/execute/test-execution-vN.md and register it before closure.');
+    }
+    const validation = latestStageArtifact(input.registeredArtifacts, 'validation_evidence');
+    if (!validation) {
+        return rejectedTestArtifact('not_accepted_missing_validation', 'missing_refs', 'Ready execute validation closure must be backed by a registered validator evidence artifact.', 'Ask validator to write .sdd/runs/<branch>/execute/validation-vN.md and register it before closure.');
+    }
+    const executionStatus = execution.frontmatter.status;
+    const executionExitCode = execution.frontmatter.exitCode;
+    if (executionStatus !== 'passed' || executionExitCode !== 0) {
+        return rejectedTestArtifact('not_accepted_failed_tests', 'invalid_proposal', `Validation execution ${execution.ref} status ${String(executionStatus)} with exitCode ${String(executionExitCode)} cannot close execute validation.`, 'Rerun failing validation commands and register passing validation execution evidence before closure.');
+    }
+    const validationExecutionRef = executionRefFromValidation(validation);
+    if (validationExecutionRef !== execution.ref) {
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Validation evidence ${validation.ref} must reference execution evidence ${execution.ref}.`, 'Refresh validation evidence so executionRef points at the registered validation execution artifact.');
+    }
+    const validationExecutionHash = validation.frontmatter.executionHash;
+    if (validationExecutionHash !== execution.hash) {
+        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Validation evidence execution hash mismatch for ${execution.ref}: expected ${String(validationExecutionHash)}, actual ${execution.hash}.`, 'Refresh validation evidence with the current validation execution hash before closure.');
+    }
+    if (validation.frontmatter.status !== 'passed') {
+        return rejectedTestArtifact('not_accepted_failed_tests', 'invalid_proposal', `Validation evidence ${validation.ref} status ${String(validation.frontmatter.status)} cannot close execute validation.`, 'Resolve validation failures and register passing validation evidence before closure.');
+    }
+    if (validation.frontmatter.acceptanceMapped !== true) {
+        return rejectedTestArtifact('not_accepted_unmapped_acceptance', 'invalid_proposal', `Validation evidence ${validation.ref} must declare acceptanceMapped: true.`, 'Map validation evidence to accepted task/verify criteria before requesting execute validation closure.');
+    }
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute validation closure must be backed by a registered execute-manager closure artifact.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/validation-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedTestArtifact('not_accepted_rejected', 'invalid_proposal', `Execute-manager recommendation ${manager.recommendation ?? 'none'} cannot accept validation evidence for execute evidence judgment.`, 'Ask execute-manager to submit a close_stage recommendation after validation blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'test_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh execute-manager closure artifact so reviewRef/reviewHash point at the registered validation review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'test_review');
+    if (!approvedReview) {
+        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready execute validation closure must include a registered validation-reviewer artifact referenced by execute-manager.', 'Ask validation-reviewer to write .sdd/runs/<branch>/execute/validation-review-vN.md and ask execute-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', `Validation-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept validation evidence.`, 'Resolve review blockers and register an approved validation-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== validation.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== validation.ref) {
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready execute validation closure must reference reviewed ${validation.ref} as the validation evidence artifact.`, 'Refresh validation-reviewer and execute-manager artifacts so targetRef points at the validation evidence artifact.');
+    }
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== validation.hash);
+    if (mismatchedHash) {
+        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed validation evidence hash mismatch for ${validation.ref}: expected ${mismatchedHash}, actual ${validation.hash}.`, 'Refresh validation-reviewer and execute-manager artifacts with the current validation evidence hash before closure.');
+    }
+    return {
+        acceptedTestEvidenceRef: { kind: 'artifact', ref: validation.ref, hash: validation.hash },
+        testAcceptanceStatus: 'accepted',
+        testEvidenceHash: validation.hash,
+        reasons: [`Runtime accepted reviewed execute validation evidence ${validation.ref}.`]
+    };
+}
+async function validateAcceptedEvidenceJudgmentArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedEvidenceJudgmentRef: null,
+            evidenceJudgmentAcceptanceStatus: 'not_required_noop',
+            evidenceJudgmentHash: null,
+            reasons: ['Evidence judgment was not required by this lifecycle decision.'],
+            truthAlignment: null
+        };
+    }
+    if (input.blocked) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute evidence judgment closure.', 'Resolve lifecycle blockers before requesting execute evidence judgment closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute evidence judgment closure must be backed by a validated execute StageCollaborationContract.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/evidence-judgment-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const upstreamIssue = await validateAcceptedTestHandoff(projectRoot, input.partition, input.acceptedTestHandoff);
+    if (upstreamIssue) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh execute validation closure before execute evidence judgment closure.');
+    }
+    const verification = latestStageArtifact(input.registeredArtifacts, 'evidence_judgment');
+    if (!verification) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_verification', 'missing_refs', 'Ready execute evidence judgment closure must be backed by a registered evidence-judgment artifact.', 'Ask evidence-judgment agent to write .sdd/runs/<branch>/execute/evidence-judgment-vN.md and register it before closure.');
+    }
+    if (verification.frontmatter.status !== 'passed') {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_failed_verification', 'invalid_proposal', `Evidence judgment ${verification.ref} status ${String(verification.frontmatter.status)} cannot close execute evidence judgment.`, 'Resolve evidence judgment failures and register passing evidence judgment evidence before closure.');
+    }
+    if (verification.frontmatter.coverageComplete !== true) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_incomplete_coverage', 'invalid_proposal', `Evidence judgment ${verification.ref} must declare coverageComplete: true.`, 'Complete acceptance coverage before requesting execute evidence judgment closure.');
+    }
+    const durableGapCount = verification.frontmatter.durableGapCount;
+    const openGapCount = verification.frontmatter.openGapCount;
+    if ((typeof durableGapCount === 'number' && durableGapCount > 0) || (typeof openGapCount === 'number' && openGapCount > 0)) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_open_gap', 'invalid_proposal', `Evidence judgment ${verification.ref} still declares open durable gaps.`, 'Resolve durable gaps before requesting execute evidence judgment closure.');
+    }
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute evidence judgment closure must be backed by a registered execute-manager closure artifact.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/evidence-judgment-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_rejected', 'invalid_proposal', `Execute-manager recommendation ${manager.recommendation ?? 'none'} cannot accept evidence judgment for truthAlignment and ship readiness.`, 'Ask execute-manager to submit a close_stage recommendation after evidence judgment blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'evidence_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh execute-manager closure artifact so reviewRef/reviewHash point at the registered evidence review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'evidence_review');
+    if (!approvedReview) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready execute evidence judgment closure must include a registered evidence-reviewer artifact referenced by execute-manager.', 'Ask evidence-reviewer to write .sdd/runs/<branch>/execute/evidence-review-vN.md and ask execute-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_review', 'missing_required_review', `Evidence-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept evidence judgment.`, 'Resolve review blockers and register an approved evidence-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== verification.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== verification.ref) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready execute evidence judgment closure must reference reviewed ${verification.ref} as the evidence judgment artifact.`, 'Refresh evidence-reviewer and execute-manager artifacts so targetRef points at the evidence judgment artifact.');
+    }
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== verification.hash);
+    if (mismatchedHash) {
+        return rejectedEvidenceJudgmentArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed evidence judgment hash mismatch for ${verification.ref}: expected ${mismatchedHash}, actual ${verification.hash}.`, 'Refresh evidence-reviewer and execute-manager artifacts with the current evidence judgment hash before closure.');
+    }
+    return {
+        acceptedEvidenceJudgmentRef: { kind: 'artifact', ref: verification.ref, hash: verification.hash },
+        evidenceJudgmentAcceptanceStatus: 'accepted',
+        evidenceJudgmentHash: verification.hash,
+        reasons: [`Runtime accepted reviewed evidence judgment evidence ${verification.ref}.`],
+        truthAlignment: parseEvidenceJudgmentTruthAlignment(verification)
+    };
+}
+async function validateAcceptedShipReadinessArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedShipReadinessRef: null,
+            shipReadinessStatus: 'not_required_noop',
+            shipReadinessHash: null,
+            releaseDocumentRef: null,
+            reasons: ['Ship was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedShipReadinessArtifact('not_accepted_blocked', 'blocked_lifecycle', input.blockedReason ?? 'Lifecycle risk decision blocks ship closure.', 'Resolve ship blockers before requesting ship-stage closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedShipReadinessArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready ship closure must be backed by a validated ship StageCollaborationContract.', 'Ask ship-manager to write .sdd/runs/<branch>/ship/ship-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const truthAlignmentIssue = await validateAcceptedTruthAlignment(projectRoot, input.partition, input.truthAlignment);
+    if (truthAlignmentIssue) {
+        return rejectedShipReadinessArtifact('not_accepted_missing_upstream', 'missing_refs', truthAlignmentIssue, 'Refresh execute evidence judgment closure so runtime records an aligned truthAlignment projection before ship closure.');
+    }
+    const authorityIssue = validateNoRuntimeAuthorityAttempts(input.registeredArtifacts);
+    if (authorityIssue) {
+        return rejectedShipReadinessArtifact('not_accepted_authority_violation', 'authority_violation', authorityIssue, 'Remove workflow-authority attempts from ship evidence before requesting runtime closure.');
+    }
+    const readiness = latestStageArtifact(input.registeredArtifacts, 'ship_readiness');
+    if (!readiness) {
+        return rejectedShipReadinessArtifact('not_accepted_missing_readiness', 'missing_refs', 'Ready ship closure must be backed by a registered ship-validator readiness artifact.', 'Ask ship-validator to write .sdd/runs/<branch>/ship/ship-readiness-vN.md and register it before closure.');
+    }
+    if (readiness.frontmatter.status !== 'ready') {
+        return rejectedShipReadinessArtifact('not_accepted_rejected', 'invalid_proposal', `Ship readiness ${readiness.ref} status ${String(readiness.frontmatter.status)} cannot mark the project ship-ready.`, 'Resolve ship readiness failures and register ready ship evidence before closure.');
+    }
+    const openBlockerCount = readinessBlockerCount(readiness);
+    if (openBlockerCount > 0) {
+        return rejectedShipReadinessArtifact('not_accepted_open_blocker', 'invalid_proposal', `Ship readiness ${readiness.ref} still declares ${openBlockerCount} open blockers.`, 'Resolve doctor, capability, repair, gap, and migration blockers before requesting ship closure.');
+    }
+    const releaseDocument = await parseShipReleaseDocumentRef(projectRoot, input.partition, readiness);
+    if (releaseDocument.issue) {
+        return rejectedShipReadinessArtifact('not_accepted_release_drift', 'invalid_proposal', releaseDocument.issue, 'Refresh release documentation and ship readiness releaseRef/releaseHash before requesting ship closure.');
+    }
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedShipReadinessArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready ship closure must be backed by a registered ship-manager closure artifact.', 'Ask ship-manager to write .sdd/runs/<branch>/ship/ship-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedShipReadinessArtifact('not_accepted_rejected', 'invalid_proposal', `Ship-manager recommendation ${manager.recommendation ?? 'none'} cannot mark the project ship-ready.`, 'Ask ship-manager to submit a close_stage recommendation after ship blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'release_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedShipReadinessArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Ship-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh ship-manager closure artifact so reviewRef/reviewHash point at the registered release review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'release_review');
+    if (!approvedReview) {
+        return rejectedShipReadinessArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready ship closure must include a registered release-reviewer artifact referenced by ship-manager.', 'Ask release-reviewer to write .sdd/runs/<branch>/ship/release-review-vN.md and ask ship-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedShipReadinessArtifact('not_accepted_missing_review', 'missing_required_review', `Release-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot mark the project ship-ready.`, 'Resolve release review blockers and register an approved release-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== readiness.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== readiness.ref) {
+        return rejectedShipReadinessArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready ship closure must reference reviewed ${readiness.ref} as the ship readiness artifact.`, 'Refresh release-reviewer and ship-manager artifacts so targetRef points at the ship readiness artifact.');
+    }
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== readiness.hash);
+    if (mismatchedHash) {
+        return rejectedShipReadinessArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed ship readiness hash mismatch for ${readiness.ref}: expected ${mismatchedHash}, actual ${readiness.hash}.`, 'Refresh release-reviewer and ship-manager artifacts with the current ship readiness hash before closure.');
+    }
+    return {
+        acceptedShipReadinessRef: { kind: 'artifact', ref: readiness.ref, hash: readiness.hash },
+        shipReadinessStatus: 'accepted',
+        shipReadinessHash: readiness.hash,
+        releaseDocumentRef: releaseDocument.ref,
+        reasons: [`Runtime accepted reviewed ship readiness evidence ${readiness.ref}.`]
+    };
+}
+async function validateAcceptedPlanHandoff(projectRoot, partition, handoff) {
+    const expectedSpecRef = `specs/${partition}/spec.md`;
+    const expectedPlanRef = `specs/${partition}/plan.md`;
+    if (!handoff) {
+        return 'Tasks closure requires a recorded plan -> tasks handoff.';
+    }
+    if (handoff.fromStage !== 'plan' || handoff.toStage !== 'tasks' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Tasks closure requires a non-blocking plan -> tasks handoff.';
+    }
+    const acceptedSpecRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedSpecRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedSpecRef);
+    if (!acceptedSpecRef?.hash) {
+        return `Plan -> tasks handoff must carry accepted ${expectedSpecRef} with a content hash.`;
+    }
+    const specContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'spec.md'));
+    if (specContent === null) {
+        return `Accepted upstream spec artifact is missing at ${expectedSpecRef}.`;
+    }
+    const currentSpecHash = hashDocumentContent(specContent);
+    if (acceptedSpecRef.hash !== currentSpecHash) {
+        return `Accepted upstream spec hash is stale for ${expectedSpecRef}: expected ${acceptedSpecRef.hash}, actual ${currentSpecHash}.`;
+    }
+    const acceptedPlanRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedPlanRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedPlanRef);
+    if (!acceptedPlanRef?.hash) {
+        return `Plan -> tasks handoff must carry accepted ${expectedPlanRef} with a content hash.`;
+    }
+    const planContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'plan.md'));
+    if (planContent === null) {
+        return `Accepted upstream plan artifact is missing at ${expectedPlanRef}.`;
+    }
+    const currentPlanHash = hashDocumentContent(planContent);
+    if (acceptedPlanRef.hash !== currentPlanHash) {
+        return `Accepted upstream plan hash is stale for ${expectedPlanRef}: expected ${acceptedPlanRef.hash}, actual ${currentPlanHash}.`;
+    }
+    return null;
+}
+async function validateAcceptedExecuteTasksHandoff(projectRoot, partition, handoff) {
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (!handoff) {
+        return 'Execute closure requires a recorded tasks -> execute handoff.';
+    }
+    if (handoff.fromStage !== 'tasks' || handoff.toStage !== 'execute' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Execute closure requires a non-blocking tasks -> execute handoff.';
+    }
+    const acceptedTasksRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedTasksRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedTasksRef);
+    if (!acceptedTasksRef?.hash) {
+        return `Tasks -> execute handoff must carry accepted ${expectedTasksRef} with a content hash.`;
+    }
+    const tasksContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (tasksContent === null) {
+        return `Accepted upstream tasks artifact is missing at ${expectedTasksRef}.`;
+    }
+    const currentTasksHash = hashDocumentContent(tasksContent);
+    if (acceptedTasksRef.hash !== currentTasksHash) {
+        return `Accepted upstream tasks hash is stale for ${expectedTasksRef}: expected ${acceptedTasksRef.hash}, actual ${currentTasksHash}.`;
+    }
+    return null;
+}
+function acceptedTasksRefFromExecuteHandoff(handoff) {
+    if (!handoff) {
+        return null;
+    }
+    return handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref.endsWith('/tasks.md'))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref.endsWith('/tasks.md'))
+        ?? null;
+}
+function isImplementationComplete(unit) {
+    return unit.executionState === 'implemented' || unit.executionState === 'validated' || unit.evidenceState === 'accepted';
+}
+function isValidationComplete(unit) {
+    return unit.executionState === 'validated' || unit.evidenceState === 'accepted';
+}
+async function validateAcceptedTasksHandoff(projectRoot, partition, handoff) {
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (!handoff) {
+        return 'Verification-design closure requires a recorded plan -> tasks handoff.';
+    }
+    if (handoff.fromStage !== 'plan' || handoff.toStage !== 'tasks' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Verification-design closure requires a non-blocking plan -> tasks handoff.';
+    }
+    const acceptedTasksRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedTasksRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedTasksRef);
+    if (!acceptedTasksRef?.hash) {
+        return `Plan -> tasks handoff must carry accepted ${expectedTasksRef} with a content hash.`;
+    }
+    const tasksContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (tasksContent === null) {
+        return `Accepted upstream tasks artifact is missing at ${expectedTasksRef}.`;
+    }
+    const currentTasksHash = hashDocumentContent(tasksContent);
+    if (acceptedTasksRef.hash !== currentTasksHash) {
+        return `Accepted upstream tasks hash is stale for ${expectedTasksRef}: expected ${acceptedTasksRef.hash}, actual ${currentTasksHash}.`;
+    }
+    return null;
+}
+async function validateAcceptedTasksExecuteHandoff(projectRoot, partition, handoff) {
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (!handoff) {
+        return 'Execute closure requires a recorded tasks -> execute handoff.';
+    }
+    if (handoff.fromStage !== 'tasks' || handoff.toStage !== 'execute' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Execute closure requires a non-blocking tasks -> execute handoff.';
+    }
+    const acceptedTasksRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedTasksRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedTasksRef);
+    if (!acceptedTasksRef?.hash) {
+        return `Tasks -> execute handoff must carry accepted ${expectedTasksRef} with a content hash.`;
+    }
+    const tasksContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (tasksContent === null) {
+        return `Accepted upstream tasks artifact is missing at ${expectedTasksRef}.`;
+    }
+    const currentTasksHash = hashDocumentContent(tasksContent);
+    if (acceptedTasksRef.hash !== currentTasksHash) {
+        return `Accepted upstream tasks hash is stale for ${expectedTasksRef}: expected ${acceptedTasksRef.hash}, actual ${currentTasksHash}.`;
+    }
+    return null;
+}
+async function validateAcceptedDoHandoff(projectRoot, partition, handoff) {
+    if (!handoff) {
+        return 'Validation lane closure requires a recorded execute -> ship handoff.';
+    }
+    if (handoff.fromStage !== 'execute' || handoff.toStage !== 'ship' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Validation lane closure requires a non-blocking execute -> ship handoff.';
+    }
+    const acceptedImplementationRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/execute/implementation-`))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/execute/implementation-`));
+    if (!acceptedImplementationRef?.hash) {
+        return `Execute -> ship handoff must carry accepted .sdd/runs/${partition}/execute/implementation-vN.md with a content hash.`;
+    }
+    return validateHandoffInputHashes(projectRoot, handoff.requiredInputRefs);
+}
+async function validateAcceptedTestHandoff(projectRoot, partition, handoff) {
+    if (!handoff) {
+        return 'Evidence-judgment lane closure requires a recorded execute -> ship handoff.';
+    }
+    if (handoff.fromStage !== 'execute' || handoff.toStage !== 'ship' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Evidence-judgment lane closure requires a non-blocking execute -> ship handoff.';
+    }
+    const acceptedTestRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/execute/validation-`))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/execute/validation-`));
+    if (!acceptedTestRef?.hash) {
+        return `Execute -> ship handoff must carry accepted .sdd/runs/${partition}/execute/validation-vN.md with a content hash.`;
+    }
+    return validateHandoffInputHashes(projectRoot, handoff.requiredInputRefs);
+}
+async function validateAcceptedSpecHandoff(projectRoot, partition, handoff) {
+    const expectedSpecRef = `specs/${partition}/spec.md`;
+    if (!handoff) {
+        return 'Plan closure requires a recorded spec -> plan handoff.';
+    }
+    if (handoff.fromStage !== 'spec' || handoff.toStage !== 'plan' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Plan closure requires a non-blocking spec -> plan handoff.';
+    }
+    const acceptedSpecRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedSpecRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedSpecRef);
+    if (!acceptedSpecRef?.hash) {
+        return `Spec -> plan handoff must carry accepted ${expectedSpecRef} with a content hash.`;
+    }
+    const specContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'spec.md'));
+    if (specContent === null) {
+        return `Accepted upstream spec artifact is missing at ${expectedSpecRef}.`;
+    }
+    const currentSpecHash = hashDocumentContent(specContent);
+    if (acceptedSpecRef.hash !== currentSpecHash) {
+        return `Accepted upstream spec hash is stale for ${expectedSpecRef}: expected ${acceptedSpecRef.hash}, actual ${currentSpecHash}.`;
+    }
+    return null;
+}
+function rejectedPlanArtifact(planAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedPlanRef: null,
+        planAcceptanceStatus,
+        planHash: null,
+        planContractHash: null,
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function rejectedTasksArtifact(tasksAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedTasksRef: null,
+        tasksAcceptanceStatus,
+        tasksHash: null,
+        tasksContractHash: null,
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function rejectedExecuteArtifact(executeAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedExecuteRef: null,
+        executeAcceptanceStatus,
+        laneEvidenceRefs: [],
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function rejectedDoArtifact(implementationAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedImplementationRef: null,
+        implementationAcceptanceStatus,
+        implementationHash: null,
+        changedFileRefs: [],
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function rejectedTestArtifact(testAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedTestEvidenceRef: null,
+        testAcceptanceStatus,
+        testEvidenceHash: null,
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function rejectedEvidenceJudgmentArtifact(evidenceJudgmentAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedEvidenceJudgmentRef: null,
+        evidenceJudgmentAcceptanceStatus,
+        evidenceJudgmentHash: null,
+        reasons: [explanation],
+        truthAlignment: null,
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function parseEvidenceJudgmentTruthAlignment(verification) {
+    const status = enumFrontmatter(verification.frontmatter, 'truthAlignmentStatus', TRUTH_ALIGNMENT_STATUSES);
+    const semanticImpact = enumFrontmatter(verification.frontmatter, 'semanticImpact', TRUTH_ALIGNMENT_SEMANTIC_IMPACTS);
+    const ownerStage = enumFrontmatter(verification.frontmatter, 'ownerStage', TRUTH_ALIGNMENT_OWNER_STAGES);
+    const invalidatesStages = stageListFrontmatter(verification.frontmatter, 'invalidatesStages');
+    const staleRefs = runtimeRefListFrontmatter(verification.frontmatter, 'staleRefs');
+    const reasons = stringListFrontmatter(verification.frontmatter, 'truthAlignmentReasons');
+    return {
+        status,
+        ownerStage,
+        semanticImpact,
+        staleRefs,
+        invalidatesStages,
+        reasons
+    };
+}
+function enumFrontmatter(frontmatter, key, allowed) {
+    const value = frontmatter[key];
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    if (typeof value !== 'string' || !allowed.includes(value)) {
+        return null;
+    }
+    return value;
+}
+function stringListFrontmatter(frontmatter, key) {
+    const value = frontmatter[key];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === 'string' && item.length > 0);
+}
+function stageListFrontmatter(frontmatter, key) {
+    const values = stringListFrontmatter(frontmatter, key);
+    if (values.length === 0) {
+        return null;
+    }
+    const allowed = new Set(['spec', 'plan', 'tasks', 'execute', 'ship']);
+    return values.filter((value) => allowed.has(value));
+}
+function runtimeRefListFrontmatter(frontmatter, key) {
+    const value = frontmatter[key];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const refs = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const entry = item;
+        if (typeof entry.ref !== 'string' || entry.ref.length === 0) {
+            continue;
+        }
+        const kind = typeof entry.kind === 'string' ? entry.kind : entry.ref.startsWith('.sdd/runs/') ? 'artifact' : entry.ref.startsWith('specs/') ? 'document' : 'external';
+        refs.push({ kind, ref: entry.ref, hash: typeof entry.hash === 'string' && entry.hash.length > 0 ? entry.hash : undefined });
+    }
+    return refs;
+}
+function rejectedShipReadinessArtifact(shipReadinessStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedShipReadinessRef: null,
+        shipReadinessStatus,
+        shipReadinessHash: null,
+        releaseDocumentRef: null,
+        reasons: [explanation],
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+async function parseShipReleaseDocumentRef(projectRoot, partition, readiness) {
+    const rawRef = readiness.frontmatter.releaseRef;
+    const hash = readiness.frontmatter.releaseHash;
+    if (rawRef === undefined || rawRef === null || rawRef === '') {
+        return { ref: null, issue: null };
+    }
+    if (typeof rawRef !== 'string' || typeof hash !== 'string' || hash.length === 0) {
+        return { ref: null, issue: `Ship readiness ${readiness.ref} releaseRef requires a non-empty releaseHash.` };
+    }
+    const normalizedRef = normalizePortablePath(rawRef);
+    if (!normalizedRef || normalizedRef === '.' || normalizedRef === '..' || normalizedRef.includes('..') || path.isAbsolute(rawRef) || !normalizedRef.startsWith(`specs/${partition}/`)) {
+        return { ref: null, issue: `Ship readiness ${readiness.ref} release document ref is unsafe or outside the branch docs: ${rawRef}` };
+    }
+    const filePath = path.resolve(projectRoot, normalizedRef);
+    const projectPath = path.resolve(projectRoot);
+    if (!filePath.startsWith(`${projectPath}${path.sep}`)) {
+        return { ref: null, issue: `Ship readiness ${readiness.ref} release document ref escapes project root: ${rawRef}` };
+    }
+    const content = await readOptionalText(filePath);
+    if (content === null) {
+        return { ref: null, issue: `Release document is missing at ${normalizedRef}.` };
+    }
+    const currentHash = hashDocumentContent(content);
+    if (hash !== currentHash) {
+        return { ref: null, issue: `Release document hash is stale for ${normalizedRef}: expected ${hash}, actual ${currentHash}.` };
+    }
+    return { ref: { kind: 'document', ref: normalizedRef, hash }, issue: null };
+}
+async function validateAcceptedTruthAlignment(projectRoot, partition, truthAlignment) {
+    if (!truthAlignment) {
+        return 'Ship closure requires a recorded aligned truthAlignment projection from execute.';
+    }
+    if (truthAlignment.contract !== TRUTH_ALIGNMENT_CONTRACT || truthAlignment.sourceStage !== 'execute') {
+        return 'Ship closure requires a valid execute truthAlignment projection.';
+    }
+    if (truthAlignment.status !== 'aligned') {
+        const reasons = truthAlignment.reasons.length > 0 ? `: ${truthAlignment.reasons.join('; ')}` : '';
+        return `Ship closure requires aligned truthAlignment; current status is ${truthAlignment.status}${reasons}.`;
+    }
+    if (truthAlignment.semanticImpact === 'material') {
+        return 'Ship closure requires material truth drift to be reconciled before ship.';
+    }
+    if (truthAlignment.staleRefs.length > 0) {
+        return `Ship closure requires fresh truthAlignment refs; stale refs: ${truthAlignment.staleRefs.map((ref) => ref.ref).join(', ')}.`;
+    }
+    if (truthAlignment.invalidatesStages.includes('ship')) {
+        return 'Ship closure requires truthAlignment that does not invalidate ship.';
+    }
+    const acceptedEvidenceJudgmentRef = truthAlignment.acceptedRealityRefs.find((ref) => ref.kind === 'artifact' && ref.ref.startsWith(`.sdd/runs/${partition}/execute/evidence-judgment-`));
+    if (!acceptedEvidenceJudgmentRef?.hash) {
+        return `TruthAlignment must carry accepted .sdd/runs/${partition}/execute/evidence-judgment-vN.md with a content hash.`;
+    }
+    return validateTruthAlignmentRefHashes(projectRoot, [...truthAlignment.declaredTruthRefs, ...truthAlignment.acceptedRealityRefs]);
+}
+async function validateTruthAlignmentRefHashes(projectRoot, refs) {
+    for (const ref of refs) {
+        if (!ref.hash || ref.kind === 'projection' || ref.kind === 'run') {
+            continue;
+        }
+        const normalized = normalizePortablePath(ref.ref);
+        if (!normalized || normalized === '.' || normalized === '..' || normalized.includes('..') || path.isAbsolute(ref.ref)) {
+            return `TruthAlignment accepted reality ref is unsafe: ${ref.ref}`;
+        }
+        const filePath = path.resolve(projectRoot, normalized);
+        const projectPath = path.resolve(projectRoot);
+        if (!filePath.startsWith(`${projectPath}${path.sep}`)) {
+            return `TruthAlignment accepted reality ref escapes project root: ${ref.ref}`;
+        }
+        const content = await readOptionalText(filePath);
+        if (content === null) {
+            return `TruthAlignment accepted reality ref is missing at ${ref.ref}.`;
+        }
+        const currentHash = hashDocumentContent(content);
+        if (ref.hash !== currentHash) {
+            return `TruthAlignment accepted reality ref hash is stale for ${ref.ref}: expected ${ref.hash}, actual ${currentHash}.`;
+        }
+    }
+    return null;
+}
+function validateNoRuntimeAuthorityAttempts(records) {
+    const forbidden = new Set(['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved']);
+    for (const record of records) {
+        const value = record.frontmatter.authorityAttempts;
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        const attempts = value.filter((attempt) => typeof attempt === 'string' && forbidden.has(attempt));
+        if (attempts.length > 0) {
+            return `Ship artifact ${record.ref} attempted workflow authority: ${attempts.join(', ')}.`;
+        }
+    }
+    return null;
+}
+function shipBlockerCount(decision) {
+    return decision.requiredEvidence.filter((evidence) => evidence.requiredBefore === 'ship' && evidence.refs.length === 0).length;
+}
+function readinessBlockerCount(readiness) {
+    return numericFrontmatter(readiness.frontmatter, 'doctorBlockerCount')
+        + numericFrontmatter(readiness.frontmatter, 'capabilityBlockerCount')
+        + numericFrontmatter(readiness.frontmatter, 'repairBlockerCount')
+        + numericFrontmatter(readiness.frontmatter, 'gapBlockerCount')
+        + numericFrontmatter(readiness.frontmatter, 'migrationBlockerCount')
+        + numericFrontmatter(readiness.frontmatter, 'openBlockerCount');
+}
+function numericFrontmatter(frontmatter, key) {
+    const value = frontmatter[key];
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : 0;
+}
+function executionRefFromValidation(validation) {
+    const value = validation.frontmatter.executionRef;
+    if (typeof value !== 'string' || value.length === 0) {
+        return null;
+    }
+    try {
+        return normalizeBranchStageEvidenceRef(value);
+    }
+    catch {
+        return null;
+    }
+}
+async function validateHandoffInputHashes(projectRoot, inputRefs) {
+    for (const ref of inputRefs) {
+        if (!ref.hash) {
+            continue;
+        }
+        const normalized = normalizePortablePath(ref.ref);
+        if (!normalized || normalized === '.' || normalized === '..' || normalized.includes('..') || path.isAbsolute(ref.ref)) {
+            return `Handoff input ref is unsafe: ${ref.ref}`;
+        }
+        const filePath = path.resolve(projectRoot, normalized);
+        const projectPath = path.resolve(projectRoot);
+        if (!filePath.startsWith(`${projectPath}${path.sep}`)) {
+            return `Handoff input ref escapes project root: ${ref.ref}`;
+        }
+        const content = await readOptionalText(filePath);
+        if (content === null) {
+            return `Accepted do handoff input is missing at ${ref.ref}.`;
+        }
+        const currentHash = hashDocumentContent(content);
+        if (ref.hash !== currentHash) {
+            return `Accepted do handoff input hash is stale for ${ref.ref}: expected ${ref.hash}, actual ${currentHash}.`;
+        }
+    }
+    return null;
+}
+function findStageReviewForManager(records, manager, reviewKind) {
+    if (manager.reviewRef) {
+        return records.find((record) => record.kind === reviewKind && record.ref === manager.reviewRef?.ref && record.hash === manager.reviewHash) ?? null;
+    }
+    return latestStageArtifact(records, reviewKind);
+}
+function parseImplementationChangedFileRefs(implementation) {
+    const value = implementation.frontmatter.changedFiles;
+    if (!Array.isArray(value) || value.length === 0) {
+        return { refs: [], issue: `Implementation evidence ${implementation.ref} must declare non-empty changedFiles frontmatter.` };
+    }
+    const refs = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            return { refs: [], issue: `Implementation evidence ${implementation.ref} has an invalid changedFiles entry.` };
+        }
+        const entry = item;
+        const rawRef = entry.ref;
+        const hash = entry.hash;
+        if (typeof rawRef !== 'string' || rawRef.length === 0 || typeof hash !== 'string' || hash.length === 0) {
+            return { refs: [], issue: `Implementation evidence ${implementation.ref} changedFiles entries must include ref and hash.` };
+        }
+        const normalizedRef = normalizeChangedFileRef(rawRef);
+        if (!normalizedRef) {
+            return { refs: [], issue: `Implementation evidence ${implementation.ref} changed file ref is unsafe: ${rawRef}` };
+        }
+        refs.push({ kind: 'evidence', ref: normalizedRef, hash });
+    }
+    return { refs, issue: null };
+}
+function normalizeChangedFileRef(value) {
+    const normalized = normalizePortablePath(value);
+    if (!normalized || normalized === '.' || normalized === '..' || normalized.includes('..') || path.isAbsolute(value)) {
+        return null;
+    }
+    if (normalized.startsWith('.sdd/runs/') || normalized.startsWith('runs/') || isCanonicalSddDocumentRef(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+function validateAllowedChangedFileRefs(changedFileRefs, allowedChangedFileRefs) {
+    if (!allowedChangedFileRefs || allowedChangedFileRefs.length === 0) {
+        return null;
+    }
+    const allowedExact = new Set();
+    const allowedPatterns = [];
+    for (const value of allowedChangedFileRefs) {
+        const normalized = value.includes('*') ? normalizeChangedFilePattern(value) : normalizeChangedFileRef(value);
+        if (!normalized) {
+            return `Allowed changed-file ref is unsafe: ${value}`;
+        }
+        if (normalized.includes('*')) {
+            allowedPatterns.push(changedFilePatternRegex(normalized));
+        }
+        else {
+            allowedExact.add(normalized);
+        }
+    }
+    const outsideBoundary = changedFileRefs.find((ref) => !allowedExact.has(ref.ref) && !allowedPatterns.some((pattern) => pattern.test(ref.ref)));
+    return outsideBoundary ? `Changed file ${outsideBoundary.ref} is outside the allowed execute task boundary.` : null;
+}
+function normalizeChangedFilePattern(value) {
+    const normalized = normalizePortablePath(value);
+    if (!normalized || normalized === '.' || normalized === '..' || normalized.includes('..') || path.isAbsolute(value)) {
+        return null;
+    }
+    if (normalized.startsWith('.sdd/runs/') || normalized.startsWith('runs/') || isCanonicalSddDocumentRef(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+function isCanonicalSddDocumentRef(normalizedRef) {
+    return /^specs\/[^/]+\/(spec|plan|tasks|verify)\.md$/.test(normalizedRef);
+}
+function changedFilePatternRegex(pattern) {
+    return new RegExp(`^${escapeRegex(pattern).replace(/\\\*/g, '[^/]*')}$`);
+}
+async function validateChangedFileHashes(projectRoot, changedFileRefs) {
+    for (const ref of changedFileRefs) {
+        const filePath = path.resolve(projectRoot, ref.ref);
+        const projectPath = path.resolve(projectRoot);
+        if (!filePath.startsWith(`${projectPath}${path.sep}`)) {
+            return `Changed file ref escapes project root: ${ref.ref}`;
+        }
+        const content = await readOptionalText(filePath);
+        if (content === null) {
+            return `Changed file ${ref.ref} is missing from the workspace.`;
+        }
+        const currentHash = hashDocumentContent(content);
+        if (ref.hash !== currentHash) {
+            return `Changed file hash is stale for ${ref.ref}: expected ${ref.hash}, actual ${currentHash}.`;
+        }
+    }
+    return null;
+}
+function buildPlanClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_tasks'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-plan', scope, runId, input.generatedAt),
+        scope,
+        stage: 'plan',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Plan adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildPlanWorkflowHandoff(scope, decision, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: stableId('plan-tasks-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'plan',
+        toStage: 'tasks',
+        fromAgent: PLAN_STAGE_MANAGER,
+        toAgent: 'tasks-stage-runtime',
+        status: decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' ? 'blocked' : 'proposed',
+        outputRefs: input.outputRefs,
+        requiredInputRefs: input.requiredInputRefs,
+        riskDecisionRef: input.riskDecisionRef,
+        evidenceRefs: input.evidenceRefs,
+        openQuestions: [],
+        blockingGaps: [],
+        createdAt: input.generatedAt
+    };
+}
+function buildTasksClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_execute'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-tasks', scope, runId, input.generatedAt),
+        scope,
+        stage: 'tasks',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Tasks adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildTasksWorkflowHandoff(scope, decision, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: stableId('tasks-execute-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'tasks',
+        toStage: 'execute',
+        fromAgent: TASKS_STAGE_MANAGER,
+        toAgent: 'execute-stage-runtime',
+        status: decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' ? 'blocked' : 'proposed',
+        outputRefs: input.outputRefs,
+        requiredInputRefs: input.requiredInputRefs,
+        riskDecisionRef: input.riskDecisionRef,
+        evidenceRefs: input.evidenceRefs,
+        openQuestions: [],
+        blockingGaps: [],
+        createdAt: input.generatedAt
+    };
+}
+function buildExecuteClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_ship'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-execute', scope, runId, input.generatedAt),
+        scope,
+        stage: 'execute',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Execute adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildExecuteWorkflowHandoff(scope, decision, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: stableId('execute-ship-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'execute',
+        toStage: 'ship',
+        fromAgent: 'execute-manager',
+        toAgent: 'ship-stage-runtime',
+        status: decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' ? 'blocked' : 'proposed',
+        outputRefs: input.outputRefs,
+        requiredInputRefs: input.requiredInputRefs,
+        riskDecisionRef: input.riskDecisionRef,
+        evidenceRefs: input.evidenceRefs,
+        openQuestions: [],
+        blockingGaps: [],
+        createdAt: input.generatedAt
+    };
+}
+function buildShipClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ship_ready'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-ship', scope, runId, input.generatedAt),
+        scope,
+        stage: 'ship',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Ship adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildStageRejection(stage, scope, closureRequestId, reasonCode, explanation, requiredNextAction, fallbackRoute, generatedAt, retryAllowed) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        rejectionId: stableId(`${stage}-rejection`, scope, closureRequestId ?? reasonCode, generatedAt),
+        stage,
+        scope,
+        closureRequestId,
+        reasonCode,
+        explanation,
+        requiredNextAction,
+        retryAllowed,
+        retryBudgetRemaining: retryAllowed ? 1 : 0,
+        fallbackRoute,
+        createdAt: generatedAt
+    };
+}
+function buildStageRuntimeNextActions(stage, scope, generatedAt, reasonCodes) {
+    return reasonCodes
+        .map((reasonCode, index) => ({
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        actionId: stableId(`${stage}-next-action`, scope, reasonCode, generatedAt),
+        stage,
+        scope,
+        kind: nextActionKind(reasonCode),
+        owner: nextActionOwner(reasonCode),
+        actionScope: nextActionScope(reasonCode),
+        reasonCode,
+        priority: {
+            reasonRank: reasonCodeRank(reasonCode),
+            upstreamDistance: stage === 'plan' && (reasonCode === 'missing_handoff' || reasonCode === 'stale_upstream') ? 1 : 0,
+            actionRank: actionKindRank(nextActionKind(reasonCode)),
+            stableOrder: index
+        },
+        requiredInputs: nextActionRequiredInputs(reasonCode),
+        blockedBy: [],
+        createdAt: generatedAt
+    }))
+        .sort(compareRuntimeNextAction);
+}
+function buildClosureStageRun(profile, adjudication, input) {
+    const status = adjudication.health === 'ready_for_plan'
+        ? 'completed'
+        : adjudication.health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-spec', profile.scope, input.runId, input.generatedAt),
+        scope: profile.scope,
+        stage: 'spec',
+        ownerAgent: profile.stageManager ?? 'runtime',
+        coMainAgents: profile.agentTeam,
+        status,
+        inputRefs: profile.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? stageBlockingReasons(adjudication) : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildClosureWorkflowHandoff(profile, decision, adjudication, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: adjudication.handoffPacket?.handoffId ?? stableId('spec-plan-handoff', profile.scope, 'closure', input.generatedAt),
+        scope: profile.scope,
+        fromStage: 'spec',
+        toStage: 'plan',
+        fromAgent: profile.stageManager ?? 'runtime',
+        toAgent: recommendedPlanRoles(profile)[0] ?? 'plan-stage-runtime',
+        status: decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' ? 'blocked' : 'proposed',
+        outputRefs: input.outputRefs,
+        requiredInputRefs: input.requiredInputRefs,
+        riskDecisionRef: input.riskDecisionRef,
+        evidenceRefs: input.evidenceRefs,
+        openQuestions: [],
+        blockingGaps: [],
+        createdAt: input.generatedAt
+    };
+}
+function runLifecycleDecisionRecord(decision) {
+    return {
+        contract: LIFECYCLE_DECISION_CONTRACT,
+        version: LIFECYCLE_DECISION_VERSION,
+        model_version: decision.policyVersion,
+        input_summary: { scope: decision.scope, inputHash: decision.inputHash },
+        decision: {
+            profile: decision.profile,
+            confidence: decision.confidence,
+            hard_gate_hits: decision.blockedStages,
+            required_stages: decision.requiredStages,
+            skipped_stages: decision.skippedStages,
+            human_checkpoint_required: decision.humanCheckpointRequired
+        },
+        reasons: decision.reasons,
+        escalation_triggers: decision.requiredReviews.map((review) => review.id),
+        downgrade_reason: null,
+        audit: {
+            decided_at: decision.generatedAt,
+            decided_by: 'phase9.1-stage-collaboration-runtime',
+            policy_version: decision.policyVersion,
+            source_artifacts: decision.inputRefs.map((ref) => ref.ref)
+        }
+    };
+}
+function stageBlockingReasons(adjudication) {
+    if (adjudication.clarificationGate) {
+        return adjudication.clarificationGate.questions;
+    }
+    if (adjudication.rejection) {
+        return [adjudication.rejection.explanation];
+    }
+    return [`Spec adjudication health is ${adjudication.health}.`];
+}
+function specArtifactStatusForHealth(health) {
+    if (health === 'no-op') {
+        return 'not_required_noop';
+    }
+    if (health === 'needs_clarification') {
+        return 'not_accepted_needs_clarification';
+    }
+    if (health === 'blocked') {
+        return 'not_accepted_blocked';
+    }
+    return 'not_accepted_rejected';
+}
+function isManagedStarterSpec(content) {
+    return /^sdd_managed_starter:\s*true\s*$/m.test(content);
+}
+function validateSpecDocumentV3(content) {
+    const errors = [];
+    if (!/contract:\s*sdd-spec-doc-v3\b/.test(content)) {
+        errors.push('missing contract: sdd-spec-doc-v3');
+    }
+    const requiredSections = [
+        'Problem Reframing / Intent Discovery',
+        'Change Delta',
+        'Scope',
+        'Requirements',
+        'Acceptance Criteria / Evidence Targets',
+        'Definitions / Rules',
+        'Planning Constraints / Signals',
+        'Open Questions / Ambiguity Ledger',
+        'Close Quality Evidence'
+    ];
+    for (const section of requiredSections) {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        if (!new RegExp(`^##\\s+(?:\\d+\\.\\s*)?${escaped}\\s*$`, 'im').test(content)) {
+            errors.push(`missing section: ${section}`);
+        }
+    }
+    const forbiddenSections = [/^##\s+Implementation Plan\s*$/im, /^##\s+Task List\s*$/im, /^##\s+Validation Plan\s*$/im, /^##\s+Runtime Gate Metadata\s*$/im, /^##\s+Subagent Trace\s*$/im];
+    if (forbiddenSections.some((pattern) => pattern.test(content))) {
+        errors.push('contains forbidden implementation/runtime/subagent section');
+    }
+    errors.push(...formatArtifactDepthBlockingIssues(evaluateSpecArtifactDepth(content)));
+    return errors;
+}
+function validateSpecDepthSignals(content, errors) {
+    const problem = extractMarkdownSection(content, 'Problem Reframing / Intent Discovery') ?? '';
+    const changeDelta = extractMarkdownSection(content, 'Change Delta') ?? '';
+    const requirements = extractMarkdownSection(content, 'Requirements') ?? '';
+    const acceptance = extractMarkdownSection(content, 'Acceptance Criteria / Evidence Targets') ?? '';
+    const definitions = extractMarkdownSection(content, 'Definitions / Rules') ?? '';
+    const ambiguity = extractMarkdownSection(content, 'Open Questions / Ambiguity Ledger') ?? '';
+    const closeEvidence = extractMarkdownSection(content, 'Close Quality Evidence') ?? '';
+    if (!hasProblemReframingDepth(problem)) {
+        errors.push('spec lacks problem reframing depth in Problem Reframing / Intent Discovery');
+    }
+    if (!hasChangeDeltaDepth(changeDelta)) {
+        errors.push('spec lacks explicit current/target/delta/unchanged/non-goal depth in Change Delta');
+    }
+    if (!hasRequirementReasoningDepth(requirements, definitions)) {
+        errors.push('spec lacks requirement reasoning or domain rule depth');
+    }
+    if (!hasAcceptanceEvidenceDepth(acceptance)) {
+        errors.push('spec lacks acceptance evidence targets tied to requirements');
+    }
+    if (!hasAmbiguityRoutingDepth(ambiguity)) {
+        errors.push('spec lacks explicit ambiguity routing for blocking decisions, researchable gaps, assumptions, or deferred items');
+    }
+    if (!closeEvidence) {
+        errors.push('missing spec close quality evidence content');
+        return;
+    }
+    const requiredEvidence = [
+        ['requirement_review_sufficient', 'spec close quality evidence must declare requirement_review_sufficient: true'],
+        ['problem_reframed', 'spec close quality evidence must declare problem_reframed: true'],
+        ['domain_rules_confirmed_or_routed', 'spec close quality evidence must declare domain_rules_confirmed_or_routed: true'],
+        ['acceptance_evidence_targets_defined', 'spec close quality evidence must declare acceptance_evidence_targets_defined: true'],
+        ['ambiguity_routed', 'spec close quality evidence must declare ambiguity_routed: true'],
+        ['ready_for_plan', 'spec close quality evidence must declare ready_for_plan: true']
+    ];
+    for (const [key, message] of requiredEvidence) {
+        if (!new RegExp(`${key}\\s*:\\s*` + '`?' + 'true' + '`?', 'i').test(closeEvidence)) {
+            errors.push(message);
+        }
+    }
+    if (!/downstream_business_guesswork_remaining\s*:\s*\[\s*\]/i.test(closeEvidence)) {
+        errors.push('spec close quality evidence must declare no downstream_business_guesswork_remaining');
+    }
+}
+function hasProblemReframingDepth(section) {
+    return /surface request/i.test(section)
+        && /reframed problem/i.test(section)
+        && /inferred real intent|real intent/i.test(section)
+        && /observable success/i.test(section);
+}
+function hasChangeDeltaDepth(section) {
+    return /current behavior/i.test(section)
+        && /target behavior|desired behavior/i.test(section)
+        && /delta/i.test(section)
+        && /unchanged behavior/i.test(section)
+        && /non-goals?/i.test(section);
+}
+function hasRequirementReasoningDepth(requirements, definitions) {
+    const hasRequirement = /\bREQ-\d+\b/i.test(requirements);
+    const hasReasoning = /reasoning|basis|source|constraint|because|why|rule|invariant|domain/i.test(`${requirements}\n${definitions}`);
+    return hasRequirement && hasReasoning;
+}
+function hasAcceptanceEvidenceDepth(section) {
+    return /\bAC-\d+\b/i.test(section)
+        && /evidence target|api|ui|sql|test|manual|runtime|stage close/i.test(section)
+        && /REQ-\d+/i.test(section);
+}
+function hasAmbiguityRoutingDepth(section) {
+    return /blocking user decisions?|blocking before plan|no blocking/i.test(section)
+        && /researchable|resolved by scout|scout|safe assumptions?|assumptions?|deferred/i.test(section);
+}
+function validatePlanDocumentV3(content, boundaryFacts) {
+    const errors = [];
+    if (!/contract:\s*sdd-plan-doc-v3\b/.test(content)) {
+        errors.push('missing contract: sdd-plan-doc-v3');
+    }
+    const requiredSections = [
+        'Metadata',
+        'Upstream Spec Trace',
+        'Planning Problem / Strategy Framing',
+        'Current Implementation Map',
+        'Target Design Overview',
+        'Change Topology / Responsibility Boundaries',
+        'Interface / API / Schema Design',
+        'State / Data / Concurrency Design',
+        'Key Design Decisions',
+        'Alternatives Considered',
+        'Risk Controls',
+        'Validation Strategy',
+        'Rollout / Rollback / Compatibility',
+        'Task-stage Constraints',
+        'Open Questions / User Decisions',
+        'Plan Close Quality Evidence'
+    ];
+    for (const section of requiredSections) {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        if (!new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').test(content)) {
+            errors.push(`missing section: ${section}`);
+        }
+    }
+    const forbiddenSections = ['Task Graph', 'Task Units', 'Task Breakdown Rationale', 'Implementation Diff', 'Validation Results', 'Runtime Gate Metadata', 'Subagent Trace'];
+    const hasForbiddenSection = forbiddenSections.some((section) => {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        return new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').test(content);
+    });
+    const taskLeakagePatterns = [/```sdd-task\b/i, /^###\s+T\d+\b/im, /^#{3,}\s+Task\s+Units?\b/im, /^\s*sourceRequirements\s*:/im, /^\s*sourceAcceptanceCriteria\s*:/im, /^\s*taskClass\s*:/im, /^\s*suggestedExecutionLane\s*:/im, /^\s*wave\s*:/im, /^\s*dependencies\s*:/im];
+    if (hasForbiddenSection || taskLeakagePatterns.some((pattern) => pattern.test(content))) {
+        errors.push('contains forbidden task/runtime/subagent section');
+    }
+    const closeEvidence = extractMarkdownSection(content, 'Plan Close Quality Evidence');
+    if (!closeEvidence) {
+        errors.push('missing plan close quality evidence content');
+    }
+    else if (/ready_for_tasks\s*:\s*`?false`?/i.test(closeEvidence) || !/ready_for_tasks\s*:\s*`?true`?/i.test(closeEvidence)) {
+        errors.push('plan close quality evidence must declare ready_for_tasks: true');
+    }
+    validatePlanDepthSignals(content, boundaryFacts, errors);
+    errors.push(...formatArtifactDepthBlockingIssues(evaluatePlanArtifactDepth(content)));
+    return errors;
+}
+function validatePlanDepthSignals(_content, boundaryFacts, errors) {
+    if (boundaryFacts?.blockingBeforeTasksCount !== undefined && boundaryFacts.blockingBeforeTasksCount !== 0) {
+        errors.push('plan close quality evidence conflicts with runtime blockingBeforeTasksCount');
+    }
+}
+function hasConcreteImplementationSurface(section) {
+    if (/scout gap|needs scout|unresolved gap|not applicable|no existing surface/i.test(section)) {
+        return true;
+    }
+    const namedSurfaces = section.match(/\b[A-Z][A-Za-z0-9_]*(?:Controller|Service|ServiceImpl|Mapper|Repository|Entity|DTO|VO|Request|Response|Component|Page|Config|Test)\b/g) ?? [];
+    const fileRefs = section.match(/`[^`]+\.(?:ts|tsx|js|jsx|java|kt|go|py|rs|xml|sql|jsp|vue|md)`/g) ?? [];
+    return namedSurfaces.length + fileRefs.length >= 2 && /reuse|change|do-not-reuse|do not reuse|owner|ownership|convention|boundary|surface/i.test(section);
+}
+function hasFieldApiSqlMapping(section) {
+    if (/not applicable|no interface|no api|no schema/i.test(section) && /because|checked|reason/i.test(section)) {
+        return true;
+    }
+    const backtickFields = section.match(/`[a-zA-Z_][\w.]*`/g) ?? [];
+    const identifierFields = section.match(/\b[A-Za-z_][A-Za-z0-9_]*(?:Id|IDs|Hash|Ref|Refs|Count|Status|Type|Key|Keys|At|Path|Command|Query|DTO|VO|Request|Response|Mapper|Controller|Service)\b/g) ?? [];
+    const hasApiShape = /\b(query|request|response|DTO|VO|endpoint|controller|service|mapper|SQL|MyBatis|分页|权限|错误|响应包装)\b/i.test(section);
+    const hasMapping = /\b(source|table|mapper|SQL|field|column|join|group|aggregate|映射|字段|表|聚合|查询参数|返回字段)\b/i.test(section);
+    return backtickFields.length + identifierFields.length >= 6 && hasApiShape && hasMapping;
+}
+function hasStateDataFailureDepth(section) {
+    if (/not applicable|no persisted|no state/i.test(section) && /failure|rollback|stale|dirty|because|reason/i.test(section)) {
+        return true;
+    }
+    const hasDataSources = /\b(table|source|asset|state|flow|idempot|transaction|rollback|failure|partial|dirty|stale|performance|limit|join|dedup|grain|表|状态|流程|失败|回滚|脏数据|性能|去重|粒度|资产池)\b/i.test(section);
+    const identifierRules = section.match(/\b[A-Za-z_][A-Za-z0-9_]*(?:Id|Hash|Ref|Status|Type|Key|At|Path|Projection|Handoff|Stage|State|Scope|Owner|Content)\b/g) ?? [];
+    const hasSpecificRules = (section.match(/`[^`]+`/g) ?? []).length >= 5 || identifierRules.length >= 5 || /@startuml|\|.*\|.*\|/m.test(section);
+    const hasFailureOrLimit = /\b(fail|failure|rollback|partial|dirty|stale|limit|timeout|fallback|异常|失败|回滚|部分|脏|限制|超时|降级)\b/i.test(section);
+    return hasDataSources && hasSpecificRules && hasFailureOrLimit;
+}
+function hasScenarioValidationMatrix(validationStrategy, riskControls) {
+    const combined = `${validationStrategy}\n${riskControls}`;
+    const hasScenario = /scenario|input data|user action|expected|proves|does not prove|场景|输入|预期|证明/i.test(combined);
+    const hasEvidence = /command|evidence|manual|test|api|ui|sql|hook|artifact|证据|检查/i.test(combined);
+    const hasRiskLink = /risk|impact|control|validation hook|task-stage constraint|风险|影响|控制/i.test(combined);
+    return hasScenario && hasEvidence && hasRiskLink;
+}
+function hasTaskStageConstraintDepth(section) {
+    return /boundary|constraint|rollback|ordering|dependency|validation coverage|risky seam|task-stage|atomic|边界|约束|回滚|依赖|验证/i.test(section)
+        && !/```sdd-task\b/i.test(section);
+}
+function hasScoutResolutionSignal(implementationMap, openQuestions, closeEvidence) {
+    return /scout|evidence|observed|grounded|resolved|logged|no existing surface|not applicable/i.test(`${implementationMap}\n${openQuestions}\n${closeEvidence}`);
+}
+function extractMarkdownSection(content, section) {
+    for (const sectionName of Array.isArray(section) ? section : [section]) {
+        const escaped = escapeRegex(sectionName).replace(/\s+/g, '\\s+');
+        const match = new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').exec(content);
+        if (!match) {
+            continue;
+        }
+        const start = match.index + match[0].length;
+        const rest = content.slice(start);
+        const next = /^##\s+/im.exec(rest);
+        return (next ? rest.slice(0, next.index) : rest).trim();
+    }
+    return null;
+}
+function validateTasksDocumentV2(content, tasksPath = 'tasks.md') {
+    const errors = [];
+    if (!/contract:\s*sdd-tasks-doc-v2\b/.test(content)) {
+        errors.push('missing contract: sdd-tasks-doc-v2');
+    }
+    const requiredSections = [
+        ['Split Basis', 'Task Split Basis', 'Work Unit Split Basis'],
+        ['Execution Order Overview'],
+        ['Implementation Tasks', 'Implementation Work Units', 'Implementation Task Units'],
+        ['Validation Tasks', 'Validation Work Units', 'Validation Task Units'],
+        ['Task Dependencies and Handoff', 'Dependencies and Validation Handoff', 'Task Dependency and Validation Handoff'],
+        ['Coverage Check'],
+        ['Open Execution Questions', 'Open Questions', 'Execution Questions'],
+        ['Tasks Close Quality Evidence', 'Close Quality Evidence']
+    ];
+    for (const sectionAliases of requiredSections) {
+        if (!hasMarkdownSection(content, sectionAliases)) {
+            errors.push(`missing section: ${sectionAliases[0]}`);
+        }
+    }
+    const forbiddenSections = [/^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Implementation Diff\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Validation Results\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Runtime Gate Metadata\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Subagent Trace\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Long-Term Backlog\s*$/im];
+    if (forbiddenSections.some((pattern) => pattern.test(content)) || /\b(?:obligationMatrix|projectionPayload|runtimeGateMetadata)\b/i.test(content)) {
+        errors.push('contains forbidden implementation/runtime/subagent section');
+    }
+    const parsed = parseSddTasksMarkdown(content, { tasksPath });
+    if (parsed.tasks.length === 0) {
+        errors.push('missing executable task units');
+    }
+    const taskIds = new Set(parsed.tasks.map((task) => task.id));
+    const taskById = new Map(parsed.tasks.map((task) => [task.id, task]));
+    let hasImplementationTask = false;
+    let hasValidationTask = false;
+    for (const task of parsed.tasks) {
+        const metadata = task.rawMetadata;
+        const taskClass = task.taskClass;
+        const unitType = task.unitType;
+        const dependencies = task.dependsOn;
+        if (taskClass !== 'implementation' && taskClass !== 'validation') {
+            errors.push(`task ${task.id} missing taskClass implementation|validation`);
+        }
+        if (!unitType) {
+            errors.push(`task ${task.id} missing unitType`);
+        }
+        if (!Number.isInteger(task.wave) || (task.wave ?? 0) <= 0) {
+            errors.push(`task ${task.id} missing execution wave`);
+        }
+        if (task.affectedFiles.length === 0) {
+            errors.push(`task ${task.id} missing affected areas`);
+        }
+        for (const dependency of dependencies) {
+            if (!taskIds.has(dependency)) {
+                errors.push(`task ${task.id} references unknown dependency ${dependency}`);
+            }
+        }
+        if (taskClass === 'implementation') {
+            hasImplementationTask = true;
+            const handoffTasks = task.validationHandoff;
+            if (handoffTasks.length === 0) {
+                errors.push(`task ${task.id} missing validation handoff`);
+            }
+            for (const handoffTaskId of handoffTasks) {
+                const handoffTask = taskById.get(handoffTaskId);
+                if (!handoffTask) {
+                    errors.push(`task ${task.id} hands off to unknown validation task ${handoffTaskId}`);
+                }
+                else if (handoffTask.taskClass !== 'validation') {
+                    errors.push(`task ${task.id} hands off to non-validation task ${handoffTaskId}`);
+                }
+                else if (Number.isInteger(task.wave) && Number.isInteger(handoffTask.wave) && (handoffTask.wave ?? 0) <= (task.wave ?? 0)) {
+                    errors.push(`task ${task.id} validation handoff ${handoffTaskId} must be in a later wave`);
+                }
+            }
+        }
+        if (taskClass === 'validation') {
+            hasValidationTask = true;
+            const validatesTasks = metadataNamedListValue(metadata, ['validatesImplementationTasks', 'validates_implementation_tasks']);
+            if (validatesTasks.length === 0) {
+                errors.push(`task ${task.id} missing validatesImplementationTasks`);
+            }
+            for (const validatedTask of validatesTasks) {
+                if (!taskIds.has(validatedTask)) {
+                    errors.push(`task ${task.id} validates unknown implementation task ${validatedTask}`);
+                }
+                const validated = taskById.get(validatedTask);
+                if (validated && validated.taskClass !== 'implementation') {
+                    errors.push(`task ${task.id} validates non-implementation task ${validatedTask}`);
+                }
+                if (validated && Number.isInteger(task.wave) && Number.isInteger(validated.wave) && (task.wave ?? 0) <= (validated.wave ?? 0)) {
+                    errors.push(`task ${task.id} must run after validated implementation task ${validatedTask}`);
+                }
+                if (!dependencies.includes(validatedTask)) {
+                    errors.push(`task ${task.id} must depend on validated implementation task ${validatedTask}`);
+                }
+            }
+        }
+    }
+    if (!hasImplementationTask) {
+        errors.push('missing implementation task');
+    }
+    if (!hasValidationTask) {
+        errors.push('missing validation task');
+    }
+    errors.push(...validateTaskValidationTopology(parsed.tasks));
+    validateTasksDepthSignals(content, errors);
+    errors.push(...taskDependencyCycleErrors(parsed.tasks));
+    return errors;
+}
+function validateTasksDepthSignals(content, errors) {
+    const closeEvidence = extractMarkdownSection(content, ['Tasks Close Quality Evidence', 'Close Quality Evidence']) ?? '';
+    if (!hasTaskReviewVerdict(closeEvidence) || !hasTaskReviewReconciliation(closeEvidence)) {
+        errors.push('tasks close quality evidence must include task-review-agent verdict and tasks-manager review reconciliation');
+    }
+    if (!/downstream_execution_guesswork_remaining\s*:\s*\[\s*\]/i.test(closeEvidence)) {
+        errors.push('tasks close quality evidence must declare downstream_execution_guesswork_remaining: []');
+    }
+}
+function hasTaskReviewVerdict(section) {
+    return /task-review-agent\s+(?:verdict|review)|review(?:_|\s+)signal|reviewed by task-review-agent/i.test(section);
+}
+function hasTaskReviewReconciliation(section) {
+    return /review(?:_|\s+)reconciliation|tasks-manager\s+(?:review\s+)?reconciliation|tasks-manager\s+(?:resolved|adjudicated)|review findings? reconciled|blocking findings resolved|task-review-agent findings resolved/i.test(section);
+}
+function hasWorkUnitContextDepth(section) {
+    return /why this task exists|work-unit context|plan decision|design part|must not reinterpret|risk/i.test(section);
+}
+function hasUpstreamTraceDepth(section) {
+    return /REQ-\d+/i.test(section) && /AC-\d+/i.test(section) && /planRefs|plan section|plan decision|§\d+/i.test(section);
+}
+function hasModificationBoundaryDepth(section) {
+    return /allowed files|allowed code|allowed .*changes|forbidden files|forbidden .*scope|what not to do|modification boundary|scope exclusions/i.test(section);
+}
+function hasRollbackUnitDepth(implementationTasks, dependencies) {
+    return /rollback unit|reverted together|rollback boundary|shared rollback/i.test(`${implementationTasks}\n${dependencies}`);
+}
+function hasDependencyRationaleDepth(dependencies, implementationTasks) {
+    return /because|why ordering matters|dependency rationale|unlocks|must complete before|parallel/i.test(`${dependencies}\n${implementationTasks}`);
+}
+function hasCompletionEvidenceDepth(section) {
+    return /completion evidence|done criteria|observable completion|what does not count|code review|basic code sanity/i.test(section);
+}
+function hasValidationExpectedResultDepth(section) {
+    return /expected result|pass criteria|evidence is enough|does not prove|acceptance checks|manual inspection|test/i.test(section);
+}
+function hasFailureRouteDepth(section) {
+    return /failure routing|failure route|return to|plan repair|spec\/user decision|environment diagnostic|tasks repair/i.test(section);
+}
+function hasMarkdownSection(content, sectionAliases) {
+    return sectionAliases.some((section) => {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        return new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').test(content);
+    });
+}
+function validateTaskValidationTopology(tasks) {
+    const taskIds = new Set(tasks.map((task) => task.id));
+    if (taskIds.size !== tasks.length) {
+        return [];
+    }
+    const taskById = new Map(tasks.map((task) => [task.id, task]));
+    const errors = [];
+    for (const task of tasks) {
+        if (task.taskClass === 'implementation') {
+            if (task.validationHandoff.length !== 1) {
+                errors.push(`task ${task.id} must hand off to exactly one validation task`);
+                continue;
+            }
+            const validationTask = taskById.get(task.validationHandoff[0]);
+            const validatesTasks = validationTask ? metadataNamedListValue(validationTask.rawMetadata, ['validatesImplementationTasks', 'validates_implementation_tasks']) : [];
+            if (validationTask && (validatesTasks.length !== 1 || validatesTasks[0] !== task.id)) {
+                errors.push(`task ${task.id} validation handoff ${validationTask.id} must validate exactly ${task.id}`);
+            }
+        }
+        if (task.taskClass === 'validation') {
+            const validatesTasks = metadataNamedListValue(task.rawMetadata, ['validatesImplementationTasks', 'validates_implementation_tasks']);
+            if (validatesTasks.length !== 1) {
+                errors.push(`task ${task.id} must validate exactly one implementation task`);
+                continue;
+            }
+            const implementationTask = taskById.get(validatesTasks[0]);
+            if (implementationTask?.taskClass === 'implementation' && (implementationTask.validationHandoff.length !== 1 || implementationTask.validationHandoff[0] !== task.id)) {
+                errors.push(`task ${task.id} validates ${implementationTask.id} but ${implementationTask.id} must hand off only to ${task.id}`);
+            }
+        }
+    }
+    return errors;
+}
+function taskDependencyCycleErrors(tasks) {
+    const taskIds = new Set(tasks.map((task) => task.id));
+    const dependencies = new Map(tasks.map((task) => [task.id, task.dependsOn.filter((dependency) => taskIds.has(dependency))]));
+    const visiting = new Set();
+    const visited = new Set();
+    const errors = [];
+    const visit = (taskId, path) => {
+        if (visited.has(taskId)) {
+            return;
+        }
+        if (visiting.has(taskId)) {
+            errors.push(`task dependency cycle: ${[...path, taskId].join(' -> ')}`);
+            return;
+        }
+        visiting.add(taskId);
+        for (const dependency of dependencies.get(taskId) ?? []) {
+            visit(dependency, [...path, taskId]);
+        }
+        visiting.delete(taskId);
+        visited.add(taskId);
+    };
+    for (const task of tasks) {
+        visit(task.id, []);
+    }
+    return Array.from(new Set(errors));
+}
+function metadataNamedListValue(metadata, names) {
+    for (const name of names) {
+        const value = metadataListValue(metadata[name]);
+        if (value.length > 0) {
+            return value;
+        }
+    }
+    return [];
+}
+function metadataNamedScalarValue(metadata, names) {
+    for (const name of names) {
+        const value = metadataScalarValue(metadata[name]);
+        if (value !== null) {
+            return value;
+        }
+    }
+    return null;
+}
+function metadataListValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter((item) => item.length > 0);
+    }
+    const scalar = metadataScalarValue(value);
+    return scalar ? [scalar] : [];
+}
+function metadataScalarValue(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return null;
+}
+async function readOptionalText(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+function specAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${specCollaborationScopeKey(scope)}`
+    };
+}
+function planAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${PLAN_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${planCollaborationScopeKey(scope)}`
+    };
+}
+function tasksAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${tasksCollaborationScopeKey(scope)}`
+    };
+}
+function executeAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${executeCollaborationScopeKey(scope)}`
+    };
+}
+function shipAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${shipCollaborationScopeKey(scope)}`
+    };
+}
+function stableHash(value) {
+    return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value.length > 0)));
+}
+function uniqueRuntimeRefs(refs) {
+    const seen = new Set();
+    return refs.filter((ref) => {
+        const key = `${ref.kind}:${ref.ref}:${ref.hash ?? ''}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function runtimeProjectionPayload(payload) {
+    if (!payload || typeof payload !== 'object' || !('payload' in payload)) {
+        return null;
+    }
+    return payload.payload;
+}
+function stableId(prefix, scope, ...parts) {
+    const hash = createHash('sha256').update(JSON.stringify([scope, parts]), 'utf8').digest('hex').slice(0, 16);
+    return `${prefix}-${hash}`;
+}
+//# sourceMappingURL=stage-collaboration.js.map