sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -0,0 +1,3870 @@
+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 { hashDocumentContent, hashSemanticDocument, hashTasksContract } from './sdd-docs/document-hashes.js';
+import { parseSddTasksMarkdown } from './sdd-docs/task-parser.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';
+import { inspectVerifyContract } from './verification/verify-contract.js';
+export const SPEC_STAGE_MANAGER = 'spec-manager';
+export const SPEC_STAGE_DRAFTER_AGENT = 'spec-drafter';
+export const SPEC_STAGE_REVIEW_AGENT = 'spec-reviewer';
+export const SPEC_STAGE_SCOUT_AGENT = 'scout';
+export const SPEC_STAGE_AGENT_TEAM = [SPEC_STAGE_DRAFTER_AGENT, SPEC_STAGE_REVIEW_AGENT, SPEC_STAGE_SCOUT_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_DRAFTER_AGENT = 'plan-drafter';
+export const PLAN_STAGE_REVIEW_AGENT = 'plan-reviewer';
+export const TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_3_tasks_collaboration_adjudication';
+export const TASKS_STAGE_MANAGER = 'tasks-manager';
+export const TASKS_STAGE_DRAFTER_AGENT = 'tasks-drafter';
+export const TASKS_STAGE_REVIEW_AGENT = 'tasks-reviewer';
+export const TASKS_STAGE_SLICER_AGENT = 'task-slicer';
+export const VERIFIES_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_4_verifies_collaboration_adjudication';
+export const VERIFIES_STAGE_MANAGER = 'verifies-manager';
+export const VERIFIES_STAGE_DRAFTER_AGENT = 'verifies-drafter';
+export const VERIFIES_STAGE_REVIEW_AGENT = 'verifies-reviewer';
+export const VERIFIES_STAGE_VERIFICATION_AGENT = 'verification-agent';
+export const DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_5_do_collaboration_adjudication';
+export const DO_STAGE_MANAGER = 'do-manager';
+export const DO_STAGE_IMPLEMENTER_AGENT = 'implementer';
+export const DO_STAGE_CODE_REVIEW_AGENT = 'code-reviewer';
+export const DO_STAGE_DEBUGGER_AGENT = 'debugger';
+export const TEST_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_6_test_collaboration_adjudication';
+export const TEST_STAGE_MANAGER = 'test-manager';
+export const TEST_STAGE_RUNNER_AGENT = 'test-runner';
+export const TEST_STAGE_VALIDATOR_AGENT = 'validator';
+export const TEST_STAGE_REVIEW_AGENT = 'test-reviewer';
+export const GOAL_VERIFY_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_7_goal_verify_collaboration_adjudication';
+export const GOAL_VERIFY_STAGE_MANAGER = 'goal-verify-manager';
+export const GOAL_VERIFY_STAGE_VALIDATOR_AGENT = 'goal-validator';
+export const GOAL_VERIFY_STAGE_REVIEW_AGENT = 'goal-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', 'verifies', 'do', 'test', 'goal-verify', '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: profile.agentTeam.includes(SPEC_STAGE_SCOUT_AGENT)
+            ? ['scout_context', 'spec_review', 'manager_closure_request']
+            : ['spec_review', 'manager_closure_request'],
+        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()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('plan-work-order', scope),
+        stage: 'plan',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['plan_context', 'plan_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: PLAN_STAGE_MANAGER,
+        agentTeam: ['plan-scout', PLAN_STAGE_DRAFTER_AGENT, PLAN_STAGE_REVIEW_AGENT],
+        requiredCapabilities: ['solution-design', 'verification-design'],
+        optionalCapabilities: ['performance-planning', 'security-engineering', 'frontend-engineering'],
+        materialPackIds: ['project-norms', 'baseline-solution-design', 'baseline-verification-design'],
+        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_DRAFTER_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 verifiesCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'verifies'].join(':');
+}
+export function buildVerifiesStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('verifies-work-order', scope),
+        stage: 'verifies',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['verifies_context', 'verifies_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: VERIFIES_STAGE_MANAGER,
+        agentTeam: [VERIFIES_STAGE_VERIFICATION_AGENT, VERIFIES_STAGE_DRAFTER_AGENT, VERIFIES_STAGE_REVIEW_AGENT],
+        requiredCapabilities: ['verification-design', 'acceptance-coverage'],
+        optionalCapabilities: ['security-testing', 'performance-testing', 'frontend-validation'],
+        materialPackIds: ['project-norms', 'baseline-verification-design', 'baseline-acceptance-coverage'],
+        generatedAt
+    };
+}
+export function doCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'do'].join(':');
+}
+export function buildDoStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('do-work-order', scope),
+        stage: 'do',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['implementation_evidence', 'code_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: DO_STAGE_MANAGER,
+        agentTeam: [DO_STAGE_IMPLEMENTER_AGENT, DO_STAGE_CODE_REVIEW_AGENT, DO_STAGE_DEBUGGER_AGENT],
+        requiredCapabilities: ['implementation', 'code-review'],
+        optionalCapabilities: ['debugging', 'security-engineering', 'frontend-engineering'],
+        materialPackIds: ['project-norms', 'baseline-implementation', 'baseline-code-review'],
+        generatedAt
+    };
+}
+export function testCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'test'].join(':');
+}
+export function buildTestStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('test-work-order', scope),
+        stage: 'test',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['test_execution', 'validation_evidence', 'test_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: TEST_STAGE_MANAGER,
+        agentTeam: [TEST_STAGE_RUNNER_AGENT, TEST_STAGE_VALIDATOR_AGENT, TEST_STAGE_REVIEW_AGENT],
+        requiredCapabilities: ['test-execution', 'validation-evidence'],
+        optionalCapabilities: ['flaky-test-analysis', 'frontend-validation', 'security-testing'],
+        materialPackIds: ['project-norms', 'baseline-test-execution', 'baseline-validation-evidence'],
+        generatedAt
+    };
+}
+export function goalVerifyCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'goal-verify'].join(':');
+}
+export function buildGoalVerifyStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        workOrderId: stableId('goal-verify-work-order', scope),
+        stage: 'goal-verify',
+        scope,
+        profileRef,
+        authorityCeiling: 'proposal_input',
+        requiredOutputKinds: ['goal_verification', 'goal_review', 'manager_closure_request'],
+        forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
+        inputRefs,
+        stageManager: GOAL_VERIFY_STAGE_MANAGER,
+        agentTeam: [GOAL_VERIFY_STAGE_VALIDATOR_AGENT, GOAL_VERIFY_STAGE_REVIEW_AGENT],
+        requiredCapabilities: ['goal-verification', 'acceptance-coverage'],
+        optionalCapabilities: ['gap-analysis', 'regression-risk-review'],
+        materialPackIds: ['project-norms', 'baseline-goal-verification', 'baseline-acceptance-coverage'],
+        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.acceptedGoalVerificationRef, ...input.artifactRefs].filter((ref) => ref !== null));
+    return {
+        contract: TRUTH_ALIGNMENT_CONTRACT,
+        branch: scope.branch,
+        sourceStage: 'goal-verify',
+        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 recordVerifiesCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: VERIFIES_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: verifiesCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.4-verifies-stage-collaboration-runtime',
+        producerVersion: 'phase9.4-verifies-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordDoCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: doCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.5-do-stage-collaboration-runtime',
+        producerVersion: 'phase9.5-do-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordTestCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: TEST_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: testCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.6-test-stage-collaboration-runtime',
+        producerVersion: 'phase9.6-test-stage-collaboration-runtime-v1',
+        generatedAt: result.createdAt,
+        payload: result
+    });
+}
+export async function recordGoalVerifyCollaborationAdjudicationProjection(projectRoot, result) {
+    return recordRuntimeProjectionEnvelope(projectRoot, {
+        projectionType: GOAL_VERIFY_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: goalVerifyCollaborationScopeKey(result.scope),
+        inputHash: stableHash(JSON.stringify(result)),
+        producer: 'phase9.7-goal-verify-stage-collaboration-runtime',
+        producerVersion: 'phase9.7-goal-verify-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 = 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 derivedClosure = deriveRegisteredStageClosureRequest(profile, workOrder, registeredArtifacts, context.partition, generatedAt);
+    const closureRequest = input.closureRequest ?? derivedClosure;
+    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', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'plan', 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 = planAdjudicationProjectionRef(decision.scope);
+    const planAcceptance = await validateAcceptedPlanArtifact(projectRoot, {
+        partition: context.partition,
+        required: planRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedSpecHandoff: acceptedSpecHandoffEnvelope?.payload ?? null
+    });
+    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 handoff = planAcceptance.planAcceptanceStatus === 'accepted'
+        ? buildPlanWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: planAcceptance.acceptedPlanRef ? [planAcceptance.acceptedPlanRef] : [],
+            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 = 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: outputRefs,
+            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', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'tasks', 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 = tasksAdjudicationProjectionRef(decision.scope);
+    const tasksAcceptance = await validateAcceptedTasksArtifact(projectRoot, {
+        partition: context.partition,
+        required: tasksRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedPlanHandoff: acceptedPlanHandoffEnvelope?.payload ?? null
+    });
+    const health = tasksAcceptance.tasksAcceptanceStatus === 'accepted'
+        ? 'ready_for_verifies'
+        : !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_verifies' ? '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_verifies' || health === 'no-op' ? [] : tasksAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('tasks', decision.scope, generatedAt, health === 'ready_for_verifies' ? ['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 reconcileVerifiesCollaborationClosure(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 verifiesRequired = decision.requiredStages.includes('verifies');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('verifies');
+    const acceptedTasksHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'tasks', 'verifies');
+    const workOrderInputRefs = acceptedTasksHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${VERIFIES_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${verifiesCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = verifiesRequired && !blocked ? buildVerifiesStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'verifies', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'verifies', 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 = verifiesAdjudicationProjectionRef(decision.scope);
+    const verifyAcceptance = await validateAcceptedVerifyArtifact(projectRoot, {
+        partition: context.partition,
+        required: verifiesRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedTasksHandoff: acceptedTasksHandoffEnvelope?.payload ?? null
+    });
+    const health = verifyAcceptance.verifyAcceptanceStatus === 'accepted'
+        ? 'ready_for_do'
+        : !verifiesRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const outputRefs = [verifyAcceptance.acceptedVerifyRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildVerifiesClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedTasksHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: verifyAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = verifyAcceptance.verifyAcceptanceStatus === 'accepted'
+        ? buildVerifiesWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: verifyAcceptance.acceptedVerifyRef ? [verifyAcceptance.acceptedVerifyRef] : [],
+            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 = verifyAcceptance.rejectionIssue
+        ? buildStageRejection('verifies', decision.scope, null, verifyAcceptance.rejectionIssue.reasonCode, verifyAcceptance.rejectionIssue.explanation, verifyAcceptance.rejectionIssue.requiredNextAction, verifyAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedVerifyRef: verifyAcceptance.acceptedVerifyRef,
+        verifyAcceptanceStatus: verifyAcceptance.verifyAcceptanceStatus,
+        verifyHash: verifyAcceptance.verifyHash,
+        verifyContractHash: verifyAcceptance.verifyContractHash,
+        acceptedTasksHandoffRef: acceptedTasksHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'tasks', 'verifies')}` } : null,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: verifyAcceptance.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('verifies-adjudication', decision.scope, health, generatedAt),
+        stage: 'verifies',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('verifies-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'verifies',
+            scope: decision.scope,
+            status: health === 'ready_for_do' ? '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_do' || health === 'no-op' ? [] : verifyAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('verifies', decision.scope, generatedAt, health === 'ready_for_do' ? ['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 recordVerifiesCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedVerifyRef: verifyAcceptance.acceptedVerifyRef
+    };
+}
+export async function reconcileDoCollaborationClosure(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 doRequired = decision.requiredStages.includes('do');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('do');
+    const acceptedVerifyHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'verifies', 'do');
+    const workOrderInputRefs = acceptedVerifyHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${doCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = doRequired && !blocked ? buildDoStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'do', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'do', 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 = doAdjudicationProjectionRef(decision.scope);
+    const implementationAcceptance = await validateAcceptedDoArtifact(projectRoot, {
+        partition: context.partition,
+        required: doRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedVerifyHandoff: acceptedVerifyHandoffEnvelope?.payload ?? null,
+        allowedChangedFileRefs: input.allowedChangedFileRefs
+    });
+    const health = implementationAcceptance.implementationAcceptanceStatus === 'accepted'
+        ? 'ready_for_test'
+        : !doRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const outputRefs = [implementationAcceptance.acceptedImplementationRef, adjudicationProjectionRef, collaborationContractRef, ...implementationAcceptance.changedFileRefs, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildDoClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedVerifyHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: implementationAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = implementationAcceptance.implementationAcceptanceStatus === 'accepted'
+        ? buildDoWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: [implementationAcceptance.acceptedImplementationRef, ...implementationAcceptance.changedFileRefs].filter((ref) => ref !== null),
+            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 = implementationAcceptance.rejectionIssue
+        ? buildStageRejection('do', decision.scope, null, implementationAcceptance.rejectionIssue.reasonCode, implementationAcceptance.rejectionIssue.explanation, implementationAcceptance.rejectionIssue.requiredNextAction, implementationAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedImplementationRef: implementationAcceptance.acceptedImplementationRef,
+        implementationAcceptanceStatus: implementationAcceptance.implementationAcceptanceStatus,
+        implementationHash: implementationAcceptance.implementationHash,
+        changedFileRefs: implementationAcceptance.changedFileRefs,
+        acceptedVerifyHandoffRef: acceptedVerifyHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'verifies', 'do')}` } : null,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: implementationAcceptance.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('do-adjudication', decision.scope, health, generatedAt),
+        stage: 'do',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('do-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'do',
+            scope: decision.scope,
+            status: health === 'ready_for_test' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: outputRefs,
+            advisoryRefs: [],
+            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('debug') || ref.ref.includes('capability')),
+            blockingReasons: health === 'ready_for_test' || health === 'no-op' ? [] : implementationAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('do', decision.scope, generatedAt, health === 'ready_for_test' ? ['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 recordDoCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedImplementationRef: implementationAcceptance.acceptedImplementationRef,
+        changedFileRefs: implementationAcceptance.changedFileRefs
+    };
+}
+export async function reconcileTestCollaborationClosure(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 testRequired = decision.requiredStages.includes('test');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('test');
+    const acceptedDoHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'do', 'test');
+    const workOrderInputRefs = acceptedDoHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${TEST_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${testCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = testRequired && !blocked ? buildTestStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'test', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'test', 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 = testAdjudicationProjectionRef(decision.scope);
+    const testAcceptance = await validateAcceptedTestArtifact(projectRoot, {
+        partition: context.partition,
+        required: testRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedDoHandoff: acceptedDoHandoffEnvelope?.payload ?? null
+    });
+    const health = testAcceptance.testAcceptanceStatus === 'accepted'
+        ? 'ready_for_goal_verify'
+        : !testRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const outputRefs = [testAcceptance.acceptedTestEvidenceRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildTestClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedDoHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: testAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = testAcceptance.testAcceptanceStatus === 'accepted'
+        ? buildTestWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: testAcceptance.acceptedTestEvidenceRef ? [testAcceptance.acceptedTestEvidenceRef] : [],
+            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 = testAcceptance.rejectionIssue
+        ? buildStageRejection('test', decision.scope, null, testAcceptance.rejectionIssue.reasonCode, testAcceptance.rejectionIssue.explanation, testAcceptance.rejectionIssue.requiredNextAction, testAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedTestEvidenceRef: testAcceptance.acceptedTestEvidenceRef,
+        testAcceptanceStatus: testAcceptance.testAcceptanceStatus,
+        testEvidenceHash: testAcceptance.testEvidenceHash,
+        acceptedDoHandoffRef: acceptedDoHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'do', 'test')}` } : null,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        reasons: testAcceptance.reasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('test-adjudication', decision.scope, health, generatedAt),
+        stage: 'test',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('test-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'test',
+            scope: decision.scope,
+            status: health === 'ready_for_goal_verify' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: outputRefs,
+            advisoryRefs: [],
+            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('validation') || ref.ref.includes('capability')),
+            blockingReasons: health === 'ready_for_goal_verify' || health === 'no-op' ? [] : testAcceptance.reasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('test', decision.scope, generatedAt, health === 'ready_for_goal_verify' ? ['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 recordTestCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedTestEvidenceRef: testAcceptance.acceptedTestEvidenceRef
+    };
+}
+export async function reconcileGoalVerifyCollaborationClosure(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 goalVerifyRequired = decision.requiredStages.includes('goal-verify');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('goal-verify');
+    const acceptedTestHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'test', 'goal-verify');
+    const workOrderInputRefs = acceptedTestHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
+    const profileRef = { kind: 'projection', ref: `${GOAL_VERIFY_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${goalVerifyCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = goalVerifyRequired && !blocked ? buildGoalVerifyStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'goal-verify', workOrder, input.collaborationContractRefs, generatedAt);
+    const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
+    const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'goal-verify', 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 = goalVerifyAdjudicationProjectionRef(decision.scope);
+    const goalVerifyAcceptance = await validateAcceptedGoalVerifyArtifact(projectRoot, {
+        partition: context.partition,
+        required: goalVerifyRequired,
+        blocked,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedTestHandoff: acceptedTestHandoffEnvelope?.payload ?? null
+    });
+    const truthAlignmentObservation = goalVerifyAcceptance.truthAlignment;
+    const truthAlignmentStatus = goalVerifyAcceptance.goalVerifyAcceptanceStatus === 'accepted'
+        ? truthAlignmentObservation?.status ?? 'aligned'
+        : 'blocked';
+    const declaredTruthRefs = await collectTruthAlignmentDeclaredTruthRefs(projectRoot, context.rawBranch, acceptedTestHandoffEnvelope?.payload ?? null);
+    const truthAlignmentProjection = goalVerifyRequired
+        ? buildTruthAlignmentProjection(decision.scope, {
+            acceptedGoalVerificationRef: goalVerifyAcceptance.acceptedGoalVerificationRef,
+            declaredTruthRefs,
+            artifactRefs,
+            status: truthAlignmentStatus,
+            ownerStage: truthAlignmentObservation?.ownerStage ?? null,
+            semanticImpact: truthAlignmentObservation?.semanticImpact ?? (truthAlignmentStatus === 'aligned' ? 'none' : 'material'),
+            staleRefs: truthAlignmentObservation?.staleRefs ?? [],
+            invalidatesStages: truthAlignmentObservation?.invalidatesStages ?? (truthAlignmentStatus === 'aligned' ? [] : ['ship']),
+            reasons: truthAlignmentObservation?.reasons.length ? truthAlignmentObservation.reasons : goalVerifyAcceptance.goalVerifyAcceptanceStatus === 'accepted'
+                ? ['Accepted goal verification is structurally aligned with declared upstream truth refs.']
+                : goalVerifyAcceptance.reasons,
+            generatedAt
+        })
+        : null;
+    const goalVerifyClosureReasons = truthAlignmentProjection?.status !== 'aligned' && truthAlignmentProjection?.reasons.length ? truthAlignmentProjection.reasons : goalVerifyAcceptance.reasons;
+    const truthAlignmentProjectionRef = truthAlignmentProjection
+        ? { kind: 'projection', ref: `${TRUTH_ALIGNMENT_PROJECTION_TYPE}:${truthAlignmentScopeKey({ branch: decision.scope.branch })}` }
+        : undefined;
+    const health = goalVerifyAcceptance.goalVerifyAcceptanceStatus === 'accepted'
+        ? truthAlignmentStatus === 'aligned' ? 'ready_for_ship' : 'blocked'
+        : !goalVerifyRequired
+            ? 'no-op'
+            : blocked
+                ? 'blocked'
+                : 'rejected';
+    const outputRefs = [goalVerifyAcceptance.acceptedGoalVerificationRef, truthAlignmentProjectionRef, adjudicationProjectionRef, collaborationContractRef, ...artifactRefs].filter((ref) => ref !== null && ref !== undefined);
+    const stageRun = buildGoalVerifyClosureStageRun(decision.scope, run.runId, workOrder, health, {
+        outputRefs,
+        decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
+        inputRefs: acceptedTestHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        generatedAt,
+        rejectionReason: goalVerifyAcceptance.rejectionIssue?.explanation ?? null
+    });
+    const stageRunProjectionRef = {
+        kind: 'projection',
+        ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
+    };
+    const handoff = null;
+    const workflowHandoffProjectionRef = undefined;
+    const rejection = goalVerifyAcceptance.rejectionIssue
+        ? buildStageRejection('goal-verify', decision.scope, null, goalVerifyAcceptance.rejectionIssue.reasonCode, goalVerifyAcceptance.rejectionIssue.explanation, goalVerifyAcceptance.rejectionIssue.requiredNextAction, goalVerifyAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
+        : null;
+    const closureRefs = {
+        runRef,
+        acceptedGoalVerificationRef: goalVerifyAcceptance.acceptedGoalVerificationRef,
+        goalVerifyAcceptanceStatus: goalVerifyAcceptance.goalVerifyAcceptanceStatus,
+        goalVerificationHash: goalVerifyAcceptance.goalVerificationHash,
+        acceptedTestHandoffRef: acceptedTestHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'test', 'goal-verify')}` } : null,
+        artifactRefs,
+        collaborationContractRef,
+        lifecycleRiskProjectionRef,
+        adjudicationProjectionRef,
+        stageRunProjectionRef,
+        workflowHandoffProjectionRef,
+        truthAlignmentProjectionRef,
+        reasons: goalVerifyClosureReasons
+    };
+    const adjudication = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        adjudicationId: stableId('goal-verify-adjudication', decision.scope, health, generatedAt),
+        stage: 'goal-verify',
+        scope: decision.scope,
+        health,
+        stageDecision: {
+            contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+            decisionId: stableId('goal-verify-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'goal-verify',
+            scope: decision.scope,
+            status: health === 'ready_for_ship' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
+            health,
+            acceptedDecisionRefs: outputRefs,
+            advisoryRefs: [],
+            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('goal-verification') || ref.ref.includes('capability')),
+            blockingReasons: health === 'ready_for_ship' || health === 'no-op' ? [] : goalVerifyClosureReasons,
+            createdAt: generatedAt
+        },
+        handoffPacket: handoff,
+        rejection,
+        nextActions: buildStageRuntimeNextActions('goal-verify', decision.scope, generatedAt, health === 'ready_for_ship' ? ['stage_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
+        closureRefs,
+        createdAt: generatedAt
+    };
+    await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+    await recordStageRunProjection(projectRoot, stageRun);
+    if (truthAlignmentProjection) {
+        await recordTruthAlignmentProjection(projectRoot, truthAlignmentProjection);
+    }
+    const projection = await recordGoalVerifyCollaborationAdjudicationProjection(projectRoot, adjudication);
+    return {
+        runId: run.runId,
+        branch: context.rawBranch,
+        workOrder,
+        adjudication,
+        projectionRef: { kind: 'projection', ref: `${projection.envelope.projectionType}:${projection.envelope.scopeKey}` },
+        artifactRefs,
+        registeredArtifacts,
+        registeredCollaborationContracts,
+        acceptedGoalVerificationRef: goalVerifyAcceptance.acceptedGoalVerificationRef
+    };
+}
+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_verifies', projectionType: TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'verifies', expectedHealth: 'ready_for_do', projectionType: VERIFIES_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'do', expectedHealth: 'ready_for_test', projectionType: DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'test', expectedHealth: 'ready_for_goal_verify', projectionType: TEST_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'goal-verify', expectedHealth: 'ready_for_ship', projectionType: GOAL_VERIFY_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 !== 'goal-verify' && 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 !== 'goal-verify' && 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',
+        verifies: 'acceptedVerifyRef',
+        do: 'acceptedImplementationRef',
+        test: 'acceptedTestEvidenceRef',
+        'goal-verify': 'acceptedGoalVerificationRef',
+        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 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_DRAFTER_AGENT, SPEC_STAGE_REVIEW_AGENT];
+    }
+    return [SPEC_STAGE_SCOUT_AGENT, SPEC_STAGE_DRAFTER_AGENT, SPEC_STAGE_REVIEW_AGENT];
+}
+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' : agent === SPEC_STAGE_DRAFTER_AGENT ? 'spec-document-candidate-author' : 'spec-document-reviewer',
+            required: true,
+            capabilityDomain: agent === SPEC_STAGE_SCOUT_AGENT ? 'context_curation' : agent === SPEC_STAGE_DRAFTER_AGENT ? 'norm_discovery' : 'uncertainty_resolution',
+            parallelGroup: agent === SPEC_STAGE_SCOUT_AGENT ? 'discovery' : agent === SPEC_STAGE_DRAFTER_AGENT ? 'authoring' : '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 candidate, review, and evidence refs.', 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.candidateRef) {
+        return { reasonCode: 'invalid_proposal', explanation: 'Spec stage closure is missing SpecDocumentCandidate.', requiredNextAction: 'Ask spec-drafter to produce a candidate and submit its ref.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    if (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 };
+    }
+    if (request.candidate.inputRefs.length === 0) {
+        return { reasonCode: 'missing_refs', explanation: 'SpecDocumentCandidate has no input refs.', requiredNextAction: 'Attach spec request, document, or runtime projection refs before closure.', 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.reviewRefs.length === 0 || request.reviewResults.length === 0) {
+        return { reasonCode: 'missing_required_review', explanation: 'Spec stage closure is missing spec-reviewer review evidence.', requiredNextAction: 'Ask spec-reviewer to review the candidate before closure.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    const approvedReview = request.reviewResults.find((review) => review.reviewer === SPEC_STAGE_REVIEW_AGENT && review.verdict === 'approved');
+    if (!approvedReview && request.unresolvedAmbiguityIds.length === 0) {
+        return { reasonCode: 'missing_required_review', explanation: 'Spec stage closure has no approved spec-reviewer result.', requiredNextAction: 'Resolve review findings or submit approved spec-reviewer evidence.', fallbackRoute: 'revise-proposal', retryAllowed: true };
+    }
+    if (request.evidenceRefs.length === 0) {
+        return { reasonCode: 'missing_refs', explanation: 'Spec stage closure has no evidence refs.', requiredNextAction: 'Attach work order, candidate, review, and source evidence refs.', 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) {
+    if (artifactRefs && artifactRefs.length > 0) {
+        return [...new Set(artifactRefs.map(normalizeBranchStageEvidenceRef))];
+    }
+    if (!profile.requiresStageClosure) {
+        return [];
+    }
+    const dir = getBranchStageEvidenceDir(projectRoot, branch, 'spec');
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+    return files
+        .filter(isSpecStageEvidenceFile)
+        .sort(compareStageEvidenceFileNames)
+        .map((fileName) => toBranchStageEvidenceRef(branch, 'spec', fileName));
+}
+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 };
+}
+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 deriveRegisteredStageClosureRequest(profile, workOrder, records, branchPartition, generatedAt) {
+    const manager = latestStageArtifact(records, 'manager_closure_request');
+    if (!manager) {
+        return null;
+    }
+    const review = findReviewForManager(records, manager);
+    const expectedSpecRef = `specs/${branchPartition}/spec.md`;
+    const candidateRef = manager.targetRef ?? review?.targetRef ?? { kind: 'document', ref: expectedSpecRef };
+    const evidenceRefs = records.map(runtimeRefForStageArtifact);
+    const blockingItem = manager.recommendation === 'request_clarification' || review?.verdict === 'blocked'
+        ? [{ id: 'blocking-ambiguity', kind: 'blocking_ambiguity', summary: 'Spec closure needs clarification before plan handoff.', refs: evidenceRefs }]
+        : [];
+    const handoffItem = manager.recommendation === 'close_stage'
+        ? [{ id: 'accepted-spec', kind: 'handoff_proposal', summary: 'Spec manager requested plan handoff for the reviewed canonical spec.', refs: [candidateRef, ...evidenceRefs] }]
+        : [];
+    const acceptedItems = [...blockingItem, ...handoffItem];
+    const candidate = {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        candidateId: stableId('spec-document-candidate', profile.scope, manager.ref, manager.hash, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        producedBy: SPEC_STAGE_DRAFTER_AGENT,
+        inputRefs: profile.inputRefs.length > 0 ? profile.inputRefs : evidenceRefs,
+        evidenceRefs,
+        acceptedItems,
+        generatedAt
+    };
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        closureRequestId: stableId('spec-closure-request', profile.scope, manager.ref, manager.hash, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        submittedBy: SPEC_STAGE_MANAGER,
+        workOrderRef: workOrder ? { kind: 'projection', ref: `spec-work-order:${workOrder.workOrderId}` } : { kind: 'projection', ref: `spec-work-order:${specCollaborationScopeKey(profile.scope)}` },
+        coordinationRef: runtimeRefForStageArtifact(manager),
+        candidateRef,
+        reviewRefs: review ? [runtimeRefForStageArtifact(review)] : [],
+        capabilityFindingRefs: [],
+        evidenceRefs,
+        candidate,
+        reviewResults: review ? [registeredReviewResult(profile, review, generatedAt)] : [],
+        capabilityFindings: [],
+        unresolvedAmbiguityIds: blockingItem.map((item) => item.id),
+        authorityAttempts: [],
+        managerRecommendation: manager.recommendation ?? 'blocked',
+        generatedAt
+    };
+}
+function registeredReviewResult(profile, review, generatedAt) {
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        reviewId: review.artifactId,
+        stage: 'spec',
+        scope: profile.scope,
+        reviewer: SPEC_STAGE_REVIEW_AGENT,
+        candidateRef: review.targetRef,
+        verdict: review.verdict ?? 'blocked',
+        findings: [`findingCount=${review.findingCount ?? 0}`, `blockingCount=${review.blockingCount ?? 0}`],
+        evidenceRefs: [runtimeRefForStageArtifact(review)],
+        generatedAt
+    };
+}
+function findReviewForManager(records, manager) {
+    if (manager.reviewRef) {
+        return records.find((record) => record.kind === 'spec_review' && record.ref === manager.reviewRef?.ref && record.hash === manager.reviewHash) ?? null;
+    }
+    return latestStageArtifact(records, 'spec_review');
+}
+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}.`]
+        };
+    }
+    if (!input.validatedCollaborationContract) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready spec closure must be backed by a validated spec StageCollaborationContract.', 'Ask spec-manager to write .sdd/runs/<branch>/spec/spec-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const expectedRef = `specs/${input.partition}/spec.md`;
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready spec closure must be backed by a registered spec-manager closure artifact.', 'Ask spec-manager to write .sdd/runs/<branch>/spec/spec-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Spec-manager recommendation ${manager.recommendation ?? 'none'} cannot accept spec for plan handoff.`, 'Ask spec-manager to submit a close_stage recommendation after review blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'spec_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedSpecArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Spec-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh spec-manager closure artifact so reviewRef/reviewHash point at the registered review artifact.');
+    }
+    const approvedReview = findReviewForManager(input.registeredArtifacts, manager);
+    if (!approvedReview) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'missing_required_review', 'Ready spec closure must include a registered spec-reviewer artifact referenced by spec-manager.', 'Ask spec-reviewer to write .sdd/runs/<branch>/spec/spec-review-vN.md and ask spec-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'missing_required_review', `Spec-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept spec.`, 'Resolve review blockers and register an approved spec-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'document' || manager.targetRef.ref !== expectedRef || approvedReview.targetRef?.kind !== 'document' || approvedReview.targetRef.ref !== expectedRef) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready spec closure must reference reviewed ${expectedRef} as the canonical spec document.`, 'Refresh review and manager artifacts so targetRef points at specs/<branch>/spec.md.');
+    }
+    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', `Reviewed canonical spec artifact is missing at ${expectedRef}.`, 'Produce and review 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 reviewed semantic spec content before closure.');
+    }
+    const specHash = hashDocumentContent(content);
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== specHash);
+    if (mismatchedHash) {
+        return rejectedSpecArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed spec hash mismatch for ${expectedRef}: expected ${mismatchedHash}, actual ${specHash}.`, 'Refresh spec-reviewer and spec-manager artifacts with the current spec.md hash before closure.');
+    }
+    return {
+        acceptedSpecRef: { kind: 'document', ref: expectedRef, hash: specHash },
+        specAcceptanceStatus: 'accepted',
+        specHash,
+        specContractHash: hashSemanticDocument(content),
+        reasons: [`Runtime accepted reviewed canonical spec artifact ${expectedRef}.`]
+    };
+}
+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');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready plan closure must be backed by a validated plan StageCollaborationContract.', 'Ask plan-manager to write .sdd/runs/<branch>/plan/plan-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    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 manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready plan closure must be backed by a registered plan-manager closure artifact.', 'Ask plan-manager to write .sdd/runs/<branch>/plan/plan-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedPlanArtifact('not_accepted_rejected', 'invalid_proposal', `Plan-manager recommendation ${manager.recommendation ?? 'none'} cannot accept plan for tasks handoff.`, 'Ask plan-manager to submit a close_stage recommendation after review blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'plan_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedPlanArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Plan-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh plan-manager closure artifact so reviewRef/reviewHash point at the registered review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'plan_review');
+    if (!approvedReview) {
+        return rejectedPlanArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready plan closure must include a registered plan-reviewer artifact referenced by plan-manager.', 'Ask plan-reviewer to write .sdd/runs/<branch>/plan/plan-review-vN.md and ask plan-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedPlanArtifact('not_accepted_missing_review', 'missing_required_review', `Plan-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept plan.`, 'Resolve review blockers and register an approved plan-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'document' || manager.targetRef.ref !== expectedRef || approvedReview.targetRef?.kind !== 'document' || approvedReview.targetRef.ref !== expectedRef) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready plan closure must reference reviewed ${expectedRef} as the canonical plan document.`, 'Refresh review and manager artifacts so targetRef points at 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', `Reviewed canonical plan artifact is missing at ${expectedRef}.`, 'Produce and review 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 reviewed semantic plan content before closure.');
+    }
+    const planHash = hashDocumentContent(content);
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== planHash);
+    if (mismatchedHash) {
+        return rejectedPlanArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed plan hash mismatch for ${expectedRef}: expected ${mismatchedHash}, actual ${planHash}.`, 'Refresh plan-reviewer and plan-manager artifacts 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');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready tasks closure must be backed by a validated tasks StageCollaborationContract.', 'Ask tasks-manager to write .sdd/runs/<branch>/tasks/tasks-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    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 manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready tasks closure must be backed by a registered tasks-manager closure artifact.', 'Ask tasks-manager to write .sdd/runs/<branch>/tasks/tasks-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedTasksArtifact('not_accepted_rejected', 'invalid_proposal', `Tasks-manager recommendation ${manager.recommendation ?? 'none'} cannot accept tasks for verifies handoff.`, 'Ask tasks-manager to submit a close_stage recommendation after review blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'tasks_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedTasksArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Tasks-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh tasks-manager closure artifact so reviewRef/reviewHash point at the registered review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'tasks_review');
+    if (!approvedReview) {
+        return rejectedTasksArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready tasks closure must include a registered tasks-reviewer artifact referenced by tasks-manager.', 'Ask tasks-reviewer to write .sdd/runs/<branch>/tasks/tasks-review-vN.md and ask tasks-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedTasksArtifact('not_accepted_missing_review', 'missing_required_review', `Tasks-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept tasks.`, 'Resolve review blockers and register an approved tasks-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'document' || manager.targetRef.ref !== expectedRef || approvedReview.targetRef?.kind !== 'document' || approvedReview.targetRef.ref !== expectedRef) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready tasks closure must reference reviewed ${expectedRef} as the canonical tasks document.`, 'Refresh review and manager artifacts so targetRef points at specs/<branch>/tasks.md.');
+    }
+    const tasksPath = path.join(projectRoot, 'specs', input.partition, 'tasks.md');
+    const content = await readOptionalText(tasksPath);
+    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 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);
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== tasksHash);
+    if (mismatchedHash) {
+        return rejectedTasksArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed tasks hash mismatch for ${expectedRef}: expected ${mismatchedHash}, actual ${tasksHash}.`, 'Refresh tasks-reviewer and tasks-manager artifacts 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 validateAcceptedVerifyArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedVerifyRef: null,
+            verifyAcceptanceStatus: 'not_required_noop',
+            verifyHash: null,
+            verifyContractHash: null,
+            reasons: ['Verify artifact was not required by this lifecycle decision.']
+        };
+    }
+    if (input.blocked) {
+        return rejectedVerifyArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks verifies closure.', 'Resolve lifecycle blockers before requesting verifies-stage closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedVerifyArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready verifies closure must be backed by a validated verifies StageCollaborationContract.', 'Ask verifies-manager to write .sdd/runs/<branch>/verifies/verifies-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const upstreamIssue = await validateAcceptedTasksHandoff(projectRoot, input.partition, input.acceptedTasksHandoff);
+    if (upstreamIssue) {
+        return rejectedVerifyArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh tasks-stage closure and provide a fresh tasks -> verifies handoff before verifies closure.');
+    }
+    const expectedRef = `specs/${input.partition}/verify.md`;
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedVerifyArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready verifies closure must be backed by a registered verifies-manager closure artifact.', 'Ask verifies-manager to write .sdd/runs/<branch>/verifies/verifies-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedVerifyArtifact('not_accepted_rejected', 'invalid_proposal', `Verifies-manager recommendation ${manager.recommendation ?? 'none'} cannot accept verify contract for do handoff.`, 'Ask verifies-manager to submit a close_stage recommendation after review blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'verifies_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedVerifyArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Verifies-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh verifies-manager closure artifact so reviewRef/reviewHash point at the registered review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'verifies_review');
+    if (!approvedReview) {
+        return rejectedVerifyArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready verifies closure must include a registered verifies-reviewer artifact referenced by verifies-manager.', 'Ask verifies-reviewer to write .sdd/runs/<branch>/verifies/verifies-review-vN.md and ask verifies-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedVerifyArtifact('not_accepted_missing_review', 'missing_required_review', `Verifies-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept verify contract.`, 'Resolve review blockers and register an approved verifies-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'document' || manager.targetRef.ref !== expectedRef || approvedReview.targetRef?.kind !== 'document' || approvedReview.targetRef.ref !== expectedRef) {
+        return rejectedVerifyArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready verifies closure must reference reviewed ${expectedRef} as the canonical verify contract.`, 'Refresh review and manager artifacts so targetRef points at specs/<branch>/verify.md.');
+    }
+    const verifyPath = path.join(projectRoot, 'specs', input.partition, 'verify.md');
+    const content = await readOptionalText(verifyPath);
+    if (content === null) {
+        return rejectedVerifyArtifact('not_accepted_missing_verify', 'missing_refs', `Reviewed canonical verify artifact is missing at ${expectedRef}.`, 'Produce and review specs/<branch>/verify.md before requesting runtime closure.');
+    }
+    if (isManagedStarterSpec(content)) {
+        return rejectedVerifyArtifact('not_accepted_starter_verify', 'invalid_proposal', `Canonical verify artifact at ${expectedRef} is still the managed starter document.`, 'Replace starter verify.md with a reviewed verification contract before closure.');
+    }
+    const verifyHash = hashDocumentContent(content);
+    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const mismatchedHash = expectedHashes.find((hash) => hash !== verifyHash);
+    if (mismatchedHash) {
+        return rejectedVerifyArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed verify hash mismatch for ${expectedRef}: expected ${mismatchedHash}, actual ${verifyHash}.`, 'Refresh verifies-reviewer and verifies-manager artifacts with the current verify.md hash before closure.');
+    }
+    const inspection = await inspectVerifyContract(projectRoot, { branch: input.partition, branchSource: 'cli_option' });
+    const blockingIssue = inspection.issues.find((issue) => issue.level === 'FAIL')
+        ?? inspection.issues.find((issue) => issue.field === 'tasks');
+    if (blockingIssue) {
+        return rejectedVerifyArtifact('not_accepted_incomplete_coverage', 'invalid_proposal', blockingIssue.message, blockingIssue.action);
+    }
+    return {
+        acceptedVerifyRef: { kind: 'document', ref: expectedRef, hash: verifyHash },
+        verifyAcceptanceStatus: 'accepted',
+        verifyHash,
+        verifyContractHash: hashSemanticDocument(content),
+        reasons: [`Runtime accepted reviewed canonical verify artifact ${expectedRef}.`]
+    };
+}
+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 do closure.', 'Resolve lifecycle blockers before requesting do-stage closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready do closure must be backed by a validated do StageCollaborationContract.', 'Ask do-manager to write .sdd/runs/<branch>/do/do-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const upstreamIssue = await validateAcceptedVerifyHandoff(projectRoot, input.partition, input.acceptedVerifyHandoff);
+    if (upstreamIssue) {
+        return rejectedDoArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh verifies-stage closure and provide a fresh verifies -> do handoff before do closure.');
+    }
+    const implementation = latestStageArtifact(input.registeredArtifacts, 'implementation_evidence');
+    if (!implementation) {
+        return rejectedDoArtifact('not_accepted_missing_implementation', 'missing_refs', 'Ready do closure must be backed by a registered implementer evidence artifact.', 'Ask implementer to write .sdd/runs/<branch>/do/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 do closure must be backed by a registered do-manager closure artifact.', 'Ask do-manager to write .sdd/runs/<branch>/do/do-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedDoArtifact('not_accepted_rejected', 'invalid_proposal', `Do-manager recommendation ${manager.recommendation ?? 'none'} cannot accept implementation state for test handoff.`, 'Ask do-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', `Do-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh do-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 do closure must include a registered code-reviewer artifact referenced by do-manager.', 'Ask code-reviewer to write .sdd/runs/<branch>/do/code-review-vN.md and ask do-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 do closure must reference reviewed ${implementation.ref} as the implementation evidence artifact.`, 'Refresh code-reviewer and do-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 do-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 do-stage 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 do-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 test closure.', 'Resolve lifecycle blockers before requesting test-stage closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready test closure must be backed by a validated test StageCollaborationContract.', 'Ask test-manager to write .sdd/runs/<branch>/test/test-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 do-stage closure and provide a fresh do -> test handoff before test closure.');
+    }
+    const execution = latestStageArtifact(input.registeredArtifacts, 'test_execution');
+    if (!execution) {
+        return rejectedTestArtifact('not_accepted_missing_execution', 'missing_refs', 'Ready test closure must be backed by a registered test-runner execution artifact.', 'Ask test-runner to write .sdd/runs/<branch>/test/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 test closure must be backed by a registered validator evidence artifact.', 'Ask validator to write .sdd/runs/<branch>/test/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', `Test execution ${execution.ref} status ${String(executionStatus)} with exitCode ${String(executionExitCode)} cannot close test stage.`, 'Rerun failing test commands and register passing test 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 test 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 test 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 test stage.`, '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 test closure.');
+    }
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready test closure must be backed by a registered test-manager closure artifact.', 'Ask test-manager to write .sdd/runs/<branch>/test/test-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedTestArtifact('not_accepted_rejected', 'invalid_proposal', `Test-manager recommendation ${manager.recommendation ?? 'none'} cannot accept test evidence for goal-verify handoff.`, 'Ask test-manager to submit a close_stage recommendation after test 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', `Test-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh test-manager closure artifact so reviewRef/reviewHash point at the registered test review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'test_review');
+    if (!approvedReview) {
+        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready test closure must include a registered test-reviewer artifact referenced by test-manager.', 'Ask test-reviewer to write .sdd/runs/<branch>/test/test-review-vN.md and ask test-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', `Test-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept test evidence.`, 'Resolve review blockers and register an approved test-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 test closure must reference reviewed ${validation.ref} as the validation evidence artifact.`, 'Refresh test-reviewer and test-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 test-reviewer and test-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 test validation evidence ${validation.ref}.`]
+    };
+}
+async function validateAcceptedGoalVerifyArtifact(projectRoot, input) {
+    if (!input.required) {
+        return {
+            acceptedGoalVerificationRef: null,
+            goalVerifyAcceptanceStatus: 'not_required_noop',
+            goalVerificationHash: null,
+            reasons: ['Goal verification was not required by this lifecycle decision.'],
+            truthAlignment: null
+        };
+    }
+    if (input.blocked) {
+        return rejectedGoalVerifyArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks goal-verify closure.', 'Resolve lifecycle blockers before requesting goal-verify-stage closure.', 'runtime-blocked');
+    }
+    if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
+        return rejectedGoalVerifyArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready goal-verify closure must be backed by a validated goal-verify StageCollaborationContract.', 'Ask goal-verify-manager to write .sdd/runs/<branch>/goal-verify/goal-verify-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
+    }
+    const upstreamIssue = await validateAcceptedTestHandoff(projectRoot, input.partition, input.acceptedTestHandoff);
+    if (upstreamIssue) {
+        return rejectedGoalVerifyArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh test-stage closure and provide a fresh test -> goal-verify handoff before goal-verify closure.');
+    }
+    const verification = latestStageArtifact(input.registeredArtifacts, 'goal_verification');
+    if (!verification) {
+        return rejectedGoalVerifyArtifact('not_accepted_missing_verification', 'missing_refs', 'Ready goal-verify closure must be backed by a registered goal-validator verification artifact.', 'Ask goal-validator to write .sdd/runs/<branch>/goal-verify/goal-verification-vN.md and register it before closure.');
+    }
+    if (verification.frontmatter.status !== 'passed') {
+        return rejectedGoalVerifyArtifact('not_accepted_failed_verification', 'invalid_proposal', `Goal verification ${verification.ref} status ${String(verification.frontmatter.status)} cannot close goal-verify stage.`, 'Resolve goal verification failures and register passing goal verification evidence before closure.');
+    }
+    if (verification.frontmatter.coverageComplete !== true) {
+        return rejectedGoalVerifyArtifact('not_accepted_incomplete_coverage', 'invalid_proposal', `Goal verification ${verification.ref} must declare coverageComplete: true.`, 'Complete acceptance coverage before requesting goal-verify closure.');
+    }
+    const durableGapCount = verification.frontmatter.durableGapCount;
+    const openGapCount = verification.frontmatter.openGapCount;
+    if ((typeof durableGapCount === 'number' && durableGapCount > 0) || (typeof openGapCount === 'number' && openGapCount > 0)) {
+        return rejectedGoalVerifyArtifact('not_accepted_open_gap', 'invalid_proposal', `Goal verification ${verification.ref} still declares open durable gaps.`, 'Resolve durable gaps before requesting goal-verify closure.');
+    }
+    const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
+    if (!manager) {
+        return rejectedGoalVerifyArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready goal-verify closure must be backed by a registered goal-verify-manager closure artifact.', 'Ask goal-verify-manager to write .sdd/runs/<branch>/goal-verify/goal-verify-manager-vN.md and register it before closure.');
+    }
+    if (manager.recommendation !== 'close_stage') {
+        return rejectedGoalVerifyArtifact('not_accepted_rejected', 'invalid_proposal', `Goal-verify-manager recommendation ${manager.recommendation ?? 'none'} cannot accept goal verification for truthAlignment and ship readiness.`, 'Ask goal-verify-manager to submit a close_stage recommendation after goal verification blockers are resolved.');
+    }
+    const reviewByRef = manager.reviewRef
+        ? input.registeredArtifacts.find((record) => record.kind === 'goal_review' && record.ref === manager.reviewRef?.ref) ?? null
+        : null;
+    if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
+        return rejectedGoalVerifyArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Goal-verify-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh goal-verify-manager closure artifact so reviewRef/reviewHash point at the registered goal review artifact.');
+    }
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'goal_review');
+    if (!approvedReview) {
+        return rejectedGoalVerifyArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready goal-verify closure must include a registered goal-reviewer artifact referenced by goal-verify-manager.', 'Ask goal-reviewer to write .sdd/runs/<branch>/goal-verify/goal-review-vN.md and ask goal-verify-manager to reference that review hash.');
+    }
+    if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
+        return rejectedGoalVerifyArtifact('not_accepted_missing_review', 'missing_required_review', `Goal-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept goal verification.`, 'Resolve review blockers and register an approved goal-reviewer artifact before closure.');
+    }
+    if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== verification.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== verification.ref) {
+        return rejectedGoalVerifyArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready goal-verify closure must reference reviewed ${verification.ref} as the goal verification artifact.`, 'Refresh goal-reviewer and goal-verify-manager artifacts so targetRef points at the goal verification 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 rejectedGoalVerifyArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed goal verification hash mismatch for ${verification.ref}: expected ${mismatchedHash}, actual ${verification.hash}.`, 'Refresh goal-reviewer and goal-verify-manager artifacts with the current goal verification hash before closure.');
+    }
+    return {
+        acceptedGoalVerificationRef: { kind: 'artifact', ref: verification.ref, hash: verification.hash },
+        goalVerifyAcceptanceStatus: 'accepted',
+        goalVerificationHash: verification.hash,
+        reasons: [`Runtime accepted reviewed goal verification evidence ${verification.ref}.`],
+        truthAlignment: parseGoalVerifyTruthAlignment(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 goal-verify 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 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 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 validateAcceptedTasksHandoff(projectRoot, partition, handoff) {
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (!handoff) {
+        return 'Verifies closure requires a recorded tasks -> verifies handoff.';
+    }
+    if (handoff.fromStage !== 'tasks' || handoff.toStage !== 'verifies' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Verifies closure requires a non-blocking tasks -> verifies 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 -> verifies 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 validateAcceptedVerifyHandoff(projectRoot, partition, handoff) {
+    const expectedVerifyRef = `specs/${partition}/verify.md`;
+    if (!handoff) {
+        return 'Do closure requires a recorded verifies -> do handoff.';
+    }
+    if (handoff.fromStage !== 'verifies' || handoff.toStage !== 'do' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Do closure requires a non-blocking verifies -> do handoff.';
+    }
+    const acceptedVerifyRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedVerifyRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedVerifyRef);
+    if (!acceptedVerifyRef?.hash) {
+        return `Verifies -> do handoff must carry accepted ${expectedVerifyRef} with a content hash.`;
+    }
+    const verifyContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'verify.md'));
+    if (verifyContent === null) {
+        return `Accepted upstream verify artifact is missing at ${expectedVerifyRef}.`;
+    }
+    const currentVerifyHash = hashDocumentContent(verifyContent);
+    if (acceptedVerifyRef.hash !== currentVerifyHash) {
+        return `Accepted upstream verify hash is stale for ${expectedVerifyRef}: expected ${acceptedVerifyRef.hash}, actual ${currentVerifyHash}.`;
+    }
+    return null;
+}
+async function validateAcceptedDoHandoff(projectRoot, partition, handoff) {
+    if (!handoff) {
+        return 'Test closure requires a recorded do -> test handoff.';
+    }
+    if (handoff.fromStage !== 'do' || handoff.toStage !== 'test' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Test closure requires a non-blocking do -> test handoff.';
+    }
+    const acceptedImplementationRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/do/implementation-`))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/do/implementation-`));
+    if (!acceptedImplementationRef?.hash) {
+        return `Do -> test handoff must carry accepted .sdd/runs/${partition}/do/implementation-vN.md with a content hash.`;
+    }
+    return validateHandoffInputHashes(projectRoot, handoff.requiredInputRefs);
+}
+async function validateAcceptedTestHandoff(projectRoot, partition, handoff) {
+    if (!handoff) {
+        return 'Goal-verify closure requires a recorded test -> goal-verify handoff.';
+    }
+    if (handoff.fromStage !== 'test' || handoff.toStage !== 'goal-verify' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Goal-verify closure requires a non-blocking test -> goal-verify handoff.';
+    }
+    const acceptedTestRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/test/validation-`))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/test/validation-`));
+    if (!acceptedTestRef?.hash) {
+        return `Test -> goal-verify handoff must carry accepted .sdd/runs/${partition}/test/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 rejectedVerifyArtifact(verifyAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedVerifyRef: null,
+        verifyAcceptanceStatus,
+        verifyHash: null,
+        verifyContractHash: null,
+        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 rejectedGoalVerifyArtifact(goalVerifyAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+    return {
+        acceptedGoalVerificationRef: null,
+        goalVerifyAcceptanceStatus,
+        goalVerificationHash: null,
+        reasons: [explanation],
+        truthAlignment: null,
+        rejectionIssue: {
+            reasonCode,
+            explanation,
+            requiredNextAction,
+            fallbackRoute
+        }
+    };
+}
+function parseGoalVerifyTruthAlignment(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', 'verifies', 'do', 'test', 'goal-verify', '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 goal-verify.';
+    }
+    if (truthAlignment.contract !== TRUTH_ALIGNMENT_CONTRACT || truthAlignment.sourceStage !== 'goal-verify') {
+        return 'Ship closure requires a valid goal-verify 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 acceptedGoalVerifyRef = truthAlignment.acceptedRealityRefs.find((ref) => ref.kind === 'artifact' && ref.ref.startsWith(`.sdd/runs/${partition}/goal-verify/goal-verification-`));
+    if (!acceptedGoalVerifyRef?.hash) {
+        return `TruthAlignment must carry accepted .sdd/runs/${partition}/goal-verify/goal-verification-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 do-stage 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_verifies'
+        ? '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-verifies-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'tasks',
+        toStage: 'verifies',
+        fromAgent: TASKS_STAGE_MANAGER,
+        toAgent: 'verifies-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 buildVerifiesClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_do'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-verifies', scope, runId, input.generatedAt),
+        scope,
+        stage: 'verifies',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Verifies adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildVerifiesWorkflowHandoff(scope, decision, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: stableId('verifies-do-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'verifies',
+        toStage: 'do',
+        fromAgent: VERIFIES_STAGE_MANAGER,
+        toAgent: 'do-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 buildDoClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_test'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-do', scope, runId, input.generatedAt),
+        scope,
+        stage: 'do',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Do adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildDoWorkflowHandoff(scope, decision, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: stableId('do-test-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'do',
+        toStage: 'test',
+        fromAgent: DO_STAGE_MANAGER,
+        toAgent: 'test-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 buildTestClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_goal_verify'
+        ? 'completed'
+        : health === 'no-op'
+            ? 'skipped'
+            : 'blocked';
+    return {
+        contract: STAGE_RUN_CONTRACT_VERSION,
+        id: stableId('stage-run-test', scope, runId, input.generatedAt),
+        scope,
+        stage: 'test',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Test adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: input.generatedAt
+    };
+}
+function buildTestWorkflowHandoff(scope, decision, input) {
+    return {
+        contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+        id: stableId('test-goal-verify-handoff', scope, 'closure', input.generatedAt),
+        scope,
+        fromStage: 'test',
+        toStage: 'goal-verify',
+        fromAgent: TEST_STAGE_MANAGER,
+        toAgent: 'goal-verify-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 buildGoalVerifyClosureStageRun(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-goal-verify', scope, runId, input.generatedAt),
+        scope,
+        stage: 'goal-verify',
+        ownerAgent: workOrder?.stageManager ?? 'runtime',
+        coMainAgents: workOrder?.agentTeam ?? [],
+        status,
+        inputRefs: input.inputRefs,
+        outputRefs: input.outputRefs,
+        decisionRefs: input.decisionRefs,
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Goal-verify adjudication health is ${health}.`] : [],
+        createdAt: input.generatedAt,
+        updatedAt: 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);
+}
+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 verifiesAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${VERIFIES_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${verifiesCollaborationScopeKey(scope)}`
+    };
+}
+function doAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${doCollaborationScopeKey(scope)}`
+    };
+}
+function testAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${TEST_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${testCollaborationScopeKey(scope)}`
+    };
+}
+function goalVerifyAdjudicationProjectionRef(scope) {
+    return {
+        kind: 'projection',
+        ref: `${GOAL_VERIFY_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${goalVerifyCollaborationScopeKey(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 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 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