sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -7,18 +7,18 @@ import { createRun } from './run-state/run-state.js';
 import { normalizePortablePath } from './path-safety.js';
 import { getBranchStageEvidenceDir, normalizeBranchStageEvidenceRef, toBranchStageEvidenceRef } from './runtime-paths.js';
 import { resolveSddContext } from './sdd-docs/context.js';
+import { evaluatePlanArtifactDepth, evaluateSpecArtifactDepth, formatArtifactDepthBlockingIssues } from './sdd-docs/artifact-depth.js';
 import { hashDocumentContent, hashSemanticDocument, hashTasksContract } from './sdd-docs/document-hashes.js';
 import { parseSddTasksMarkdown } from './sdd-docs/task-parser.js';
+import { EXECUTION_LANE_PROJECTION_TYPE, TASK_DEPENDENCY_GRAPH_PROJECTION_TYPE, TASK_UNIT_PROJECTION_TYPE, executionLaneScopeKey, readTaskDependencyGraphProjection, taskDependencyGraphScopeKey } from './task-execution-contract.js';
 import { readWorkflowHandoffProjection, recordStageRunProjection, recordWorkflowHandoffProjection, STAGE_RUN_PROJECTION_TYPE, stageRunScopeKey, WORKFLOW_HANDOFF_PROJECTION_TYPE, workflowHandoffScopeKey } from './stage-runtime/runtime.js';
 import { listRuntimeProjections, recordRuntimeArtifactPayload, recordRuntimeProjectionEnvelope, recordRuntimeStageArtifact, recordRuntimeStageCollaborationContract, runtimeScopedId } from './storage/runtime-store.js';
 import { readMarkdownArtifact, validateStageArtifactFrontmatter } from './stage-artifacts.js';
 import { readStageCollaborationContract, validateStageCollaborationContractFrontmatter } from './stage-collaboration-contracts.js';
-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_AGENT_TEAM = [SPEC_STAGE_SCOUT_AGENT, SPEC_STAGE_REVIEW_AGENT];
 export const SPEC_STAGE_REQUIRED_CAPABILITIES = ['norm_discovery', 'uncertainty_resolution'];
 export const SPEC_STAGE_OPTIONAL_CAPABILITIES = ['context_curation', 'solution-design', 'frontend-engineering', 'security-engineering', 'ui-ux-product-design'];
 export const SPEC_STAGE_MATERIAL_PACKS = ['project-norms', 'uncertainty-map', 'baseline-solution-design', 'baseline-frontend-engineering', 'baseline-security-engineering', 'baseline-ui-ux-product-design'];
@@ -26,32 +26,26 @@ export const STAGE_COLLABORATION_RUNTIME_PRODUCER_VERSION = 'phase9.1-stage-coll
 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 PLAN_STAGE_SCOUT_AGENT = 'plan-scout';
+export const PLAN_STAGE_REVIEW_AGENT = 'plan-review-agent';
+export const PLAN_STAGE_AGENT_TEAM = [PLAN_STAGE_SCOUT_AGENT, PLAN_STAGE_REVIEW_AGENT];
+export const PLAN_SCOUT_DOMAINS = ['architecture-runtime', 'backend-api', 'frontend-ui', 'database-migration', 'security', 'performance', 'testing-validation'];
+export const PLAN_STAGE_REQUIRED_CAPABILITIES = ['plan-strategy', 'plan-pressure-review'];
+export const PLAN_STAGE_OPTIONAL_CAPABILITIES = [...PLAN_SCOUT_DOMAINS];
+export const PLAN_STAGE_MATERIAL_PACKS = ['project-norms', 'plan-section-rubric', 'plan-scout-domain-packs'];
 export const TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_3_tasks_collaboration_adjudication';
 export const TASKS_STAGE_MANAGER = 'tasks-manager';
-export const TASKS_STAGE_DRAFTER_AGENT = 'tasks-drafter';
-export const TASKS_STAGE_REVIEW_AGENT = 'tasks-reviewer';
+export const TASKS_STAGE_REVIEW_AGENT = 'task-review-agent';
 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 EXECUTE_IMPLEMENTER_AGENT = 'implementer';
+export const EXECUTE_CODE_REVIEW_AGENT = 'code-reviewer';
+export const EXECUTE_DEBUGGER_AGENT = 'debugger';
+export const EXECUTE_TEST_RUNNER_AGENT = 'test-runner';
+export const EXECUTE_VALIDATOR_AGENT = 'validator';
+export const EXECUTE_TEST_REVIEW_AGENT = 'test-reviewer';
+export const EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase10_execute_collaboration_adjudication';
+export const EXECUTE_EVIDENCE_JUDGMENT_VALIDATOR_AGENT = 'evidence-validator';
+export const EXECUTE_EVIDENCE_JUDGMENT_REVIEW_AGENT = 'evidence-reviewer';
 export const TRUTH_ALIGNMENT_PROJECTION_TYPE = 'phase9_12_truth_alignment';
 export const TRUTH_ALIGNMENT_CONTRACT = 'sdd-truth-alignment-v1';
 export const SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = 'phase9_9_ship_collaboration_adjudication';
@@ -60,7 +54,7 @@ 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'];
+const TRUTH_ALIGNMENT_OWNER_STAGES = ['spec', 'plan', 'tasks', 'execute', 'ship'];
 export function deriveSpecCollaborationProfile(decision, generatedAt = new Date().toISOString()) {
     const required = decision.requiredStages.includes('spec');
     const intensity = specIntensity(decision, required);
@@ -92,9 +86,7 @@ export function buildSpecStageWorkOrder(profile, profileRef, generatedAt = new D
         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'],
+        requiredOutputKinds: specRequiredOutputKinds(profile.intensity),
         forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
         stageManager: SPEC_STAGE_MANAGER,
         agentTeam: profile.agentTeam,
@@ -109,7 +101,8 @@ export function buildSpecStageWorkOrder(profile, profileRef, generatedAt = new D
 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()) {
+export function buildPlanStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString(), intensity = 'scout-first') {
+    const collaborationPlan = planCollaborationPlan(intensity);
     return {
         contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
         workOrderId: stableId('plan-work-order', scope),
@@ -117,14 +110,16 @@ export function buildPlanStageWorkOrder(scope, profileRef, inputRefs, generatedA
         scope,
         profileRef,
         authorityCeiling: 'proposal_input',
-        requiredOutputKinds: ['plan_context', 'plan_review', 'manager_closure_request'],
+        requiredOutputKinds: planRequiredOutputKinds(intensity),
         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'],
+        agentTeam: planMemberAgents(intensity),
+        planScoutDomains: planScoutDomains(intensity),
+        requiredCapabilities: planRequiredCapabilities(intensity),
+        optionalCapabilities: planOptionalCapabilities(intensity),
+        materialPackIds: planMaterialPackIds(intensity),
+        collaborationPlan,
         generatedAt
     };
 }
@@ -143,98 +138,32 @@ export function buildTasksStageWorkOrder(scope, profileRef, inputRefs, generated
         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],
+        agentTeam: [TASKS_STAGE_SLICER_AGENT, TASKS_STAGE_REVIEW_AGENT],
         requiredCapabilities: ['task-decomposition', 'acceptance-mapping'],
         optionalCapabilities: ['dependency-analysis', 'parallelization-planning'],
         materialPackIds: ['project-norms', 'baseline-task-slicing', 'baseline-acceptance-mapping'],
         generatedAt
     };
 }
-export function verifiesCollaborationScopeKey(scope) {
-    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'verifies'].join(':');
+export function executeCollaborationScopeKey(scope) {
+    return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', 'execute'].join(':');
 }
-export function buildVerifiesStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
+export function buildExecuteStageWorkOrder(scope, profileRef, inputRefs, generatedAt = new Date().toISOString()) {
     return {
         contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
-        workOrderId: stableId('verifies-work-order', scope),
-        stage: 'verifies',
+        workOrderId: stableId('execute-work-order', scope),
+        stage: 'execute',
         scope,
         profileRef,
         authorityCeiling: 'proposal_input',
-        requiredOutputKinds: ['verifies_context', 'verifies_review', 'manager_closure_request'],
+        requiredOutputKinds: ['implementation_evidence', 'code_review', 'validation_evidence', 'checkpoint_decision', 'evidence_judgment', 'manager_closure_request'],
         forbiddenActions: ['stage_pass', 'risk_decision', 'gate_pass', 'ship_ready', 'truth_alignment_approved'],
         inputRefs,
-        stageManager: 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'],
+        stageManager: 'execute-manager',
+        agentTeam: [EXECUTE_IMPLEMENTER_AGENT, EXECUTE_CODE_REVIEW_AGENT, EXECUTE_DEBUGGER_AGENT, EXECUTE_TEST_RUNNER_AGENT, EXECUTE_VALIDATOR_AGENT, EXECUTE_TEST_REVIEW_AGENT, EXECUTE_EVIDENCE_JUDGMENT_VALIDATOR_AGENT, EXECUTE_EVIDENCE_JUDGMENT_REVIEW_AGENT],
+        requiredCapabilities: ['implementation', 'code-review', 'validation', 'evidence-judgment'],
+        optionalCapabilities: ['debugging', 'checkpoint-review', 'frontend-engineering', 'security-engineering'],
+        materialPackIds: ['accepted-task-contract', 'execute-lane-contract', 'validation-contract', 'checkpoint-policy', 'evidence-judgment-policy'],
         generatedAt
     };
 }
@@ -242,11 +171,11 @@ 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));
+    const acceptedRealityRefs = uniqueRuntimeRefs([input.acceptedEvidenceJudgmentRef, ...input.artifactRefs].filter((ref) => ref !== null));
     return {
         contract: TRUTH_ALIGNMENT_CONTRACT,
         branch: scope.branch,
-        sourceStage: 'goal-verify',
+        sourceStage: 'execute',
         declaredTruthRefs: uniqueRuntimeRefs(input.declaredTruthRefs),
         acceptedRealityRefs,
         status: input.status,
@@ -316,46 +245,13 @@ export async function recordTasksCollaborationAdjudicationProjection(projectRoot
         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) {
+export async function recordExecuteCollaborationAdjudicationProjection(projectRoot, result) {
     return recordRuntimeProjectionEnvelope(projectRoot, {
-        projectionType: DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
-        scopeKey: doCollaborationScopeKey(result.scope),
+        projectionType: EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE,
+        scopeKey: executeCollaborationScopeKey(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',
+        producer: 'phase10-execute-stage-collaboration-runtime',
+        producerVersion: 'phase10-execute-stage-collaboration-runtime-v1',
         generatedAt: result.createdAt,
         payload: result
     });
@@ -406,13 +302,15 @@ export async function reconcileSpecCollaborationClosure(projectRoot, input) {
     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 registeredCollaborationContracts = input.collaborationContractRefs && input.collaborationContractRefs.length > 0
+        ? await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'spec', workOrder, input.collaborationContractRefs, generatedAt)
+        : [];
     const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
     const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
     const registeredArtifacts = await registerSpecStageArtifacts(projectRoot, context.rawBranch, profile, input.artifactRefs, run.runId, generatedAt);
     const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
-    const derivedClosure = deriveRegisteredStageClosureRequest(profile, workOrder, registeredArtifacts, context.partition, generatedAt);
-    const closureRequest = input.closureRequest ?? derivedClosure;
+    const outputClosure = await buildOutputCenteredSpecClosureRequest(projectRoot, profile, workOrder, context.partition, input.outputCloseRequest, generatedAt);
+    const closureRequest = input.closureRequest ?? outputClosure;
     const coordination = input.coordination ?? deriveRegisteredSpecManagerCoordination(profile, workOrder, registeredArtifacts, generatedAt);
     const candidate = closureRequest?.candidate ?? null;
     const reviews = closureRequest?.reviewResults ?? [];
@@ -519,10 +417,11 @@ export async function reconcilePlanCollaborationClosure(projectRoot, input) {
     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 registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'plan', null, input.collaborationContractRefs, generatedAt);
     const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
     const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
-    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'plan', input.artifactRefs, Boolean(workOrder), run.runId, generatedAt);
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'plan', input.artifactRefs, false, run.runId, generatedAt);
+    const closureRequest = await buildOutputCenteredPlanClosureRequest(projectRoot, decision.scope, workOrder, context.partition, acceptedSpecHandoffEnvelope?.payload ?? null, input.outputCloseRequest, generatedAt);
     const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
     const lifecycleRiskProjectionRef = {
         kind: 'projection',
@@ -535,7 +434,8 @@ export async function reconcilePlanCollaborationClosure(projectRoot, input) {
         blocked,
         registeredArtifacts,
         registeredCollaborationContracts,
-        acceptedSpecHandoff: acceptedSpecHandoffEnvelope?.payload ?? null
+        acceptedSpecHandoff: acceptedSpecHandoffEnvelope?.payload ?? null,
+        closureRequest,
     });
     const health = planAcceptance.planAcceptanceStatus === 'accepted'
         ? 'ready_for_tasks'
@@ -556,11 +456,14 @@ export async function reconcilePlanCollaborationClosure(projectRoot, input) {
         kind: 'projection',
         ref: `${STAGE_RUN_PROJECTION_TYPE}:${stageRunScopeKey(stageRun.scope, stageRun.stage)}`
     };
+    const acceptedSpecRef = acceptedSpecRefFromHandoff(context.partition, acceptedSpecHandoffEnvelope?.payload ?? null);
+    const handoffOutputRefs = [planAcceptance.acceptedPlanRef].filter((ref) => ref !== null);
+    const handoffRequiredInputRefs = [acceptedSpecRef, planAcceptance.acceptedPlanRef].filter((ref) => ref !== null);
     const handoff = planAcceptance.planAcceptanceStatus === 'accepted'
         ? buildPlanWorkflowHandoff(decision.scope, decision, {
-            outputRefs,
-            requiredInputRefs: planAcceptance.acceptedPlanRef ? [planAcceptance.acceptedPlanRef] : [],
-            evidenceRefs: artifactRefs,
+            outputRefs: handoffOutputRefs,
+            requiredInputRefs: handoffRequiredInputRefs,
+            evidenceRefs: [],
             riskDecisionRef: lifecycleRiskProjectionRef,
             generatedAt
         })
@@ -599,7 +502,7 @@ export async function reconcilePlanCollaborationClosure(projectRoot, input) {
             scope: decision.scope,
             status: health === 'ready_for_tasks' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
             health,
-            acceptedDecisionRefs: outputRefs,
+            acceptedDecisionRefs: [planAcceptance.acceptedPlanRef, adjudicationProjectionRef].filter((ref) => ref !== null),
             advisoryRefs: [],
             capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('context') || ref.ref.includes('capability')),
             blockingReasons: health === 'ready_for_tasks' || health === 'no-op' ? [] : planAcceptance.reasons,
@@ -648,10 +551,11 @@ export async function reconcileTasksCollaborationClosure(projectRoot, input) {
     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 registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'tasks', null, input.collaborationContractRefs, generatedAt);
     const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
     const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
-    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'tasks', input.artifactRefs, Boolean(workOrder), run.runId, generatedAt);
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'tasks', input.artifactRefs, false, run.runId, generatedAt);
+    const closureRequest = await buildOutputCenteredTasksClosureRequest(projectRoot, decision.scope, workOrder, context.partition, acceptedPlanHandoffEnvelope?.payload ?? null, input.outputCloseRequest, generatedAt);
     const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
     const lifecycleRiskProjectionRef = {
         kind: 'projection',
@@ -664,10 +568,11 @@ export async function reconcileTasksCollaborationClosure(projectRoot, input) {
         blocked,
         registeredArtifacts,
         registeredCollaborationContracts,
-        acceptedPlanHandoff: acceptedPlanHandoffEnvelope?.payload ?? null
+        acceptedPlanHandoff: acceptedPlanHandoffEnvelope?.payload ?? null,
+        closureRequest
     });
     const health = tasksAcceptance.tasksAcceptanceStatus === 'accepted'
-        ? 'ready_for_verifies'
+        ? 'ready_for_execute'
         : !tasksRequired
             ? 'no-op'
             : blocked
@@ -726,17 +631,17 @@ export async function reconcileTasksCollaborationClosure(projectRoot, input) {
             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',
+            status: health === 'ready_for_execute' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
             health,
             acceptedDecisionRefs: outputRefs,
             advisoryRefs: [],
             capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('context') || ref.ref.includes('capability')),
-            blockingReasons: health === 'ready_for_verifies' || health === 'no-op' ? [] : tasksAcceptance.reasons,
+            blockingReasons: health === 'ready_for_execute' || 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']),
+        nextActions: buildStageRuntimeNextActions('tasks', decision.scope, generatedAt, health === 'ready_for_execute' ? ['stage_ready', 'handoff_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
         closureRefs,
         createdAt: generatedAt
     };
@@ -758,7 +663,7 @@ export async function reconcileTasksCollaborationClosure(projectRoot, input) {
         acceptedTasksRef: tasksAcceptance.acceptedTasksRef
     };
 }
-export async function reconcileVerifiesCollaborationClosure(projectRoot, input) {
+export async function reconcileExecuteCollaborationClosure(projectRoot, input) {
     const generatedAt = input.generatedAt ?? new Date().toISOString();
     const context = await resolveSddContext(projectRoot, { branch: input.decision.scope.branch, branchSource: 'cli_option' });
     const decision = {
@@ -771,504 +676,122 @@ export async function reconcileVerifiesCollaborationClosure(projectRoot, input)
         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 executeRequired = decision.requiredStages.includes('execute');
+    const blocked = decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' || decision.blockedStages.includes('execute');
+    const acceptedTasksHandoffEnvelope = await readWorkflowHandoffProjection(projectRoot, decision.scope, 'tasks', 'execute');
     const workOrderInputRefs = acceptedTasksHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs;
-    const profileRef = { kind: 'projection', ref: `${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 profileRef = { kind: 'projection', ref: `${EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${executeCollaborationScopeKey(decision.scope)}:profile` };
+    const workOrder = executeRequired && !blocked ? buildExecuteStageWorkOrder(decision.scope, profileRef, workOrderInputRefs, generatedAt) : null;
+    const registeredCollaborationContracts = await registerStageCollaborationContracts(projectRoot, context.rawBranch, 'execute', workOrder, input.collaborationContractRefs, generatedAt);
     const validatedCollaborationContract = latestValidatedStageCollaborationContract(registeredCollaborationContracts);
     const collaborationContractRef = validatedCollaborationContract ? runtimeRefForStageCollaborationContract(validatedCollaborationContract) : null;
-    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'verifies', input.artifactRefs, Boolean(workOrder), run.runId, generatedAt);
+    const registeredArtifacts = await registerBranchStageArtifacts(projectRoot, context.rawBranch, 'execute', input.artifactRefs, Boolean(workOrder), run.runId, generatedAt);
     const artifactRefs = registeredArtifacts.map(runtimeRefForStageArtifact);
     const lifecycleRiskProjectionRef = {
         kind: 'projection',
         ref: `${LIFECYCLE_RISK_DECISION_PROJECTION_TYPE}:${lifecycleRiskDecisionScopeKey(decision.scope)}`
     };
-    const adjudicationProjectionRef = verifiesAdjudicationProjectionRef(decision.scope);
-    const verifyAcceptance = await validateAcceptedVerifyArtifact(projectRoot, {
+    const adjudicationProjectionRef = executeAdjudicationProjectionRef(decision.scope);
+    const executeAcceptance = await validateAcceptedExecuteArtifact(projectRoot, {
         partition: context.partition,
-        required: verifiesRequired,
+        required: executeRequired,
         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
+    const health = executeAcceptance.executeAcceptanceStatus === 'accepted'
+        ? 'ready_for_ship'
+        : !executeRequired
             ? '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
-        })
+    const acceptedEvidenceJudgmentArtifact = latestStageArtifact(registeredArtifacts, 'evidence_judgment');
+    const acceptedEvidenceJudgmentRef = executeAcceptance.executeAcceptanceStatus === 'accepted' && acceptedEvidenceJudgmentArtifact
+        ? { kind: 'artifact', ref: acceptedEvidenceJudgmentArtifact.ref, hash: acceptedEvidenceJudgmentArtifact.hash }
         : 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
+    const truthAlignmentProjection = acceptedEvidenceJudgmentRef
         ? buildTruthAlignmentProjection(decision.scope, {
-            acceptedGoalVerificationRef: goalVerifyAcceptance.acceptedGoalVerificationRef,
-            declaredTruthRefs,
+            acceptedEvidenceJudgmentRef: acceptedEvidenceJudgmentRef,
+            declaredTruthRefs: await collectTruthAlignmentDeclaredTruthRefs(projectRoot, context.rawBranch, acceptedTasksHandoffEnvelope?.payload ?? null),
             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,
+            status: 'aligned',
+            ownerStage: null,
+            semanticImpact: 'none',
+            staleRefs: [],
+            invalidatesStages: [],
+            reasons: ['Accepted execute evidence judgment is structurally aligned with declared upstream truth refs.'],
             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, {
+        ? { kind: 'projection', ref: `${TRUTH_ALIGNMENT_PROJECTION_TYPE}:${truthAlignmentScopeKey({ branch: decision.scope.branch })}` }
+        : null;
+    const outputRefs = [executeAcceptance.acceptedExecuteRef, truthAlignmentProjectionRef, adjudicationProjectionRef, collaborationContractRef, ...executeAcceptance.laneEvidenceRefs, ...artifactRefs].filter((ref) => ref !== null);
+    const stageRun = buildExecuteClosureStageRun(decision.scope, run.runId, workOrder, health, {
         outputRefs,
         decisionRefs: [lifecycleRiskProjectionRef, adjudicationProjectionRef],
-        inputRefs: acceptedTestHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
+        inputRefs: acceptedTasksHandoffEnvelope?.payload.requiredInputRefs ?? decision.inputRefs,
         generatedAt,
-        rejectionReason: goalVerifyAcceptance.rejectionIssue?.explanation ?? null
+        rejectionReason: executeAcceptance.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)
+    const handoff = executeAcceptance.executeAcceptanceStatus === 'accepted'
+        ? buildExecuteWorkflowHandoff(decision.scope, decision, {
+            outputRefs,
+            requiredInputRefs: executeAcceptance.acceptedExecuteRef ? [executeAcceptance.acceptedExecuteRef, ...executeAcceptance.laneEvidenceRefs] : executeAcceptance.laneEvidenceRefs,
+            evidenceRefs: artifactRefs,
+            riskDecisionRef: lifecycleRiskProjectionRef,
+            generatedAt
+        })
+        : null;
+    const workflowHandoffProjectionRef = handoff
+        ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(handoff.scope, handoff.fromStage, handoff.toStage)}` }
+        : undefined;
+    const rejection = executeAcceptance.rejectionIssue
+        ? buildStageRejection('execute', decision.scope, null, executeAcceptance.rejectionIssue.reasonCode, executeAcceptance.rejectionIssue.explanation, executeAcceptance.rejectionIssue.requiredNextAction, executeAcceptance.rejectionIssue.fallbackRoute, generatedAt, true)
         : null;
     const closureRefs = {
         runRef,
-        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,
+        acceptedExecuteRef: executeAcceptance.acceptedExecuteRef,
+        executeAcceptanceStatus: executeAcceptance.executeAcceptanceStatus,
+        acceptedTasksHandoffRef: acceptedTasksHandoffEnvelope ? { kind: 'projection', ref: `${WORKFLOW_HANDOFF_PROJECTION_TYPE}:${workflowHandoffScopeKey(decision.scope, 'tasks', 'execute')}` } : null,
+        truthAlignmentProjectionRef,
+        laneEvidenceRefs: executeAcceptance.laneEvidenceRefs,
         artifactRefs,
         collaborationContractRef,
         lifecycleRiskProjectionRef,
         adjudicationProjectionRef,
         stageRunProjectionRef,
         workflowHandoffProjectionRef,
-        truthAlignmentProjectionRef,
-        reasons: goalVerifyClosureReasons
+        reasons: executeAcceptance.reasons
     };
     const adjudication = {
         contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
-        adjudicationId: stableId('goal-verify-adjudication', decision.scope, health, generatedAt),
-        stage: 'goal-verify',
+        adjudicationId: stableId('execute-adjudication', decision.scope, health, generatedAt),
+        stage: 'execute',
         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',
+            decisionId: stableId('execute-stage-decision', decision.scope, run.runId, generatedAt),
+            stage: 'execute',
             scope: decision.scope,
             status: health === 'ready_for_ship' ? 'completed' : health === 'no-op' ? 'skipped' : health === 'blocked' ? 'blocked' : 'rejected',
             health,
             acceptedDecisionRefs: outputRefs,
             advisoryRefs: [],
-            capabilityRefs: artifactRefs.filter((ref) => ref.ref.includes('goal-verification') || ref.ref.includes('capability')),
-            blockingReasons: health === 'ready_for_ship' || health === 'no-op' ? [] : goalVerifyClosureReasons,
+            capabilityRefs: executeAcceptance.laneEvidenceRefs,
+            blockingReasons: health === 'ready_for_ship' || health === 'no-op' ? [] : executeAcceptance.reasons,
             createdAt: generatedAt
         },
         handoffPacket: handoff,
         rejection,
-        nextActions: buildStageRuntimeNextActions('goal-verify', decision.scope, generatedAt, health === 'ready_for_ship' ? ['stage_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
+        nextActions: buildStageRuntimeNextActions('execute', decision.scope, generatedAt, health === 'ready_for_ship' ? ['stage_ready', 'handoff_ready'] : rejection ? [rejectionReasonToNextActionReason(rejection.reasonCode)] : ['report_only']),
         closureRefs,
         createdAt: generatedAt
     };
@@ -1277,7 +800,10 @@ export async function reconcileGoalVerifyCollaborationClosure(projectRoot, input
     if (truthAlignmentProjection) {
         await recordTruthAlignmentProjection(projectRoot, truthAlignmentProjection);
     }
-    const projection = await recordGoalVerifyCollaborationAdjudicationProjection(projectRoot, adjudication);
+    if (handoff) {
+        await recordWorkflowHandoffProjection(projectRoot, handoff);
+    }
+    const projection = await recordExecuteCollaborationAdjudicationProjection(projectRoot, adjudication);
     return {
         runId: run.runId,
         branch: context.rawBranch,
@@ -1287,7 +813,7 @@ export async function reconcileGoalVerifyCollaborationClosure(projectRoot, input
         artifactRefs,
         registeredArtifacts,
         registeredCollaborationContracts,
-        acceptedGoalVerificationRef: goalVerifyAcceptance.acceptedGoalVerificationRef
+        acceptedExecuteRef: executeAcceptance.acceptedExecuteRef
     };
 }
 export async function reconcileShipCollaborationClosure(projectRoot, input) {
@@ -1413,11 +939,8 @@ export async function reconcileShipCollaborationClosure(projectRoot, input) {
 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: 'tasks', expectedHealth: 'ready_for_execute', projectionType: TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
+    { stage: 'execute', expectedHealth: 'ready_for_ship', projectionType: EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE },
     { stage: 'ship', expectedHealth: 'ship_ready', projectionType: SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE }
 ];
 export async function inspectFullStageChain(projectRoot, branch) {
@@ -1447,14 +970,14 @@ export async function inspectFullStageChain(projectRoot, branch) {
 }
 async function collectTruthAlignmentDeclaredTruthRefs(projectRoot, branch, testHandoff) {
     const projectionTypes = FULL_STAGE_CHAIN
-        .filter((item) => item.stage !== 'goal-verify' && item.stage !== 'ship')
+        .filter((item) => item.stage !== 'ship')
         .map((item) => item.projectionType);
     const projections = await listRuntimeProjections(projectRoot, projectionTypes);
     const envelopes = projections
         .map((projection) => projection.payload)
         .filter((envelope) => envelope?.payload?.scope?.branch === branch);
     const acceptedRefs = FULL_STAGE_CHAIN
-        .filter((item) => item.stage !== 'goal-verify' && item.stage !== 'ship')
+        .filter((item) => item.stage !== 'ship')
         .map((item) => latestStageChainEnvelope(envelopes, item.projectionType, item.stage))
         .map((envelope) => envelope ? acceptedRefFromAdjudication(envelope.payload.stage, envelope.payload) : null)
         .filter((ref) => ref !== null);
@@ -1497,10 +1020,7 @@ function acceptedRefFromAdjudication(stage, adjudication) {
         spec: 'acceptedSpecRef',
         plan: 'acceptedPlanRef',
         tasks: 'acceptedTasksRef',
-        verifies: 'acceptedVerifyRef',
-        do: 'acceptedImplementationRef',
-        test: 'acceptedTestEvidenceRef',
-        'goal-verify': 'acceptedGoalVerificationRef',
+        execute: 'acceptedExecuteRef',
         ship: 'acceptedShipReadinessRef'
     };
     return runtimeRefValue(closureRefs[keyByStage[stage]]) ?? adjudication.stageDecision?.acceptedDecisionRefs[0] ?? null;
@@ -1639,6 +1159,105 @@ export function adjudicateSpecStageClosureRequest(input) {
         nextActions: buildRuntimeNextActions(input.profile, generatedAt, ['stage_ready', 'handoff_ready'])
     });
 }
+function planMemberAgents(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return [PLAN_STAGE_REVIEW_AGENT];
+    }
+    return [PLAN_STAGE_SCOUT_AGENT, PLAN_STAGE_REVIEW_AGENT];
+}
+function planScoutDomains(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked' || intensity === 'lightweight') {
+        return [];
+    }
+    if (intensity === 'scout-first') {
+        return ['architecture-runtime', 'testing-validation'];
+    }
+    return ['architecture-runtime', 'backend-api', 'database-migration', 'security', 'testing-validation'];
+}
+function planRequiredOutputKinds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['plan_review', 'manager_closure_request'];
+    }
+    return ['plan_context', 'plan_review', 'manager_closure_request'];
+}
+function planRequiredCapabilities(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['plan-strategy', 'plan-pressure-review'];
+    }
+    return ['plan-strategy', 'plan-pressure-review', ...planScoutDomains(intensity)];
+}
+function planOptionalCapabilities(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    return PLAN_SCOUT_DOMAINS.filter((domain) => !planScoutDomains(intensity).includes(domain));
+}
+function planMaterialPackIds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['project-norms', 'plan-section-rubric'];
+    }
+    return [...PLAN_STAGE_MATERIAL_PACKS];
+}
+function planCollaborationPlan(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return { topology: 'none', participants: [], maxParallelism: 0, fanIn: 'runtime_adjudication' };
+    }
+    const requiredCapabilities = planRequiredCapabilities(intensity);
+    const optionalCapabilities = planOptionalCapabilities(intensity);
+    const materialPackIds = planMaterialPackIds(intensity);
+    const participants = [
+        { id: PLAN_STAGE_MANAGER, kind: 'agent', role: 'plan-stage-manager', required: true, capabilityDomain: 'plan-strategy', parallelGroup: null },
+        ...planMemberAgents(intensity).map((agent) => ({
+            id: agent,
+            kind: 'subagent',
+            role: planAgentRole(agent),
+            required: agent === PLAN_STAGE_REVIEW_AGENT,
+            capabilityDomain: planAgentCapability(agent),
+            parallelGroup: planAgentParallelGroup(agent)
+        })),
+        ...requiredCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'required-capability-review', required: true, capabilityDomain: capability, parallelGroup: 'capability-review' })),
+        ...optionalCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'optional-capability-review', required: false, capabilityDomain: capability, parallelGroup: 'capability-review' })),
+        ...materialPackIds.map((packId) => ({ id: packId, kind: 'material-pack', role: 'capability-material', required: false, parallelGroup: 'material-pack' }))
+    ];
+    const topology = intensity === 'lightweight' ? 'team-lite' : intensity === 'scout-first' ? 'parallel-research' : 'team-required';
+    return { topology, participants, maxParallelism: topology === 'team-lite' ? 2 : 3, fanIn: 'runtime_adjudication' };
+}
+function planAgentRole(agent) {
+    switch (agent) {
+        case PLAN_STAGE_SCOUT_AGENT:
+            return 'domain-evidence-scout';
+        case PLAN_STAGE_REVIEW_AGENT:
+            return 'plan-pressure-reviewer';
+    }
+}
+function planAgentCapability(agent) {
+    switch (agent) {
+        case PLAN_STAGE_SCOUT_AGENT:
+            return 'architecture-runtime';
+        case PLAN_STAGE_REVIEW_AGENT:
+            return 'plan-pressure-review';
+    }
+}
+function planAgentParallelGroup(agent) {
+    switch (agent) {
+        case PLAN_STAGE_SCOUT_AGENT:
+            return 'domain-scouting';
+        case PLAN_STAGE_REVIEW_AGENT:
+            return 'review';
+    }
+}
 function specIntensity(decision, required) {
     if (decision.profile === 'blocked' || decision.blockedStages.includes('spec')) {
         return 'blocked';
@@ -1674,9 +1293,18 @@ function specMemberAgents(intensity) {
         return [];
     }
     if (intensity === 'lightweight') {
-        return [SPEC_STAGE_DRAFTER_AGENT, SPEC_STAGE_REVIEW_AGENT];
+        return [SPEC_STAGE_REVIEW_AGENT];
+    }
+    return [SPEC_STAGE_SCOUT_AGENT, SPEC_STAGE_REVIEW_AGENT];
+}
+function specRequiredOutputKinds(intensity) {
+    if (intensity === 'noop' || intensity === 'blocked') {
+        return [];
+    }
+    if (intensity === 'lightweight') {
+        return ['spec_review', 'manager_closure_request'];
     }
-    return [SPEC_STAGE_SCOUT_AGENT, SPEC_STAGE_DRAFTER_AGENT, SPEC_STAGE_REVIEW_AGENT];
+    return ['scout_context', 'spec_review', 'manager_closure_request'];
 }
 function specRequiredCapabilities(intensity) {
     if (intensity === 'noop' || intensity === 'blocked') {
@@ -1717,10 +1345,10 @@ function specCollaborationPlan(intensity) {
         ...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',
+            role: agent === SPEC_STAGE_SCOUT_AGENT ? 'bounded-context-scout' : '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'
+            capabilityDomain: agent === SPEC_STAGE_SCOUT_AGENT ? 'context_curation' : 'uncertainty_resolution',
+            parallelGroup: agent === SPEC_STAGE_SCOUT_AGENT ? 'discovery' : 'review'
         })),
         ...requiredCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'required-capability-review', required: true, capabilityDomain: capability, parallelGroup: 'capability-review' })),
         ...optionalCapabilities.map((capability) => ({ id: `cap.${capability}`, kind: 'skill', role: 'optional-capability-review', required: false, capabilityDomain: capability, parallelGroup: 'capability-review' })),
@@ -1732,7 +1360,7 @@ function specCollaborationPlan(intensity) {
 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 };
+        return { reasonCode: 'invalid_proposal', explanation: 'Spec stage closure requires a StageClosureRequest from spec-manager.', requiredNextAction: 'Submit spec-manager closure request with final spec ref/hash and runtime close boundary facts.', fallbackRoute: 'revise-proposal', retryAllowed: true };
     }
     if (request.stage !== 'spec') {
         return { reasonCode: 'unsupported_stage', explanation: `Spec runtime cannot close ${request.stage} closure requests.`, requiredNextAction: 'Route the closure request to the matching stage runtime.', fallbackRoute: 'revise-proposal', retryAllowed: true };
@@ -1740,32 +1368,19 @@ function validateStageClosureRequest(input) {
     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') {
+    if (request.candidate && request.candidate.stage !== 'spec') {
         return { reasonCode: 'unsupported_stage', explanation: `Spec runtime cannot close ${request.candidate.stage} candidates.`, requiredNextAction: 'Route the candidate to the matching stage runtime.', fallbackRoute: 'revise-proposal', retryAllowed: true };
     }
-    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));
+    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);
+    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 };
+    if (request.managerRecommendation === 'close_stage' && !request.runtimeCloseBoundaryFacts) {
+        return { reasonCode: 'missing_refs', explanation: 'Spec stage close request is missing runtime close boundary facts for the final spec.md V3.', requiredNextAction: 'Ask spec-manager to submit finalSpecRef/finalSpecHash, section close declaration, review signal presence, and blockingBeforePlanCount=0.', fallbackRoute: 'revise-proposal', retryAllowed: true };
     }
     return null;
 }
@@ -2092,27 +1707,13 @@ async function registerSpecStageArtifacts(projectRoot, branch, profile, artifact
     return records;
 }
 async function collectSpecStageEvidenceRefs(projectRoot, branch, profile, artifactRefs) {
+    void projectRoot;
+    void branch;
+    void profile;
     if (artifactRefs && artifactRefs.length > 0) {
         return [...new Set(artifactRefs.map(normalizeBranchStageEvidenceRef))];
     }
-    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));
+    return [];
 }
 async function registerBranchStageArtifacts(projectRoot, branch, stage, artifactRefs, required, runId, registeredAt) {
     const refs = await collectBranchStageEvidenceRefs(projectRoot, branch, stage, artifactRefs, required);
@@ -2200,95 +1801,226 @@ function runtimeRefForStageArtifact(record) {
 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) {
+async function buildOutputCenteredSpecClosureRequest(projectRoot, profile, workOrder, partition, request, generatedAt) {
+    if (!request) {
         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) {
+    const expectedSpecRef = `specs/${partition}/spec.md`;
+    if (request.finalSpecRef && request.finalSpecRef !== expectedSpecRef) {
         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];
+    if (request.sectionCloseDeclaration !== 'present' || request.reviewSignal !== 'present' || request.blockingBeforePlanCount !== 0) {
+        return null;
+    }
+    const content = await readOptionalText(path.join(projectRoot, 'specs', partition, 'spec.md'));
+    if (content === null) {
+        return null;
+    }
+    const specHash = hashDocumentContent(content);
+    const finalSpecRef = { kind: 'document', ref: expectedSpecRef, hash: specHash };
+    const facts = {
+        contract: 'sdd-spec-runtime-close-boundary-facts-v1',
+        scope: profile.scope,
+        finalSpecRef,
+        finalSpecHash: specHash,
+        templateContract: 'sdd-spec-doc-v3',
+        blockingBeforePlanCount: 0,
+        sectionCloseDeclaration: 'present',
+        reviewSignal: 'present',
+        runtimeTruthOwner: 'Runtime Kernel'
+    };
+    const acceptedItems = [{
+            id: 'accepted-spec',
+            kind: 'handoff_proposal',
+            summary: 'Spec-manager submitted final spec.md V3 for runtime ref/hash acceptance.',
+            refs: [finalSpecRef]
+        }];
     const candidate = {
         contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
-        candidateId: stableId('spec-document-candidate', profile.scope, manager.ref, manager.hash, generatedAt),
+        candidateId: stableId('spec-document-candidate', profile.scope, expectedSpecRef, specHash, generatedAt),
         stage: 'spec',
         scope: profile.scope,
-        producedBy: SPEC_STAGE_DRAFTER_AGENT,
-        inputRefs: profile.inputRefs.length > 0 ? profile.inputRefs : evidenceRefs,
-        evidenceRefs,
+        producedBy: SPEC_STAGE_MANAGER,
+        inputRefs: profile.inputRefs,
+        evidenceRefs: [],
         acceptedItems,
         generatedAt
     };
     return {
         contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
-        closureRequestId: stableId('spec-closure-request', profile.scope, manager.ref, manager.hash, generatedAt),
+        closureRequestId: stableId('spec-closure-request', profile.scope, expectedSpecRef, specHash, generatedAt),
         stage: 'spec',
         scope: profile.scope,
-        submittedBy: SPEC_STAGE_MANAGER,
+        submittedBy: 'host-adapter',
         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)] : [],
+        coordinationRef: null,
+        candidateRef: finalSpecRef,
+        reviewRefs: [],
         capabilityFindingRefs: [],
-        evidenceRefs,
+        evidenceRefs: [],
         candidate,
-        reviewResults: review ? [registeredReviewResult(profile, review, generatedAt)] : [],
+        reviewResults: [],
         capabilityFindings: [],
-        unresolvedAmbiguityIds: blockingItem.map((item) => item.id),
+        unresolvedAmbiguityIds: [],
         authorityAttempts: [],
-        managerRecommendation: manager.recommendation ?? 'blocked',
+        managerRecommendation: 'close_stage',
+        runtimeCloseBoundaryFacts: facts,
         generatedAt
     };
 }
-function registeredReviewResult(profile, review, generatedAt) {
+async function buildOutputCenteredPlanClosureRequest(projectRoot, scope, workOrder, partition, acceptedSpecHandoff, request, generatedAt) {
+    if (!request) {
+        return null;
+    }
+    const expectedPlanRef = `specs/${partition}/plan.md`;
+    if (request.finalPlanRef && request.finalPlanRef !== expectedPlanRef) {
+        return null;
+    }
+    if (request.planCloseQualityEvidence !== 'present' || request.reviewSignal !== 'present' || request.blockingBeforeTasksCount !== 0) {
+        return null;
+    }
+    const acceptedSpecRef = acceptedSpecRefFromHandoff(partition, acceptedSpecHandoff);
+    if (!acceptedSpecRef) {
+        return null;
+    }
+    const content = await readOptionalText(path.join(projectRoot, 'specs', partition, 'plan.md'));
+    if (content === null) {
+        return null;
+    }
+    const planHash = hashDocumentContent(content);
+    const finalPlanRef = { kind: 'document', ref: expectedPlanRef, hash: planHash };
+    const facts = {
+        contract: 'sdd-plan-runtime-close-boundary-facts-v1',
+        scope,
+        acceptedSpecRef,
+        finalPlanRef,
+        finalPlanHash: planHash,
+        templateContract: 'sdd-plan-doc-v3',
+        blockingBeforeTasksCount: 0,
+        planCloseQualityEvidence: 'present',
+        reviewSignal: 'present',
+        runtimeTruthOwner: 'Runtime Kernel'
+    };
     return {
         contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
-        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)],
+        closureRequestId: stableId('plan-closure-request', scope, expectedPlanRef, planHash, generatedAt),
+        stage: 'plan',
+        scope,
+        submittedBy: 'host-adapter',
+        workOrderRef: workOrder ? { kind: 'projection', ref: `plan-work-order:${workOrder.workOrderId}` } : { kind: 'projection', ref: `plan-work-order:${planCollaborationScopeKey(scope)}` },
+        coordinationRef: null,
+        candidateRef: finalPlanRef,
+        reviewRefs: [],
+        capabilityFindingRefs: [],
+        evidenceRefs: [],
+        candidate: null,
+        reviewResults: [],
+        capabilityFindings: [],
+        unresolvedAmbiguityIds: [],
+        authorityAttempts: [],
+        managerRecommendation: 'close_stage',
+        runtimeCloseBoundaryFacts: facts,
         generatedAt
     };
 }
-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;
+async function buildOutputCenteredTasksClosureRequest(projectRoot, scope, workOrder, partition, acceptedPlanHandoff, request, generatedAt) {
+    if (!request) {
+        return null;
+    }
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (request.finalTasksRef && request.finalTasksRef !== expectedTasksRef) {
+        return null;
+    }
+    if (request.dependencyGraphStatus !== 'present' || request.validationSignalsStatus !== 'present' || request.reviewSignal !== 'present' || request.blockingBeforeExecuteCount !== 0) {
+        return null;
+    }
+    const acceptedPlanRef = acceptedPlanRefFromHandoff(partition, acceptedPlanHandoff);
+    const acceptedSpecRef = acceptedSpecRefFromPlanHandoff(acceptedPlanHandoff);
+    if (!acceptedPlanRef || !acceptedSpecRef) {
+        return null;
+    }
+    const content = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (content === null) {
+        return null;
+    }
+    const taskModel = parseSddTasksMarkdown(content, { tasksPath: expectedTasksRef });
+    const tasksHash = hashDocumentContent(content);
+    const finalTasksRef = { kind: 'document', ref: expectedTasksRef, hash: tasksHash };
+    const facts = {
+        contract: 'sdd-tasks-runtime-close-boundary-facts-v1',
+        scope,
+        acceptedSpecRef,
+        acceptedPlanRef,
+        finalTasksRef,
+        finalTasksHash: tasksHash,
+        templateContract: 'sdd-tasks-doc-v2',
+        taskUnitCount: taskModel.tasks.length,
+        blockingBeforeExecuteCount: 0,
+        dependencyGraphStatus: 'present',
+        validationSignalsStatus: 'present',
+        reviewSignal: 'present',
+        runtimeTruthOwner: 'Runtime Kernel'
+    };
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        closureRequestId: stableId('tasks-closure-request', scope, expectedTasksRef, tasksHash, generatedAt),
+        stage: 'tasks',
+        scope,
+        submittedBy: 'host-adapter',
+        workOrderRef: workOrder ? { kind: 'projection', ref: `tasks-work-order:${workOrder.workOrderId}` } : { kind: 'projection', ref: `tasks-work-order:${tasksCollaborationScopeKey(scope)}` },
+        coordinationRef: null,
+        candidateRef: finalTasksRef,
+        reviewRefs: [],
+        capabilityFindingRefs: [],
+        evidenceRefs: [],
+        candidate: null,
+        reviewResults: [],
+        capabilityFindings: [],
+        unresolvedAmbiguityIds: [],
+        authorityAttempts: [],
+        managerRecommendation: 'close_stage',
+        runtimeCloseBoundaryFacts: facts,
+        generatedAt
+    };
+}
+function acceptedSpecRefFromHandoff(partition, handoff) {
+    const expectedSpecRef = `specs/${partition}/spec.md`;
+    return handoff?.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedSpecRef)
+        ?? handoff?.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedSpecRef)
+        ?? null;
+}
+function acceptedPlanRefFromHandoff(partition, handoff) {
+    const expectedPlanRef = `specs/${partition}/plan.md`;
+    return handoff?.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedPlanRef)
+        ?? handoff?.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedPlanRef)
+        ?? null;
+}
+function acceptedSpecRefFromPlanHandoff(handoff) {
+    return handoff?.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref.endsWith('/spec.md'))
+        ?? handoff?.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref.endsWith('/spec.md'))
+        ?? null;
+}
+function latestValidatedStageCollaborationContract(records) {
+    return records
+        .filter((record) => record.status === 'validated')
+        .sort((left, right) => stageEvidenceVersion(right.ref) - stageEvidenceVersion(left.ref) || right.registeredAt.localeCompare(left.registeredAt))[0] ?? null;
+}
+function deriveRegisteredSpecManagerCoordination(profile, workOrder, records, generatedAt) {
+    const manager = latestStageArtifact(records, 'manager_closure_request');
+    if (!manager || !workOrder) {
+        return null;
     }
-    return latestStageArtifact(records, 'spec_review');
+    return {
+        contract: STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION,
+        coordinationId: stableId('spec-manager-coordination', profile.scope, manager.ref, manager.hash, generatedAt),
+        stage: 'spec',
+        scope: profile.scope,
+        stageManager: SPEC_STAGE_MANAGER,
+        workOrderRef: { kind: 'projection', ref: `spec-work-order:${workOrder.workOrderId}` },
+        agentTeamRefs: records.filter((record) => record.ref !== manager.ref).map(runtimeRefForStageArtifact),
+        recommendation: manager.recommendation ?? 'blocked',
+        generatedAt
+    };
 }
 function latestStageArtifact(records, kind) {
     return records
@@ -2305,54 +2037,90 @@ async function validateAcceptedSpecArtifact(projectRoot, input) {
             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 boundaryFacts = input.closureRequest?.runtimeCloseBoundaryFacts ?? null;
+    if (!boundaryFacts || boundaryFacts.contract !== 'sdd-spec-runtime-close-boundary-facts-v1') {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready spec closure must include runtime close boundary facts for the final spec.md V3.', 'Submit finalSpecRef/finalSpecHash, section close declaration, review signal presence, and blockingBeforePlanCount=0 before closure.');
     }
-    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.');
+    if (!validSpecRuntimeCloseBoundaryFacts(boundaryFacts, input.partition, expectedRef)) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Spec runtime close boundary facts do not match the final spec.md V3 acceptance contract.', 'Refresh spec close facts so finalSpecRef/finalSpecHash, template contract, section close declaration, review signal, and blocking count match runtime requirements.');
     }
     const specPath = path.join(projectRoot, 'specs', input.partition, 'spec.md');
     const content = await readOptionalText(specPath);
     if (content === null) {
-        return rejectedSpecArtifact('not_accepted_missing_spec', 'missing_refs', `Reviewed canonical spec artifact is missing at ${expectedRef}.`, 'Produce and review specs/<branch>/spec.md before requesting runtime closure.');
+        return rejectedSpecArtifact('not_accepted_missing_spec', 'missing_refs', `Final spec.md V3 artifact is missing at ${expectedRef}.`, 'Produce specs/<branch>/spec.md before requesting runtime closure.');
     }
     if (isManagedStarterSpec(content)) {
-        return rejectedSpecArtifact('not_accepted_starter_spec', 'invalid_proposal', `Canonical spec artifact at ${expectedRef} is still the managed starter spec.`, 'Replace starter spec.md with reviewed semantic spec content before closure.');
+        return rejectedSpecArtifact('not_accepted_starter_spec', 'invalid_proposal', `Canonical spec artifact at ${expectedRef} is still the managed starter spec.`, 'Replace starter spec.md with final semantic spec.md V3 content before closure.');
     }
     const specHash = hashDocumentContent(content);
-    const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
+    const expectedHashes = [boundaryFacts.finalSpecHash, boundaryFacts.finalSpecRef.hash].filter((hash) => Boolean(hash));
     const mismatchedHash = expectedHashes.find((hash) => hash !== specHash);
     if (mismatchedHash) {
-        return rejectedSpecArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `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 rejectedSpecArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Final spec.md V3 hash mismatch for ${expectedRef}: expected ${mismatchedHash}, actual ${specHash}.`, 'Refresh spec close facts with the current spec.md hash before closure.');
+    }
+    const specV3Errors = validateSpecDocumentV3(content);
+    if (specV3Errors.length > 0) {
+        return rejectedSpecArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Final spec.md does not satisfy sdd-spec-doc-v3: ${specV3Errors.join('; ')}.`, 'Rewrite specs/<branch>/spec.md as final spec.md V3 with required semantic sections before closure.');
     }
     return {
         acceptedSpecRef: { kind: 'document', ref: expectedRef, hash: specHash },
         specAcceptanceStatus: 'accepted',
         specHash,
         specContractHash: hashSemanticDocument(content),
-        reasons: [`Runtime accepted reviewed canonical spec artifact ${expectedRef}.`]
-    };
+        reasons: [`Runtime accepted final spec.md V3 artifact ${expectedRef}.`]
+    };
+}
+function validSpecRuntimeCloseBoundaryFacts(facts, partition, expectedSpecRef) {
+    return facts.contract === 'sdd-spec-runtime-close-boundary-facts-v1'
+        && facts.scope.branch === partition
+        && facts.finalSpecRef.kind === 'document'
+        && facts.finalSpecRef.ref === expectedSpecRef
+        && Boolean(facts.finalSpecRef.hash)
+        && facts.finalSpecHash === facts.finalSpecRef.hash
+        && facts.templateContract === 'sdd-spec-doc-v3'
+        && facts.blockingBeforePlanCount === 0
+        && facts.sectionCloseDeclaration === 'present'
+        && facts.reviewSignal === 'present'
+        && facts.runtimeTruthOwner === 'Runtime Kernel';
+}
+function validPlanRuntimeCloseBoundaryFacts(facts, partition, expectedPlanRef, acceptedSpecRef) {
+    return facts.contract === 'sdd-plan-runtime-close-boundary-facts-v1'
+        && facts.scope.branch === partition
+        && facts.acceptedSpecRef.kind === acceptedSpecRef.kind
+        && facts.acceptedSpecRef.ref === acceptedSpecRef.ref
+        && facts.acceptedSpecRef.hash === acceptedSpecRef.hash
+        && facts.finalPlanRef.kind === 'document'
+        && facts.finalPlanRef.ref === expectedPlanRef
+        && Boolean(facts.finalPlanRef.hash)
+        && facts.finalPlanHash === facts.finalPlanRef.hash
+        && facts.templateContract === 'sdd-plan-doc-v3'
+        && facts.blockingBeforeTasksCount === 0
+        && facts.planCloseQualityEvidence === 'present'
+        && facts.reviewSignal === 'present'
+        && facts.runtimeTruthOwner === 'Runtime Kernel';
+}
+function validTasksRuntimeCloseBoundaryFacts(facts, partition, expectedTasksRef, acceptedSpecRef, acceptedPlanRef, taskUnitCount) {
+    return facts.contract === 'sdd-tasks-runtime-close-boundary-facts-v1'
+        && facts.scope.branch === partition
+        && facts.acceptedSpecRef.kind === acceptedSpecRef.kind
+        && facts.acceptedSpecRef.ref === acceptedSpecRef.ref
+        && facts.acceptedSpecRef.hash === acceptedSpecRef.hash
+        && facts.acceptedPlanRef.kind === acceptedPlanRef.kind
+        && facts.acceptedPlanRef.ref === acceptedPlanRef.ref
+        && facts.acceptedPlanRef.hash === acceptedPlanRef.hash
+        && facts.finalTasksRef.kind === 'document'
+        && facts.finalTasksRef.ref === expectedTasksRef
+        && Boolean(facts.finalTasksRef.hash)
+        && facts.finalTasksHash === facts.finalTasksRef.hash
+        && facts.templateContract === 'sdd-tasks-doc-v2'
+        && facts.taskUnitCount === taskUnitCount
+        && facts.taskUnitCount > 0
+        && facts.blockingBeforeExecuteCount === 0
+        && facts.dependencyGraphStatus === 'present'
+        && facts.validationSignalsStatus === 'present'
+        && facts.reviewSignal === 'present'
+        && facts.runtimeTruthOwner === 'Runtime Kernel';
 }
 function rejectedSpecArtifact(specAcceptanceStatus, reasonCode, explanation, requiredNextAction) {
     return {
@@ -2382,50 +2150,37 @@ async function validateAcceptedPlanArtifact(projectRoot, input) {
     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.');
+    const acceptedSpecRef = acceptedSpecRefFromHandoff(input.partition, input.acceptedSpecHandoff);
+    if (!acceptedSpecRef) {
+        return rejectedPlanArtifact('not_accepted_missing_upstream', 'missing_refs', 'Plan closure requires accepted spec ref/hash from runtime handoff.', 'Refresh spec-stage closure and provide a fresh spec -> plan handoff before plan closure.');
     }
-    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.');
+    const boundaryFacts = input.closureRequest?.runtimeCloseBoundaryFacts;
+    if (!boundaryFacts || boundaryFacts.contract !== 'sdd-plan-runtime-close-boundary-facts-v1') {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Plan close request is missing runtime boundary facts for final plan.md V3.', 'Submit finalPlanRef/finalPlanHash, acceptedSpecRef, plan close quality evidence, review signal, and blockingBeforeTasksCount=0.');
     }
-    if (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.');
+    if (!validPlanRuntimeCloseBoundaryFacts(boundaryFacts, input.partition, expectedRef, acceptedSpecRef)) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Plan close boundary facts must reference accepted spec and final ${expectedRef}.`, 'Refresh the output close request from current runtime handoff and specs/<branch>/plan.md.');
     }
     const planPath = path.join(projectRoot, 'specs', input.partition, 'plan.md');
     const content = await readOptionalText(planPath);
     if (content === null) {
-        return rejectedPlanArtifact('not_accepted_missing_plan', 'missing_refs', `Reviewed canonical plan artifact is missing at ${expectedRef}.`, 'Produce and review specs/<branch>/plan.md before requesting runtime closure.');
+        return rejectedPlanArtifact('not_accepted_missing_plan', 'missing_refs', `Canonical plan artifact is missing at ${expectedRef}.`, 'Produce specs/<branch>/plan.md before requesting runtime closure.');
     }
     if (isManagedStarterSpec(content)) {
-        return rejectedPlanArtifact('not_accepted_starter_plan', 'invalid_proposal', `Canonical plan artifact at ${expectedRef} is still the managed starter document.`, 'Replace starter plan.md with reviewed semantic plan content before closure.');
+        return rejectedPlanArtifact('not_accepted_starter_plan', 'invalid_proposal', `Canonical plan artifact at ${expectedRef} is still the managed starter document.`, 'Replace starter plan.md with semantic plan content before closure.');
+    }
+    const documentErrors = validatePlanDocumentV3(content, boundaryFacts);
+    if (documentErrors.length > 0) {
+        return rejectedPlanArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Canonical plan artifact at ${expectedRef} is not a valid sdd-plan-doc-v3: ${documentErrors.join('; ')}.`, 'Rewrite specs/<branch>/plan.md as plan.md V3 before requesting runtime closure.');
     }
     const planHash = hashDocumentContent(content);
-    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.');
+    if (boundaryFacts.finalPlanHash !== planHash || boundaryFacts.finalPlanRef.hash !== planHash) {
+        return rejectedPlanArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Final plan hash mismatch for ${expectedRef}: expected ${boundaryFacts.finalPlanHash}, actual ${planHash}.`, 'Refresh plan close request with the current plan.md hash before closure.');
     }
     return {
         acceptedPlanRef: { kind: 'document', ref: expectedRef, hash: planHash },
@@ -2448,45 +2203,37 @@ async function validateAcceptedTasksArtifact(projectRoot, input) {
     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 acceptedPlanRef = acceptedPlanRefFromHandoff(input.partition, input.acceptedPlanHandoff);
+    const acceptedSpecRef = acceptedSpecRefFromPlanHandoff(input.acceptedPlanHandoff);
+    if (!acceptedPlanRef || !acceptedSpecRef) {
+        return rejectedTasksArtifact('not_accepted_missing_upstream', 'missing_refs', 'Tasks closure requires accepted spec and plan ref/hash from runtime handoff.', 'Refresh plan-stage closure and provide a fresh plan -> tasks handoff before tasks closure.');
     }
     const tasksPath = path.join(projectRoot, 'specs', input.partition, 'tasks.md');
     const content = await readOptionalText(tasksPath);
+    const boundaryFacts = input.closureRequest?.runtimeCloseBoundaryFacts;
+    if (!boundaryFacts || boundaryFacts.contract !== 'sdd-tasks-runtime-close-boundary-facts-v1') {
+        const closeEvidenceErrors = [];
+        if (content !== null) {
+            validateTasksDepthSignals(content, closeEvidenceErrors);
+        }
+        const closeEvidenceExplanation = closeEvidenceErrors.join('\n');
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', closeEvidenceExplanation || 'Tasks close request is missing runtime boundary facts for final tasks.md V2.', 'Submit finalTasksRef/finalTasksHash, acceptedSpecRef, acceptedPlanRef, taskUnitCount, dependencyGraphStatus, validationSignalsStatus, reviewSignal, and blockingBeforeExecuteCount=0.');
+    }
     if (content === null) {
         return rejectedTasksArtifact('not_accepted_missing_tasks', 'missing_refs', `Reviewed canonical tasks artifact is missing at ${expectedRef}.`, 'Produce and review specs/<branch>/tasks.md before requesting runtime closure.');
     }
     if (isManagedStarterSpec(content)) {
         return rejectedTasksArtifact('not_accepted_starter_tasks', 'invalid_proposal', `Canonical tasks artifact at ${expectedRef} is still the managed starter document.`, 'Replace starter tasks.md with reviewed executable task contracts before closure.');
     }
+    const tasksV2Errors = validateTasksDocumentV2(content, expectedRef);
+    if (tasksV2Errors.length > 0) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Final tasks.md does not satisfy sdd-tasks-doc-v2: ${tasksV2Errors.join('; ')}.`, 'Rewrite specs/<branch>/tasks.md as final tasks.md V2 with required execution topology sections before closure.');
+    }
     const taskModel = parseSddTasksMarkdown(content, { tasksPath: expectedRef });
     const duplicateIdGap = taskModel.gaps.find((gap) => gap.field === 'id' && /Duplicate task id/i.test(gap.message));
     if (duplicateIdGap) {
@@ -2498,11 +2245,12 @@ async function validateAcceptedTasksArtifact(projectRoot, input) {
     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 tasksHash = hashDocumentContent(content);
+    if (!validTasksRuntimeCloseBoundaryFacts(boundaryFacts, input.partition, expectedRef, acceptedSpecRef, acceptedPlanRef, taskModel.tasks.length)) {
+        return rejectedTasksArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Tasks close boundary facts must reference accepted spec, accepted plan, final ${expectedRef}, and parsed task unit count.`, 'Refresh the output close request from current runtime handoff and specs/<branch>/tasks.md.');
+    }
+    if (boundaryFacts.finalTasksHash !== tasksHash || boundaryFacts.finalTasksRef.hash !== tasksHash) {
+        return rejectedTasksArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Final tasks hash mismatch for ${expectedRef}: expected ${boundaryFacts.finalTasksHash}, actual ${tasksHash}.`, 'Refresh tasks close request with the current tasks.md hash before closure.');
     }
     const tasksContractHash = hashTasksContract(content);
     if (!tasksContractHash) {
@@ -2516,76 +2264,83 @@ async function validateAcceptedTasksArtifact(projectRoot, input) {
         reasons: [`Runtime accepted reviewed canonical tasks artifact ${expectedRef}.`]
     };
 }
-async function validateAcceptedVerifyArtifact(projectRoot, input) {
+async function validateAcceptedExecuteArtifact(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.']
+            acceptedExecuteRef: null,
+            executeAcceptanceStatus: 'not_required_noop',
+            laneEvidenceRefs: [],
+            reasons: ['Execute evidence 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.');
+        return rejectedExecuteArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute closure.', 'Resolve lifecycle blockers before requesting execute-stage closure.', 'runtime-blocked');
     }
-    const upstreamIssue = await validateAcceptedTasksHandoff(projectRoot, input.partition, input.acceptedTasksHandoff);
+    const upstreamIssue = await validateAcceptedExecuteTasksHandoff(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 rejectedExecuteArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh tasks-stage closure and provide a fresh tasks -> execute handoff before execute closure.');
     }
+    return validateExecuteProjectionReadiness(projectRoot, input.partition, input.acceptedTasksHandoff);
+}
+async function validateExecuteProjectionReadiness(projectRoot, partition, acceptedTasksHandoff) {
+    const acceptedTasksRef = acceptedTasksRefFromExecuteHandoff(acceptedTasksHandoff);
+    if (!acceptedTasksRef?.hash) {
+        return rejectedExecuteArtifact('not_accepted_missing_upstream', 'missing_refs', 'Execute close requires a tasks -> execute handoff carrying accepted tasks ref/hash.', 'Refresh tasks-stage closure before requesting execute close.');
+    }
+    const [projectionRecords, dependencyGraphEnvelope] = await Promise.all([
+        listRuntimeProjections(projectRoot, [TASK_UNIT_PROJECTION_TYPE, EXECUTION_LANE_PROJECTION_TYPE]),
+        readTaskDependencyGraphProjection(projectRoot, partition)
+    ]);
+    if (!dependencyGraphEnvelope || dependencyGraphEnvelope.payload.tasksHash !== acceptedTasksRef.hash) {
+        return rejectedExecuteArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute dependency graph must be derived from accepted ${acceptedTasksRef.ref}.`, 'Rebuild execute task projections from the accepted tasks ref/hash before closing execute.');
+    }
+    const taskUnits = projectionRecords
+        .filter((record) => record.projectionType === TASK_UNIT_PROJECTION_TYPE && record.scopeKey.startsWith(`${partition}:`))
+        .map((record) => runtimeProjectionPayload(record.payload))
+        .filter((unit) => Boolean(unit))
+        .filter((unit) => unit.sourceRef.ref === acceptedTasksRef.ref && unit.sourceRef.hash === acceptedTasksRef.hash);
+    if (taskUnits.length === 0) {
+        return rejectedExecuteArtifact('not_accepted_wrong_ref', 'missing_refs', `No TaskUnitProjection records match accepted ${acceptedTasksRef.ref}.`, 'Rebuild execute task projections from the accepted tasks ref/hash before closing execute.');
+    }
+    const executionLanes = projectionRecords
+        .filter((record) => record.projectionType === EXECUTION_LANE_PROJECTION_TYPE && record.scopeKey.startsWith(`${partition}:`))
+        .map((record) => runtimeProjectionPayload(record.payload))
+        .filter((lane) => Boolean(lane));
+    const laneEvidenceRefs = executionLanes.map((lane) => ({ kind: 'projection', ref: `${EXECUTION_LANE_PROJECTION_TYPE}:${executionLaneScopeKey(partition, lane.laneId)}` }));
+    const invalidTaskIds = uniqueStrings([...dependencyGraphEnvelope.payload.invalidTaskIds, ...taskUnits.filter((unit) => unit.dependencyState === 'invalid').map((unit) => unit.taskId)]);
+    if (invalidTaskIds.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Execute task projections contain invalid task units: ${invalidTaskIds.join(', ')}.`, 'Repair accepted tasks.md and rebuild task projections before closing execute.');
+    }
+    const implementationUnits = taskUnits.filter((unit) => unit.unit.agentRouting.board === 'implementation');
+    const validationUnits = taskUnits.filter((unit) => unit.unit.agentRouting.board === 'validation');
+    if (implementationUnits.length === 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_implementation', 'missing_refs', 'Execute close requires at least one implementation-board task unit from accepted tasks.md.', 'Route accepted implementation tasks before closing execute.');
+    }
+    if (validationUnits.length === 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_validation', 'missing_refs', 'Execute close requires at least one validation-board task unit from accepted tasks.md.', 'Route implementation validation and goal validation tasks before closing execute.');
+    }
+    const incompleteImplementation = implementationUnits.filter((unit) => !isImplementationComplete(unit)).map((unit) => unit.taskId);
+    if (incompleteImplementation.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_implementation', 'missing_refs', `Implementation board is not complete for task units: ${incompleteImplementation.join(', ')}.`, 'Run implementation/review/debug lanes until implementation task units are implemented or validated before execute close.');
+    }
+    const openCheckpointIds = taskUnits.filter((unit) => unit.checkpointState === 'open' || unit.checkpointState === 'locked').map((unit) => `${unit.taskId}:checkpoint`);
+    if (openCheckpointIds.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_checkpoint', 'invalid_proposal', `Execute checkpoints are still open: ${openCheckpointIds.join(', ')}.`, 'Satisfy or resolve execute checkpoints before closing execute.');
+    }
+    const incompleteValidation = validationUnits.filter((unit) => !isValidationComplete(unit)).map((unit) => unit.taskId);
+    if (incompleteValidation.length > 0) {
+        return rejectedExecuteArtifact('not_accepted_missing_validation', 'missing_refs', `Validation board is not complete for task units: ${incompleteValidation.join(', ')}.`, 'Run validation and goal-validation lanes until validation task units are validated before execute close.');
+    }
+    const acceptedExecuteRef = {
+        kind: 'projection',
+        ref: `${TASK_DEPENDENCY_GRAPH_PROJECTION_TYPE}:${taskDependencyGraphScopeKey(partition)}`,
+        hash: dependencyGraphEnvelope.payload.tasksHash
+    };
     return {
-        acceptedVerifyRef: { kind: 'document', ref: expectedRef, hash: verifyHash },
-        verifyAcceptanceStatus: 'accepted',
-        verifyHash,
-        verifyContractHash: hashSemanticDocument(content),
-        reasons: [`Runtime accepted reviewed canonical verify artifact ${expectedRef}.`]
+        acceptedExecuteRef,
+        executeAcceptanceStatus: 'accepted',
+        laneEvidenceRefs,
+        reasons: [`Runtime accepted execute task/lane projections for ${acceptedTasksRef.ref}.`]
     };
 }
 async function validateAcceptedDoArtifact(projectRoot, input) {
@@ -2599,46 +2354,46 @@ async function validateAcceptedDoArtifact(projectRoot, input) {
         };
     }
     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');
+        return rejectedDoArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute closure.', 'Resolve lifecycle blockers before requesting execute closure.', 'runtime-blocked');
     }
     if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
-        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready 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.');
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready execute implementation closure must be backed by a validated execute StageCollaborationContract.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/execute-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
     }
-    const upstreamIssue = await validateAcceptedVerifyHandoff(projectRoot, input.partition, input.acceptedVerifyHandoff);
+    const upstreamIssue = await validateAcceptedTasksExecuteHandoff(projectRoot, input.partition, input.acceptedTasksHandoff);
     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.');
+        return rejectedDoArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh tasks closure and provide a fresh tasks -> execute handoff before execute closure.');
     }
     const implementation = latestStageArtifact(input.registeredArtifacts, 'implementation_evidence');
     if (!implementation) {
-        return rejectedDoArtifact('not_accepted_missing_implementation', 'missing_refs', 'Ready 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.');
+        return rejectedDoArtifact('not_accepted_missing_implementation', 'missing_refs', 'Ready execute implementation closure must be backed by a registered implementer evidence artifact.', 'Ask implementer to write .sdd/runs/<branch>/execute/implementation-vN.md and register it before closure.');
     }
     const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
     if (!manager) {
-        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready 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.');
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'missing_refs', 'Ready execute implementation closure must be backed by a registered execute-manager closure artifact.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/execute-manager-vN.md and register it before closure.');
     }
     if (manager.recommendation !== 'close_stage') {
-        return rejectedDoArtifact('not_accepted_rejected', 'invalid_proposal', `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.');
+        return rejectedDoArtifact('not_accepted_rejected', 'invalid_proposal', `Execute-manager recommendation ${manager.recommendation ?? 'none'} cannot accept implementation state for execute validation handoff.`, 'Ask execute-manager to submit a close_stage recommendation after review blockers are resolved.');
     }
     const reviewByRef = manager.reviewRef
         ? input.registeredArtifacts.find((record) => record.kind === 'code_review' && record.ref === manager.reviewRef?.ref) ?? null
         : null;
     if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
-        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `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.');
+        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh execute-manager closure artifact so reviewRef/reviewHash point at the registered code review artifact.');
     }
     const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'code_review');
     if (!approvedReview) {
-        return rejectedDoArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready 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.');
+        return rejectedDoArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready execute implementation closure must include a registered code-reviewer artifact referenced by execute-manager.', 'Ask code-reviewer to write .sdd/runs/<branch>/execute/code-review-vN.md and ask execute-manager to reference that review hash.');
     }
     if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
         return rejectedDoArtifact('not_accepted_missing_review', 'missing_required_review', `Code-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept implementation state.`, 'Resolve review blockers and register an approved code-reviewer artifact before closure.');
     }
     if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== implementation.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== implementation.ref) {
-        return rejectedDoArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready 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.');
+        return rejectedDoArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready execute implementation closure must reference reviewed ${implementation.ref} as the implementation evidence artifact.`, 'Refresh code-reviewer and execute-manager artifacts so targetRef points at the implementation evidence artifact.');
     }
     const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
     const mismatchedHash = expectedHashes.find((hash) => hash !== implementation.hash);
     if (mismatchedHash) {
-        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed implementation evidence hash mismatch for ${implementation.ref}: expected ${mismatchedHash}, actual ${implementation.hash}.`, 'Refresh code-reviewer and do-manager artifacts with the current implementation evidence hash before closure.');
+        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed implementation evidence hash mismatch for ${implementation.ref}: expected ${mismatchedHash}, actual ${implementation.hash}.`, 'Refresh code-reviewer and execute-manager artifacts with the current implementation evidence hash before closure.');
     }
     const changedFileParse = parseImplementationChangedFileRefs(implementation);
     if (changedFileParse.issue) {
@@ -2647,11 +2402,11 @@ async function validateAcceptedDoArtifact(projectRoot, input) {
     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.');
+        return rejectedDoArtifact('not_accepted_boundary_violation', 'invalid_proposal', boundaryIssue, 'Restrict execute implementation evidence to the task boundary or update the allowed changed-file refs.');
     }
     const changedFileHashIssue = await validateChangedFileHashes(projectRoot, changedFileRefs);
     if (changedFileHashIssue) {
-        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', changedFileHashIssue, 'Refresh implementation, code-reviewer, and do-manager artifacts with current changed-file hashes before closure.');
+        return rejectedDoArtifact('not_accepted_hash_mismatch', 'invalid_proposal', changedFileHashIssue, 'Refresh implementation, code-reviewer, and execute-manager artifacts with current changed-file hashes before closure.');
     }
     return {
         acceptedImplementationRef: { kind: 'artifact', ref: implementation.ref, hash: implementation.hash },
@@ -2671,146 +2426,146 @@ async function validateAcceptedTestArtifact(projectRoot, input) {
         };
     }
     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');
+        return rejectedTestArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute validation closure.', 'Resolve lifecycle blockers before requesting execute validation closure.', 'runtime-blocked');
     }
     if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
-        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready 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.');
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute validation closure must be backed by a validated execute StageCollaborationContract.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/validation-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
     }
     const upstreamIssue = await validateAcceptedDoHandoff(projectRoot, input.partition, input.acceptedDoHandoff);
     if (upstreamIssue) {
-        return rejectedTestArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh do-stage closure and provide a fresh do -> test handoff before test closure.');
+        return rejectedTestArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh execute implementation closure before execute validation closure.');
     }
     const execution = latestStageArtifact(input.registeredArtifacts, 'test_execution');
     if (!execution) {
-        return rejectedTestArtifact('not_accepted_missing_execution', 'missing_refs', 'Ready 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.');
+        return rejectedTestArtifact('not_accepted_missing_execution', 'missing_refs', 'Ready execute validation closure must be backed by a registered validation execution artifact.', 'Ask validator to write .sdd/runs/<branch>/execute/test-execution-vN.md and register it before closure.');
     }
     const validation = latestStageArtifact(input.registeredArtifacts, 'validation_evidence');
     if (!validation) {
-        return rejectedTestArtifact('not_accepted_missing_validation', 'missing_refs', 'Ready 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.');
+        return rejectedTestArtifact('not_accepted_missing_validation', 'missing_refs', 'Ready execute validation closure must be backed by a registered validator evidence artifact.', 'Ask validator to write .sdd/runs/<branch>/execute/validation-vN.md and register it before closure.');
     }
     const executionStatus = execution.frontmatter.status;
     const executionExitCode = execution.frontmatter.exitCode;
     if (executionStatus !== 'passed' || executionExitCode !== 0) {
-        return rejectedTestArtifact('not_accepted_failed_tests', 'invalid_proposal', `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.');
+        return rejectedTestArtifact('not_accepted_failed_tests', 'invalid_proposal', `Validation execution ${execution.ref} status ${String(executionStatus)} with exitCode ${String(executionExitCode)} cannot close execute validation.`, 'Rerun failing validation commands and register passing validation execution evidence before closure.');
     }
     const validationExecutionRef = executionRefFromValidation(validation);
     if (validationExecutionRef !== execution.ref) {
-        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Validation evidence ${validation.ref} must reference execution evidence ${execution.ref}.`, 'Refresh validation evidence so executionRef points at the registered test execution artifact.');
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Validation evidence ${validation.ref} must reference execution evidence ${execution.ref}.`, 'Refresh validation evidence so executionRef points at the registered validation execution artifact.');
     }
     const validationExecutionHash = validation.frontmatter.executionHash;
     if (validationExecutionHash !== execution.hash) {
-        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Validation evidence execution hash mismatch for ${execution.ref}: expected ${String(validationExecutionHash)}, actual ${execution.hash}.`, 'Refresh validation evidence with the current test execution hash before closure.');
+        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Validation evidence execution hash mismatch for ${execution.ref}: expected ${String(validationExecutionHash)}, actual ${execution.hash}.`, 'Refresh validation evidence with the current validation execution hash before closure.');
     }
     if (validation.frontmatter.status !== 'passed') {
-        return rejectedTestArtifact('not_accepted_failed_tests', 'invalid_proposal', `Validation evidence ${validation.ref} status ${String(validation.frontmatter.status)} cannot close test stage.`, 'Resolve validation failures and register passing validation evidence before closure.');
+        return rejectedTestArtifact('not_accepted_failed_tests', 'invalid_proposal', `Validation evidence ${validation.ref} status ${String(validation.frontmatter.status)} cannot close execute validation.`, 'Resolve validation failures and register passing validation evidence before closure.');
     }
     if (validation.frontmatter.acceptanceMapped !== true) {
-        return rejectedTestArtifact('not_accepted_unmapped_acceptance', 'invalid_proposal', `Validation evidence ${validation.ref} must declare acceptanceMapped: true.`, 'Map validation evidence to accepted task/verify criteria before requesting test closure.');
+        return rejectedTestArtifact('not_accepted_unmapped_acceptance', 'invalid_proposal', `Validation evidence ${validation.ref} must declare acceptanceMapped: true.`, 'Map validation evidence to accepted task/verify criteria before requesting execute validation closure.');
     }
     const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
     if (!manager) {
-        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready 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.');
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute validation closure must be backed by a registered execute-manager closure artifact.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/validation-manager-vN.md and register it before closure.');
     }
     if (manager.recommendation !== 'close_stage') {
-        return rejectedTestArtifact('not_accepted_rejected', 'invalid_proposal', `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.');
+        return rejectedTestArtifact('not_accepted_rejected', 'invalid_proposal', `Execute-manager recommendation ${manager.recommendation ?? 'none'} cannot accept validation evidence for execute evidence judgment.`, 'Ask execute-manager to submit a close_stage recommendation after validation blockers are resolved.');
     }
     const reviewByRef = manager.reviewRef
         ? input.registeredArtifacts.find((record) => record.kind === 'test_review' && record.ref === manager.reviewRef?.ref) ?? null
         : null;
     if (reviewByRef && manager.reviewHash !== reviewByRef.hash) {
-        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `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.');
+        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh execute-manager closure artifact so reviewRef/reviewHash point at the registered validation review artifact.');
     }
     const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'test_review');
     if (!approvedReview) {
-        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready 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.');
+        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready execute validation closure must include a registered validation-reviewer artifact referenced by execute-manager.', 'Ask validation-reviewer to write .sdd/runs/<branch>/execute/validation-review-vN.md and ask execute-manager to reference that review hash.');
     }
     if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
-        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', `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.');
+        return rejectedTestArtifact('not_accepted_missing_review', 'missing_required_review', `Validation-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept validation evidence.`, 'Resolve review blockers and register an approved validation-reviewer artifact before closure.');
     }
     if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== validation.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== validation.ref) {
-        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready 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.');
+        return rejectedTestArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready execute validation closure must reference reviewed ${validation.ref} as the validation evidence artifact.`, 'Refresh validation-reviewer and execute-manager artifacts so targetRef points at the validation evidence artifact.');
     }
     const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
     const mismatchedHash = expectedHashes.find((hash) => hash !== validation.hash);
     if (mismatchedHash) {
-        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed validation evidence hash mismatch for ${validation.ref}: expected ${mismatchedHash}, actual ${validation.hash}.`, 'Refresh test-reviewer and test-manager artifacts with the current validation evidence hash before closure.');
+        return rejectedTestArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed validation evidence hash mismatch for ${validation.ref}: expected ${mismatchedHash}, actual ${validation.hash}.`, 'Refresh validation-reviewer and execute-manager artifacts with the current validation evidence hash before closure.');
     }
     return {
         acceptedTestEvidenceRef: { kind: 'artifact', ref: validation.ref, hash: validation.hash },
         testAcceptanceStatus: 'accepted',
         testEvidenceHash: validation.hash,
-        reasons: [`Runtime accepted reviewed test validation evidence ${validation.ref}.`]
+        reasons: [`Runtime accepted reviewed execute validation evidence ${validation.ref}.`]
     };
 }
-async function validateAcceptedGoalVerifyArtifact(projectRoot, input) {
+async function validateAcceptedEvidenceJudgmentArtifact(projectRoot, input) {
     if (!input.required) {
         return {
-            acceptedGoalVerificationRef: null,
-            goalVerifyAcceptanceStatus: 'not_required_noop',
-            goalVerificationHash: null,
-            reasons: ['Goal verification was not required by this lifecycle decision.'],
+            acceptedEvidenceJudgmentRef: null,
+            evidenceJudgmentAcceptanceStatus: 'not_required_noop',
+            evidenceJudgmentHash: null,
+            reasons: ['Evidence judgment 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');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_blocked', 'blocked_lifecycle', 'Lifecycle risk decision blocks execute evidence judgment closure.', 'Resolve lifecycle blockers before requesting execute evidence judgment closure.', 'runtime-blocked');
     }
     if (!latestValidatedStageCollaborationContract(input.registeredCollaborationContracts)) {
-        return 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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute evidence judgment closure must be backed by a validated execute StageCollaborationContract.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/evidence-judgment-collaboration-contract-vN.md within StageWorkOrder constraints before closure.');
     }
     const upstreamIssue = await validateAcceptedTestHandoff(projectRoot, input.partition, input.acceptedTestHandoff);
     if (upstreamIssue) {
-        return rejectedGoalVerifyArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh test-stage closure and provide a fresh test -> goal-verify handoff before goal-verify closure.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_upstream', 'missing_refs', upstreamIssue, 'Refresh execute validation closure before execute evidence judgment closure.');
     }
-    const verification = latestStageArtifact(input.registeredArtifacts, 'goal_verification');
+    const verification = latestStageArtifact(input.registeredArtifacts, 'evidence_judgment');
     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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_verification', 'missing_refs', 'Ready execute evidence judgment closure must be backed by a registered evidence-judgment artifact.', 'Ask evidence-judgment agent to write .sdd/runs/<branch>/execute/evidence-judgment-vN.md and register it before closure.');
     }
     if (verification.frontmatter.status !== 'passed') {
-        return 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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_failed_verification', 'invalid_proposal', `Evidence judgment ${verification.ref} status ${String(verification.frontmatter.status)} cannot close execute evidence judgment.`, 'Resolve evidence judgment failures and register passing evidence judgment evidence before closure.');
     }
     if (verification.frontmatter.coverageComplete !== true) {
-        return rejectedGoalVerifyArtifact('not_accepted_incomplete_coverage', 'invalid_proposal', `Goal verification ${verification.ref} must declare coverageComplete: true.`, 'Complete acceptance coverage before requesting goal-verify closure.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_incomplete_coverage', 'invalid_proposal', `Evidence judgment ${verification.ref} must declare coverageComplete: true.`, 'Complete acceptance coverage before requesting execute evidence judgment closure.');
     }
     const durableGapCount = verification.frontmatter.durableGapCount;
     const openGapCount = verification.frontmatter.openGapCount;
     if ((typeof durableGapCount === 'number' && durableGapCount > 0) || (typeof openGapCount === 'number' && openGapCount > 0)) {
-        return rejectedGoalVerifyArtifact('not_accepted_open_gap', 'invalid_proposal', `Goal verification ${verification.ref} still declares open durable gaps.`, 'Resolve durable gaps before requesting goal-verify closure.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_open_gap', 'invalid_proposal', `Evidence judgment ${verification.ref} still declares open durable gaps.`, 'Resolve durable gaps before requesting execute evidence judgment closure.');
     }
     const manager = latestStageArtifact(input.registeredArtifacts, 'manager_closure_request');
     if (!manager) {
-        return 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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_wrong_ref', 'invalid_proposal', 'Ready execute evidence judgment closure must be backed by a registered execute-manager closure artifact.', 'Ask execute-manager to write .sdd/runs/<branch>/execute/evidence-judgment-manager-vN.md and register it before closure.');
     }
     if (manager.recommendation !== 'close_stage') {
-        return 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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_rejected', 'invalid_proposal', `Execute-manager recommendation ${manager.recommendation ?? 'none'} cannot accept evidence judgment for truthAlignment and ship readiness.`, 'Ask execute-manager to submit a close_stage recommendation after evidence judgment blockers are resolved.');
     }
     const reviewByRef = manager.reviewRef
-        ? input.registeredArtifacts.find((record) => record.kind === 'goal_review' && record.ref === manager.reviewRef?.ref) ?? null
+        ? input.registeredArtifacts.find((record) => record.kind === 'evidence_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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Execute-manager review hash mismatch for ${reviewByRef.ref}: expected ${manager.reviewHash ?? 'none'}, actual ${reviewByRef.hash}.`, 'Refresh execute-manager closure artifact so reviewRef/reviewHash point at the registered evidence review artifact.');
     }
-    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'goal_review');
+    const approvedReview = findStageReviewForManager(input.registeredArtifacts, manager, 'evidence_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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_review', 'missing_required_review', 'Ready execute evidence judgment closure must include a registered evidence-reviewer artifact referenced by execute-manager.', 'Ask evidence-reviewer to write .sdd/runs/<branch>/execute/evidence-review-vN.md and ask execute-manager to reference that review hash.');
     }
     if (approvedReview.verdict !== 'approved' || approvedReview.blockingCount !== 0) {
-        return 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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_missing_review', 'missing_required_review', `Evidence-reviewer verdict ${approvedReview.verdict ?? 'none'} with ${approvedReview.blockingCount ?? 0} blockers cannot accept evidence judgment.`, 'Resolve review blockers and register an approved evidence-reviewer artifact before closure.');
     }
     if (manager.targetRef?.kind !== 'artifact' || manager.targetRef.ref !== verification.ref || approvedReview.targetRef?.kind !== 'artifact' || approvedReview.targetRef.ref !== verification.ref) {
-        return 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.');
+        return rejectedEvidenceJudgmentArtifact('not_accepted_wrong_ref', 'invalid_proposal', `Ready execute evidence judgment closure must reference reviewed ${verification.ref} as the evidence judgment artifact.`, 'Refresh evidence-reviewer and execute-manager artifacts so targetRef points at the evidence judgment artifact.');
     }
     const expectedHashes = [manager.targetHash, approvedReview.targetHash, manager.targetRef.hash, approvedReview.targetRef.hash].filter((hash) => Boolean(hash));
     const mismatchedHash = expectedHashes.find((hash) => hash !== verification.hash);
     if (mismatchedHash) {
-        return 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 rejectedEvidenceJudgmentArtifact('not_accepted_hash_mismatch', 'invalid_proposal', `Reviewed evidence judgment hash mismatch for ${verification.ref}: expected ${mismatchedHash}, actual ${verification.hash}.`, 'Refresh evidence-reviewer and execute-manager artifacts with the current evidence judgment hash before closure.');
     }
     return {
-        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)
+        acceptedEvidenceJudgmentRef: { kind: 'artifact', ref: verification.ref, hash: verification.hash },
+        evidenceJudgmentAcceptanceStatus: 'accepted',
+        evidenceJudgmentHash: verification.hash,
+        reasons: [`Runtime accepted reviewed evidence judgment evidence ${verification.ref}.`],
+        truthAlignment: parseEvidenceJudgmentTruthAlignment(verification)
     };
 }
 async function validateAcceptedShipReadinessArtifact(projectRoot, input) {
@@ -2831,7 +2586,7 @@ async function validateAcceptedShipReadinessArtifact(projectRoot, input) {
     }
     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.');
+        return rejectedShipReadinessArtifact('not_accepted_missing_upstream', 'missing_refs', truthAlignmentIssue, 'Refresh execute evidence judgment closure so runtime records an aligned truthAlignment projection before ship closure.');
     }
     const authorityIssue = validateNoRuntimeAuthorityAttempts(input.registeredArtifacts);
     if (authorityIssue) {
@@ -2889,6 +2644,7 @@ async function validateAcceptedShipReadinessArtifact(projectRoot, input) {
     };
 }
 async function validateAcceptedPlanHandoff(projectRoot, partition, handoff) {
+    const expectedSpecRef = `specs/${partition}/spec.md`;
     const expectedPlanRef = `specs/${partition}/plan.md`;
     if (!handoff) {
         return 'Tasks closure requires a recorded plan -> tasks handoff.';
@@ -2896,6 +2652,19 @@ async function validateAcceptedPlanHandoff(projectRoot, partition, handoff) {
     if (handoff.fromStage !== 'plan' || handoff.toStage !== 'tasks' || handoff.status === 'blocked' || handoff.status === 'rejected') {
         return 'Tasks closure requires a non-blocking plan -> tasks handoff.';
     }
+    const acceptedSpecRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedSpecRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedSpecRef);
+    if (!acceptedSpecRef?.hash) {
+        return `Plan -> tasks handoff must carry accepted ${expectedSpecRef} with a content hash.`;
+    }
+    const specContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'spec.md'));
+    if (specContent === null) {
+        return `Accepted upstream spec artifact is missing at ${expectedSpecRef}.`;
+    }
+    const currentSpecHash = hashDocumentContent(specContent);
+    if (acceptedSpecRef.hash !== currentSpecHash) {
+        return `Accepted upstream spec hash is stale for ${expectedSpecRef}: expected ${acceptedSpecRef.hash}, actual ${currentSpecHash}.`;
+    }
     const acceptedPlanRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedPlanRef)
         ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedPlanRef);
     if (!acceptedPlanRef?.hash) {
@@ -2911,18 +2680,55 @@ async function validateAcceptedPlanHandoff(projectRoot, partition, handoff) {
     }
     return null;
 }
+async function validateAcceptedExecuteTasksHandoff(projectRoot, partition, handoff) {
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
+    if (!handoff) {
+        return 'Execute closure requires a recorded tasks -> execute handoff.';
+    }
+    if (handoff.fromStage !== 'tasks' || handoff.toStage !== 'execute' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Execute closure requires a non-blocking tasks -> execute handoff.';
+    }
+    const acceptedTasksRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedTasksRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedTasksRef);
+    if (!acceptedTasksRef?.hash) {
+        return `Tasks -> execute handoff must carry accepted ${expectedTasksRef} with a content hash.`;
+    }
+    const tasksContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (tasksContent === null) {
+        return `Accepted upstream tasks artifact is missing at ${expectedTasksRef}.`;
+    }
+    const currentTasksHash = hashDocumentContent(tasksContent);
+    if (acceptedTasksRef.hash !== currentTasksHash) {
+        return `Accepted upstream tasks hash is stale for ${expectedTasksRef}: expected ${acceptedTasksRef.hash}, actual ${currentTasksHash}.`;
+    }
+    return null;
+}
+function acceptedTasksRefFromExecuteHandoff(handoff) {
+    if (!handoff) {
+        return null;
+    }
+    return handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref.endsWith('/tasks.md'))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref.endsWith('/tasks.md'))
+        ?? null;
+}
+function isImplementationComplete(unit) {
+    return unit.executionState === 'implemented' || unit.executionState === 'validated' || unit.evidenceState === 'accepted';
+}
+function isValidationComplete(unit) {
+    return unit.executionState === 'validated' || unit.evidenceState === 'accepted';
+}
 async function validateAcceptedTasksHandoff(projectRoot, partition, handoff) {
     const expectedTasksRef = `specs/${partition}/tasks.md`;
     if (!handoff) {
-        return 'Verifies closure requires a recorded tasks -> verifies handoff.';
+        return 'Verification-design closure requires a recorded plan -> tasks handoff.';
     }
-    if (handoff.fromStage !== 'tasks' || handoff.toStage !== 'verifies' || handoff.status === 'blocked' || handoff.status === 'rejected') {
-        return 'Verifies closure requires a non-blocking tasks -> verifies handoff.';
+    if (handoff.fromStage !== 'plan' || handoff.toStage !== 'tasks' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Verification-design closure requires a non-blocking plan -> tasks handoff.';
     }
     const acceptedTasksRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedTasksRef)
         ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedTasksRef);
     if (!acceptedTasksRef?.hash) {
-        return `Tasks -> verifies handoff must carry accepted ${expectedTasksRef} with a content hash.`;
+        return `Plan -> tasks handoff must carry accepted ${expectedTasksRef} with a content hash.`;
     }
     const tasksContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
     if (tasksContent === null) {
@@ -2934,54 +2740,54 @@ async function validateAcceptedTasksHandoff(projectRoot, partition, handoff) {
     }
     return null;
 }
-async function validateAcceptedVerifyHandoff(projectRoot, partition, handoff) {
-    const expectedVerifyRef = `specs/${partition}/verify.md`;
+async function validateAcceptedTasksExecuteHandoff(projectRoot, partition, handoff) {
+    const expectedTasksRef = `specs/${partition}/tasks.md`;
     if (!handoff) {
-        return 'Do closure requires a recorded verifies -> do handoff.';
+        return 'Execute closure requires a recorded tasks -> execute handoff.';
     }
-    if (handoff.fromStage !== 'verifies' || handoff.toStage !== 'do' || handoff.status === 'blocked' || handoff.status === 'rejected') {
-        return 'Do closure requires a non-blocking verifies -> do handoff.';
+    if (handoff.fromStage !== 'tasks' || handoff.toStage !== 'execute' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Execute closure requires a non-blocking tasks -> execute handoff.';
     }
-    const 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 acceptedTasksRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'document' && inputRef.ref === expectedTasksRef)
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'document' && outputRef.ref === expectedTasksRef);
+    if (!acceptedTasksRef?.hash) {
+        return `Tasks -> execute handoff must carry accepted ${expectedTasksRef} with a content hash.`;
     }
-    const verifyContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'verify.md'));
-    if (verifyContent === null) {
-        return `Accepted upstream verify artifact is missing at ${expectedVerifyRef}.`;
+    const tasksContent = await readOptionalText(path.join(projectRoot, 'specs', partition, 'tasks.md'));
+    if (tasksContent === null) {
+        return `Accepted upstream tasks artifact is missing at ${expectedTasksRef}.`;
     }
-    const currentVerifyHash = hashDocumentContent(verifyContent);
-    if (acceptedVerifyRef.hash !== currentVerifyHash) {
-        return `Accepted upstream verify hash is stale for ${expectedVerifyRef}: expected ${acceptedVerifyRef.hash}, actual ${currentVerifyHash}.`;
+    const currentTasksHash = hashDocumentContent(tasksContent);
+    if (acceptedTasksRef.hash !== currentTasksHash) {
+        return `Accepted upstream tasks hash is stale for ${expectedTasksRef}: expected ${acceptedTasksRef.hash}, actual ${currentTasksHash}.`;
     }
     return null;
 }
 async function validateAcceptedDoHandoff(projectRoot, partition, handoff) {
     if (!handoff) {
-        return 'Test closure requires a recorded do -> test handoff.';
+        return 'Validation lane closure requires a recorded execute -> ship handoff.';
     }
-    if (handoff.fromStage !== 'do' || handoff.toStage !== 'test' || handoff.status === 'blocked' || handoff.status === 'rejected') {
-        return 'Test closure requires a non-blocking do -> test handoff.';
+    if (handoff.fromStage !== 'execute' || handoff.toStage !== 'ship' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Validation lane closure requires a non-blocking execute -> ship handoff.';
     }
-    const acceptedImplementationRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/do/implementation-`))
-        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/do/implementation-`));
+    const acceptedImplementationRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/execute/implementation-`))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/execute/implementation-`));
     if (!acceptedImplementationRef?.hash) {
-        return `Do -> test handoff must carry accepted .sdd/runs/${partition}/do/implementation-vN.md with a content hash.`;
+        return `Execute -> ship handoff must carry accepted .sdd/runs/${partition}/execute/implementation-vN.md with a content hash.`;
     }
     return validateHandoffInputHashes(projectRoot, handoff.requiredInputRefs);
 }
 async function validateAcceptedTestHandoff(projectRoot, partition, handoff) {
     if (!handoff) {
-        return 'Goal-verify closure requires a recorded test -> goal-verify handoff.';
+        return 'Evidence-judgment lane closure requires a recorded execute -> ship 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.';
+    if (handoff.fromStage !== 'execute' || handoff.toStage !== 'ship' || handoff.status === 'blocked' || handoff.status === 'rejected') {
+        return 'Evidence-judgment lane closure requires a non-blocking execute -> ship handoff.';
     }
-    const acceptedTestRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/test/validation-`))
-        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/test/validation-`));
+    const acceptedTestRef = handoff.requiredInputRefs.find((inputRef) => inputRef.kind === 'artifact' && inputRef.ref.startsWith(`.sdd/runs/${partition}/execute/validation-`))
+        ?? handoff.outputRefs.find((outputRef) => outputRef.kind === 'artifact' && outputRef.ref.startsWith(`.sdd/runs/${partition}/execute/validation-`));
     if (!acceptedTestRef?.hash) {
-        return `Test -> goal-verify handoff must carry accepted .sdd/runs/${partition}/test/validation-vN.md with a content hash.`;
+        return `Execute -> ship handoff must carry accepted .sdd/runs/${partition}/execute/validation-vN.md with a content hash.`;
     }
     return validateHandoffInputHashes(projectRoot, handoff.requiredInputRefs);
 }
@@ -3038,12 +2844,11 @@ function rejectedTasksArtifact(tasksAcceptanceStatus, reasonCode, explanation, r
         }
     };
 }
-function rejectedVerifyArtifact(verifyAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+function rejectedExecuteArtifact(executeAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
     return {
-        acceptedVerifyRef: null,
-        verifyAcceptanceStatus,
-        verifyHash: null,
-        verifyContractHash: null,
+        acceptedExecuteRef: null,
+        executeAcceptanceStatus,
+        laneEvidenceRefs: [],
         reasons: [explanation],
         rejectionIssue: {
             reasonCode,
@@ -3082,11 +2887,11 @@ function rejectedTestArtifact(testAcceptanceStatus, reasonCode, explanation, req
         }
     };
 }
-function rejectedGoalVerifyArtifact(goalVerifyAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
+function rejectedEvidenceJudgmentArtifact(evidenceJudgmentAcceptanceStatus, reasonCode, explanation, requiredNextAction, fallbackRoute = 'revise-proposal') {
     return {
-        acceptedGoalVerificationRef: null,
-        goalVerifyAcceptanceStatus,
-        goalVerificationHash: null,
+        acceptedEvidenceJudgmentRef: null,
+        evidenceJudgmentAcceptanceStatus,
+        evidenceJudgmentHash: null,
         reasons: [explanation],
         truthAlignment: null,
         rejectionIssue: {
@@ -3097,7 +2902,7 @@ function rejectedGoalVerifyArtifact(goalVerifyAcceptanceStatus, reasonCode, expl
         }
     };
 }
-function parseGoalVerifyTruthAlignment(verification) {
+function parseEvidenceJudgmentTruthAlignment(verification) {
     const status = enumFrontmatter(verification.frontmatter, 'truthAlignmentStatus', TRUTH_ALIGNMENT_STATUSES);
     const semanticImpact = enumFrontmatter(verification.frontmatter, 'semanticImpact', TRUTH_ALIGNMENT_SEMANTIC_IMPACTS);
     const ownerStage = enumFrontmatter(verification.frontmatter, 'ownerStage', TRUTH_ALIGNMENT_OWNER_STAGES);
@@ -3135,7 +2940,7 @@ function stageListFrontmatter(frontmatter, key) {
     if (values.length === 0) {
         return null;
     }
-    const allowed = new Set(['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
+    const allowed = new Set(['spec', 'plan', 'tasks', 'execute', 'ship']);
     return values.filter((value) => allowed.has(value));
 }
 function runtimeRefListFrontmatter(frontmatter, key) {
@@ -3202,10 +3007,10 @@ async function parseShipReleaseDocumentRef(projectRoot, partition, readiness) {
 }
 async function validateAcceptedTruthAlignment(projectRoot, partition, truthAlignment) {
     if (!truthAlignment) {
-        return 'Ship closure requires a recorded aligned truthAlignment projection from goal-verify.';
+        return 'Ship closure requires a recorded aligned truthAlignment projection from execute.';
     }
-    if (truthAlignment.contract !== TRUTH_ALIGNMENT_CONTRACT || truthAlignment.sourceStage !== 'goal-verify') {
-        return 'Ship closure requires a valid goal-verify truthAlignment projection.';
+    if (truthAlignment.contract !== TRUTH_ALIGNMENT_CONTRACT || truthAlignment.sourceStage !== 'execute') {
+        return 'Ship closure requires a valid execute truthAlignment projection.';
     }
     if (truthAlignment.status !== 'aligned') {
         const reasons = truthAlignment.reasons.length > 0 ? `: ${truthAlignment.reasons.join('; ')}` : '';
@@ -3220,9 +3025,9 @@ async function validateAcceptedTruthAlignment(projectRoot, partition, truthAlign
     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.`;
+    const acceptedEvidenceJudgmentRef = truthAlignment.acceptedRealityRefs.find((ref) => ref.kind === 'artifact' && ref.ref.startsWith(`.sdd/runs/${partition}/execute/evidence-judgment-`));
+    if (!acceptedEvidenceJudgmentRef?.hash) {
+        return `TruthAlignment must carry accepted .sdd/runs/${partition}/execute/evidence-judgment-vN.md with a content hash.`;
     }
     return validateTruthAlignmentRefHashes(projectRoot, [...truthAlignment.declaredTruthRefs, ...truthAlignment.acceptedRealityRefs]);
 }
@@ -3376,7 +3181,7 @@ function validateAllowedChangedFileRefs(changedFileRefs, allowedChangedFileRefs)
         }
     }
     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;
+    return outsideBoundary ? `Changed file ${outsideBoundary.ref} is outside the allowed execute task boundary.` : null;
 }
 function normalizeChangedFilePattern(value) {
     const normalized = normalizePortablePath(value);
@@ -3454,7 +3259,7 @@ function buildPlanWorkflowHandoff(scope, decision, input) {
     };
 }
 function buildTasksClosureStageRun(scope, runId, workOrder, health, input) {
-    const status = health === 'ready_for_verifies'
+    const status = health === 'ready_for_execute'
         ? 'completed'
         : health === 'no-op'
             ? 'skipped'
@@ -3478,94 +3283,12 @@ function buildTasksClosureStageRun(scope, runId, workOrder, health, input) {
 function buildTasksWorkflowHandoff(scope, decision, input) {
     return {
         contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
-        id: stableId('tasks-verifies-handoff', scope, 'closure', input.generatedAt),
+        id: stableId('tasks-execute-handoff', scope, 'closure', input.generatedAt),
         scope,
         fromStage: 'tasks',
-        toStage: 'verifies',
+        toStage: 'execute',
         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',
+        toAgent: 'execute-stage-runtime',
         status: decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' ? 'blocked' : 'proposed',
         outputRefs: input.outputRefs,
         requiredInputRefs: input.requiredInputRefs,
@@ -3576,37 +3299,37 @@ function buildDoWorkflowHandoff(scope, decision, input) {
         createdAt: input.generatedAt
     };
 }
-function buildTestClosureStageRun(scope, runId, workOrder, health, input) {
-    const status = health === 'ready_for_goal_verify'
+function buildExecuteClosureStageRun(scope, runId, workOrder, health, input) {
+    const status = health === 'ready_for_ship'
         ? 'completed'
         : health === 'no-op'
             ? 'skipped'
             : 'blocked';
     return {
         contract: STAGE_RUN_CONTRACT_VERSION,
-        id: stableId('stage-run-test', scope, runId, input.generatedAt),
+        id: stableId('stage-run-execute', scope, runId, input.generatedAt),
         scope,
-        stage: 'test',
+        stage: 'execute',
         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}.`] : [],
+        blockingReasons: status === 'blocked' ? [input.rejectionReason ?? `Execute adjudication health is ${health}.`] : [],
         createdAt: input.generatedAt,
         updatedAt: input.generatedAt
     };
 }
-function buildTestWorkflowHandoff(scope, decision, input) {
+function buildExecuteWorkflowHandoff(scope, decision, input) {
     return {
         contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
-        id: stableId('test-goal-verify-handoff', scope, 'closure', input.generatedAt),
+        id: stableId('execute-ship-handoff', scope, 'closure', input.generatedAt),
         scope,
-        fromStage: 'test',
-        toStage: 'goal-verify',
-        fromAgent: TEST_STAGE_MANAGER,
-        toAgent: 'goal-verify-stage-runtime',
+        fromStage: 'execute',
+        toStage: 'ship',
+        fromAgent: 'execute-manager',
+        toAgent: 'ship-stage-runtime',
         status: decision.profile === 'blocked' || decision.approvalPolicy === 'blocked' ? 'blocked' : 'proposed',
         outputRefs: input.outputRefs,
         requiredInputRefs: input.requiredInputRefs,
@@ -3617,28 +3340,6 @@ function buildTestWorkflowHandoff(scope, decision, input) {
         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'
@@ -3790,6 +3491,462 @@ function specArtifactStatusForHealth(health) {
 function isManagedStarterSpec(content) {
     return /^sdd_managed_starter:\s*true\s*$/m.test(content);
 }
+function validateSpecDocumentV3(content) {
+    const errors = [];
+    if (!/contract:\s*sdd-spec-doc-v3\b/.test(content)) {
+        errors.push('missing contract: sdd-spec-doc-v3');
+    }
+    const requiredSections = [
+        'Problem Reframing / Intent Discovery',
+        'Change Delta',
+        'Scope',
+        'Requirements',
+        'Acceptance Criteria / Evidence Targets',
+        'Definitions / Rules',
+        'Planning Constraints / Signals',
+        'Open Questions / Ambiguity Ledger',
+        'Close Quality Evidence'
+    ];
+    for (const section of requiredSections) {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        if (!new RegExp(`^##\\s+(?:\\d+\\.\\s*)?${escaped}\\s*$`, 'im').test(content)) {
+            errors.push(`missing section: ${section}`);
+        }
+    }
+    const forbiddenSections = [/^##\s+Implementation Plan\s*$/im, /^##\s+Task List\s*$/im, /^##\s+Validation Plan\s*$/im, /^##\s+Runtime Gate Metadata\s*$/im, /^##\s+Subagent Trace\s*$/im];
+    if (forbiddenSections.some((pattern) => pattern.test(content))) {
+        errors.push('contains forbidden implementation/runtime/subagent section');
+    }
+    errors.push(...formatArtifactDepthBlockingIssues(evaluateSpecArtifactDepth(content)));
+    return errors;
+}
+function validateSpecDepthSignals(content, errors) {
+    const problem = extractMarkdownSection(content, 'Problem Reframing / Intent Discovery') ?? '';
+    const changeDelta = extractMarkdownSection(content, 'Change Delta') ?? '';
+    const requirements = extractMarkdownSection(content, 'Requirements') ?? '';
+    const acceptance = extractMarkdownSection(content, 'Acceptance Criteria / Evidence Targets') ?? '';
+    const definitions = extractMarkdownSection(content, 'Definitions / Rules') ?? '';
+    const ambiguity = extractMarkdownSection(content, 'Open Questions / Ambiguity Ledger') ?? '';
+    const closeEvidence = extractMarkdownSection(content, 'Close Quality Evidence') ?? '';
+    if (!hasProblemReframingDepth(problem)) {
+        errors.push('spec lacks problem reframing depth in Problem Reframing / Intent Discovery');
+    }
+    if (!hasChangeDeltaDepth(changeDelta)) {
+        errors.push('spec lacks explicit current/target/delta/unchanged/non-goal depth in Change Delta');
+    }
+    if (!hasRequirementReasoningDepth(requirements, definitions)) {
+        errors.push('spec lacks requirement reasoning or domain rule depth');
+    }
+    if (!hasAcceptanceEvidenceDepth(acceptance)) {
+        errors.push('spec lacks acceptance evidence targets tied to requirements');
+    }
+    if (!hasAmbiguityRoutingDepth(ambiguity)) {
+        errors.push('spec lacks explicit ambiguity routing for blocking decisions, researchable gaps, assumptions, or deferred items');
+    }
+    if (!closeEvidence) {
+        errors.push('missing spec close quality evidence content');
+        return;
+    }
+    const requiredEvidence = [
+        ['requirement_review_sufficient', 'spec close quality evidence must declare requirement_review_sufficient: true'],
+        ['problem_reframed', 'spec close quality evidence must declare problem_reframed: true'],
+        ['domain_rules_confirmed_or_routed', 'spec close quality evidence must declare domain_rules_confirmed_or_routed: true'],
+        ['acceptance_evidence_targets_defined', 'spec close quality evidence must declare acceptance_evidence_targets_defined: true'],
+        ['ambiguity_routed', 'spec close quality evidence must declare ambiguity_routed: true'],
+        ['ready_for_plan', 'spec close quality evidence must declare ready_for_plan: true']
+    ];
+    for (const [key, message] of requiredEvidence) {
+        if (!new RegExp(`${key}\\s*:\\s*` + '`?' + 'true' + '`?', 'i').test(closeEvidence)) {
+            errors.push(message);
+        }
+    }
+    if (!/downstream_business_guesswork_remaining\s*:\s*\[\s*\]/i.test(closeEvidence)) {
+        errors.push('spec close quality evidence must declare no downstream_business_guesswork_remaining');
+    }
+}
+function hasProblemReframingDepth(section) {
+    return /surface request/i.test(section)
+        && /reframed problem/i.test(section)
+        && /inferred real intent|real intent/i.test(section)
+        && /observable success/i.test(section);
+}
+function hasChangeDeltaDepth(section) {
+    return /current behavior/i.test(section)
+        && /target behavior|desired behavior/i.test(section)
+        && /delta/i.test(section)
+        && /unchanged behavior/i.test(section)
+        && /non-goals?/i.test(section);
+}
+function hasRequirementReasoningDepth(requirements, definitions) {
+    const hasRequirement = /\bREQ-\d+\b/i.test(requirements);
+    const hasReasoning = /reasoning|basis|source|constraint|because|why|rule|invariant|domain/i.test(`${requirements}\n${definitions}`);
+    return hasRequirement && hasReasoning;
+}
+function hasAcceptanceEvidenceDepth(section) {
+    return /\bAC-\d+\b/i.test(section)
+        && /evidence target|api|ui|sql|test|manual|runtime|stage close/i.test(section)
+        && /REQ-\d+/i.test(section);
+}
+function hasAmbiguityRoutingDepth(section) {
+    return /blocking user decisions?|blocking before plan|no blocking/i.test(section)
+        && /researchable|resolved by scout|scout|safe assumptions?|assumptions?|deferred/i.test(section);
+}
+function validatePlanDocumentV3(content, boundaryFacts) {
+    const errors = [];
+    if (!/contract:\s*sdd-plan-doc-v3\b/.test(content)) {
+        errors.push('missing contract: sdd-plan-doc-v3');
+    }
+    const requiredSections = [
+        'Metadata',
+        'Upstream Spec Trace',
+        'Planning Problem / Strategy Framing',
+        'Current Implementation Map',
+        'Target Design Overview',
+        'Change Topology / Responsibility Boundaries',
+        'Interface / API / Schema Design',
+        'State / Data / Concurrency Design',
+        'Key Design Decisions',
+        'Alternatives Considered',
+        'Risk Controls',
+        'Validation Strategy',
+        'Rollout / Rollback / Compatibility',
+        'Task-stage Constraints',
+        'Open Questions / User Decisions',
+        'Plan Close Quality Evidence'
+    ];
+    for (const section of requiredSections) {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        if (!new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').test(content)) {
+            errors.push(`missing section: ${section}`);
+        }
+    }
+    const forbiddenSections = ['Task Graph', 'Task Units', 'Task Breakdown Rationale', 'Implementation Diff', 'Validation Results', 'Runtime Gate Metadata', 'Subagent Trace'];
+    const hasForbiddenSection = forbiddenSections.some((section) => {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        return new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').test(content);
+    });
+    const taskLeakagePatterns = [/```sdd-task\b/i, /^###\s+T\d+\b/im, /^#{3,}\s+Task\s+Units?\b/im, /^\s*sourceRequirements\s*:/im, /^\s*sourceAcceptanceCriteria\s*:/im, /^\s*taskClass\s*:/im, /^\s*suggestedExecutionLane\s*:/im, /^\s*wave\s*:/im, /^\s*dependencies\s*:/im];
+    if (hasForbiddenSection || taskLeakagePatterns.some((pattern) => pattern.test(content))) {
+        errors.push('contains forbidden task/runtime/subagent section');
+    }
+    const closeEvidence = extractMarkdownSection(content, 'Plan Close Quality Evidence');
+    if (!closeEvidence) {
+        errors.push('missing plan close quality evidence content');
+    }
+    else if (/ready_for_tasks\s*:\s*`?false`?/i.test(closeEvidence) || !/ready_for_tasks\s*:\s*`?true`?/i.test(closeEvidence)) {
+        errors.push('plan close quality evidence must declare ready_for_tasks: true');
+    }
+    validatePlanDepthSignals(content, boundaryFacts, errors);
+    errors.push(...formatArtifactDepthBlockingIssues(evaluatePlanArtifactDepth(content)));
+    return errors;
+}
+function validatePlanDepthSignals(_content, boundaryFacts, errors) {
+    if (boundaryFacts?.blockingBeforeTasksCount !== undefined && boundaryFacts.blockingBeforeTasksCount !== 0) {
+        errors.push('plan close quality evidence conflicts with runtime blockingBeforeTasksCount');
+    }
+}
+function hasConcreteImplementationSurface(section) {
+    if (/scout gap|needs scout|unresolved gap|not applicable|no existing surface/i.test(section)) {
+        return true;
+    }
+    const namedSurfaces = section.match(/\b[A-Z][A-Za-z0-9_]*(?:Controller|Service|ServiceImpl|Mapper|Repository|Entity|DTO|VO|Request|Response|Component|Page|Config|Test)\b/g) ?? [];
+    const fileRefs = section.match(/`[^`]+\.(?:ts|tsx|js|jsx|java|kt|go|py|rs|xml|sql|jsp|vue|md)`/g) ?? [];
+    return namedSurfaces.length + fileRefs.length >= 2 && /reuse|change|do-not-reuse|do not reuse|owner|ownership|convention|boundary|surface/i.test(section);
+}
+function hasFieldApiSqlMapping(section) {
+    if (/not applicable|no interface|no api|no schema/i.test(section) && /because|checked|reason/i.test(section)) {
+        return true;
+    }
+    const backtickFields = section.match(/`[a-zA-Z_][\w.]*`/g) ?? [];
+    const identifierFields = section.match(/\b[A-Za-z_][A-Za-z0-9_]*(?:Id|IDs|Hash|Ref|Refs|Count|Status|Type|Key|Keys|At|Path|Command|Query|DTO|VO|Request|Response|Mapper|Controller|Service)\b/g) ?? [];
+    const hasApiShape = /\b(query|request|response|DTO|VO|endpoint|controller|service|mapper|SQL|MyBatis|分页|权限|错误|响应包装)\b/i.test(section);
+    const hasMapping = /\b(source|table|mapper|SQL|field|column|join|group|aggregate|映射|字段|表|聚合|查询参数|返回字段)\b/i.test(section);
+    return backtickFields.length + identifierFields.length >= 6 && hasApiShape && hasMapping;
+}
+function hasStateDataFailureDepth(section) {
+    if (/not applicable|no persisted|no state/i.test(section) && /failure|rollback|stale|dirty|because|reason/i.test(section)) {
+        return true;
+    }
+    const hasDataSources = /\b(table|source|asset|state|flow|idempot|transaction|rollback|failure|partial|dirty|stale|performance|limit|join|dedup|grain|表|状态|流程|失败|回滚|脏数据|性能|去重|粒度|资产池)\b/i.test(section);
+    const identifierRules = section.match(/\b[A-Za-z_][A-Za-z0-9_]*(?:Id|Hash|Ref|Status|Type|Key|At|Path|Projection|Handoff|Stage|State|Scope|Owner|Content)\b/g) ?? [];
+    const hasSpecificRules = (section.match(/`[^`]+`/g) ?? []).length >= 5 || identifierRules.length >= 5 || /@startuml|\|.*\|.*\|/m.test(section);
+    const hasFailureOrLimit = /\b(fail|failure|rollback|partial|dirty|stale|limit|timeout|fallback|异常|失败|回滚|部分|脏|限制|超时|降级)\b/i.test(section);
+    return hasDataSources && hasSpecificRules && hasFailureOrLimit;
+}
+function hasScenarioValidationMatrix(validationStrategy, riskControls) {
+    const combined = `${validationStrategy}\n${riskControls}`;
+    const hasScenario = /scenario|input data|user action|expected|proves|does not prove|场景|输入|预期|证明/i.test(combined);
+    const hasEvidence = /command|evidence|manual|test|api|ui|sql|hook|artifact|证据|检查/i.test(combined);
+    const hasRiskLink = /risk|impact|control|validation hook|task-stage constraint|风险|影响|控制/i.test(combined);
+    return hasScenario && hasEvidence && hasRiskLink;
+}
+function hasTaskStageConstraintDepth(section) {
+    return /boundary|constraint|rollback|ordering|dependency|validation coverage|risky seam|task-stage|atomic|边界|约束|回滚|依赖|验证/i.test(section)
+        && !/```sdd-task\b/i.test(section);
+}
+function hasScoutResolutionSignal(implementationMap, openQuestions, closeEvidence) {
+    return /scout|evidence|observed|grounded|resolved|logged|no existing surface|not applicable/i.test(`${implementationMap}\n${openQuestions}\n${closeEvidence}`);
+}
+function extractMarkdownSection(content, section) {
+    for (const sectionName of Array.isArray(section) ? section : [section]) {
+        const escaped = escapeRegex(sectionName).replace(/\s+/g, '\\s+');
+        const match = new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').exec(content);
+        if (!match) {
+            continue;
+        }
+        const start = match.index + match[0].length;
+        const rest = content.slice(start);
+        const next = /^##\s+/im.exec(rest);
+        return (next ? rest.slice(0, next.index) : rest).trim();
+    }
+    return null;
+}
+function validateTasksDocumentV2(content, tasksPath = 'tasks.md') {
+    const errors = [];
+    if (!/contract:\s*sdd-tasks-doc-v2\b/.test(content)) {
+        errors.push('missing contract: sdd-tasks-doc-v2');
+    }
+    const requiredSections = [
+        ['Split Basis', 'Task Split Basis', 'Work Unit Split Basis'],
+        ['Execution Order Overview'],
+        ['Implementation Tasks', 'Implementation Work Units', 'Implementation Task Units'],
+        ['Validation Tasks', 'Validation Work Units', 'Validation Task Units'],
+        ['Task Dependencies and Handoff', 'Dependencies and Validation Handoff', 'Task Dependency and Validation Handoff'],
+        ['Coverage Check'],
+        ['Open Execution Questions', 'Open Questions', 'Execution Questions'],
+        ['Tasks Close Quality Evidence', 'Close Quality Evidence']
+    ];
+    for (const sectionAliases of requiredSections) {
+        if (!hasMarkdownSection(content, sectionAliases)) {
+            errors.push(`missing section: ${sectionAliases[0]}`);
+        }
+    }
+    const forbiddenSections = [/^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Implementation Diff\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Validation Results\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Runtime Gate Metadata\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Subagent Trace\s*$/im, /^##\s+(?:\d+(?:\.\d+)*\.?\s+)?Long-Term Backlog\s*$/im];
+    if (forbiddenSections.some((pattern) => pattern.test(content)) || /\b(?:obligationMatrix|projectionPayload|runtimeGateMetadata)\b/i.test(content)) {
+        errors.push('contains forbidden implementation/runtime/subagent section');
+    }
+    const parsed = parseSddTasksMarkdown(content, { tasksPath });
+    if (parsed.tasks.length === 0) {
+        errors.push('missing executable task units');
+    }
+    const taskIds = new Set(parsed.tasks.map((task) => task.id));
+    const taskById = new Map(parsed.tasks.map((task) => [task.id, task]));
+    let hasImplementationTask = false;
+    let hasValidationTask = false;
+    for (const task of parsed.tasks) {
+        const metadata = task.rawMetadata;
+        const taskClass = task.taskClass;
+        const unitType = task.unitType;
+        const dependencies = task.dependsOn;
+        if (taskClass !== 'implementation' && taskClass !== 'validation') {
+            errors.push(`task ${task.id} missing taskClass implementation|validation`);
+        }
+        if (!unitType) {
+            errors.push(`task ${task.id} missing unitType`);
+        }
+        if (!Number.isInteger(task.wave) || (task.wave ?? 0) <= 0) {
+            errors.push(`task ${task.id} missing execution wave`);
+        }
+        if (task.affectedFiles.length === 0) {
+            errors.push(`task ${task.id} missing affected areas`);
+        }
+        for (const dependency of dependencies) {
+            if (!taskIds.has(dependency)) {
+                errors.push(`task ${task.id} references unknown dependency ${dependency}`);
+            }
+        }
+        if (taskClass === 'implementation') {
+            hasImplementationTask = true;
+            const handoffTasks = task.validationHandoff;
+            if (handoffTasks.length === 0) {
+                errors.push(`task ${task.id} missing validation handoff`);
+            }
+            for (const handoffTaskId of handoffTasks) {
+                const handoffTask = taskById.get(handoffTaskId);
+                if (!handoffTask) {
+                    errors.push(`task ${task.id} hands off to unknown validation task ${handoffTaskId}`);
+                }
+                else if (handoffTask.taskClass !== 'validation') {
+                    errors.push(`task ${task.id} hands off to non-validation task ${handoffTaskId}`);
+                }
+                else if (Number.isInteger(task.wave) && Number.isInteger(handoffTask.wave) && (handoffTask.wave ?? 0) <= (task.wave ?? 0)) {
+                    errors.push(`task ${task.id} validation handoff ${handoffTaskId} must be in a later wave`);
+                }
+            }
+        }
+        if (taskClass === 'validation') {
+            hasValidationTask = true;
+            const validatesTasks = metadataNamedListValue(metadata, ['validatesImplementationTasks', 'validates_implementation_tasks']);
+            if (validatesTasks.length === 0) {
+                errors.push(`task ${task.id} missing validatesImplementationTasks`);
+            }
+            for (const validatedTask of validatesTasks) {
+                if (!taskIds.has(validatedTask)) {
+                    errors.push(`task ${task.id} validates unknown implementation task ${validatedTask}`);
+                }
+                const validated = taskById.get(validatedTask);
+                if (validated && validated.taskClass !== 'implementation') {
+                    errors.push(`task ${task.id} validates non-implementation task ${validatedTask}`);
+                }
+                if (validated && Number.isInteger(task.wave) && Number.isInteger(validated.wave) && (task.wave ?? 0) <= (validated.wave ?? 0)) {
+                    errors.push(`task ${task.id} must run after validated implementation task ${validatedTask}`);
+                }
+                if (!dependencies.includes(validatedTask)) {
+                    errors.push(`task ${task.id} must depend on validated implementation task ${validatedTask}`);
+                }
+            }
+        }
+    }
+    if (!hasImplementationTask) {
+        errors.push('missing implementation task');
+    }
+    if (!hasValidationTask) {
+        errors.push('missing validation task');
+    }
+    errors.push(...validateTaskValidationTopology(parsed.tasks));
+    validateTasksDepthSignals(content, errors);
+    errors.push(...taskDependencyCycleErrors(parsed.tasks));
+    return errors;
+}
+function validateTasksDepthSignals(content, errors) {
+    const closeEvidence = extractMarkdownSection(content, ['Tasks Close Quality Evidence', 'Close Quality Evidence']) ?? '';
+    if (!hasTaskReviewVerdict(closeEvidence) || !hasTaskReviewReconciliation(closeEvidence)) {
+        errors.push('tasks close quality evidence must include task-review-agent verdict and tasks-manager review reconciliation');
+    }
+    if (!/downstream_execution_guesswork_remaining\s*:\s*\[\s*\]/i.test(closeEvidence)) {
+        errors.push('tasks close quality evidence must declare downstream_execution_guesswork_remaining: []');
+    }
+}
+function hasTaskReviewVerdict(section) {
+    return /task-review-agent\s+(?:verdict|review)|review(?:_|\s+)signal|reviewed by task-review-agent/i.test(section);
+}
+function hasTaskReviewReconciliation(section) {
+    return /review(?:_|\s+)reconciliation|tasks-manager\s+(?:review\s+)?reconciliation|tasks-manager\s+(?:resolved|adjudicated)|review findings? reconciled|blocking findings resolved|task-review-agent findings resolved/i.test(section);
+}
+function hasWorkUnitContextDepth(section) {
+    return /why this task exists|work-unit context|plan decision|design part|must not reinterpret|risk/i.test(section);
+}
+function hasUpstreamTraceDepth(section) {
+    return /REQ-\d+/i.test(section) && /AC-\d+/i.test(section) && /planRefs|plan section|plan decision|§\d+/i.test(section);
+}
+function hasModificationBoundaryDepth(section) {
+    return /allowed files|allowed code|allowed .*changes|forbidden files|forbidden .*scope|what not to do|modification boundary|scope exclusions/i.test(section);
+}
+function hasRollbackUnitDepth(implementationTasks, dependencies) {
+    return /rollback unit|reverted together|rollback boundary|shared rollback/i.test(`${implementationTasks}\n${dependencies}`);
+}
+function hasDependencyRationaleDepth(dependencies, implementationTasks) {
+    return /because|why ordering matters|dependency rationale|unlocks|must complete before|parallel/i.test(`${dependencies}\n${implementationTasks}`);
+}
+function hasCompletionEvidenceDepth(section) {
+    return /completion evidence|done criteria|observable completion|what does not count|code review|basic code sanity/i.test(section);
+}
+function hasValidationExpectedResultDepth(section) {
+    return /expected result|pass criteria|evidence is enough|does not prove|acceptance checks|manual inspection|test/i.test(section);
+}
+function hasFailureRouteDepth(section) {
+    return /failure routing|failure route|return to|plan repair|spec\/user decision|environment diagnostic|tasks repair/i.test(section);
+}
+function hasMarkdownSection(content, sectionAliases) {
+    return sectionAliases.some((section) => {
+        const escaped = escapeRegex(section).replace(/\s+/g, '\\s+');
+        return new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${escaped}\\s*$`, 'im').test(content);
+    });
+}
+function validateTaskValidationTopology(tasks) {
+    const taskIds = new Set(tasks.map((task) => task.id));
+    if (taskIds.size !== tasks.length) {
+        return [];
+    }
+    const taskById = new Map(tasks.map((task) => [task.id, task]));
+    const errors = [];
+    for (const task of tasks) {
+        if (task.taskClass === 'implementation') {
+            if (task.validationHandoff.length !== 1) {
+                errors.push(`task ${task.id} must hand off to exactly one validation task`);
+                continue;
+            }
+            const validationTask = taskById.get(task.validationHandoff[0]);
+            const validatesTasks = validationTask ? metadataNamedListValue(validationTask.rawMetadata, ['validatesImplementationTasks', 'validates_implementation_tasks']) : [];
+            if (validationTask && (validatesTasks.length !== 1 || validatesTasks[0] !== task.id)) {
+                errors.push(`task ${task.id} validation handoff ${validationTask.id} must validate exactly ${task.id}`);
+            }
+        }
+        if (task.taskClass === 'validation') {
+            const validatesTasks = metadataNamedListValue(task.rawMetadata, ['validatesImplementationTasks', 'validates_implementation_tasks']);
+            if (validatesTasks.length !== 1) {
+                errors.push(`task ${task.id} must validate exactly one implementation task`);
+                continue;
+            }
+            const implementationTask = taskById.get(validatesTasks[0]);
+            if (implementationTask?.taskClass === 'implementation' && (implementationTask.validationHandoff.length !== 1 || implementationTask.validationHandoff[0] !== task.id)) {
+                errors.push(`task ${task.id} validates ${implementationTask.id} but ${implementationTask.id} must hand off only to ${task.id}`);
+            }
+        }
+    }
+    return errors;
+}
+function taskDependencyCycleErrors(tasks) {
+    const taskIds = new Set(tasks.map((task) => task.id));
+    const dependencies = new Map(tasks.map((task) => [task.id, task.dependsOn.filter((dependency) => taskIds.has(dependency))]));
+    const visiting = new Set();
+    const visited = new Set();
+    const errors = [];
+    const visit = (taskId, path) => {
+        if (visited.has(taskId)) {
+            return;
+        }
+        if (visiting.has(taskId)) {
+            errors.push(`task dependency cycle: ${[...path, taskId].join(' -> ')}`);
+            return;
+        }
+        visiting.add(taskId);
+        for (const dependency of dependencies.get(taskId) ?? []) {
+            visit(dependency, [...path, taskId]);
+        }
+        visiting.delete(taskId);
+        visited.add(taskId);
+    };
+    for (const task of tasks) {
+        visit(task.id, []);
+    }
+    return Array.from(new Set(errors));
+}
+function metadataNamedListValue(metadata, names) {
+    for (const name of names) {
+        const value = metadataListValue(metadata[name]);
+        if (value.length > 0) {
+            return value;
+        }
+    }
+    return [];
+}
+function metadataNamedScalarValue(metadata, names) {
+    for (const name of names) {
+        const value = metadataScalarValue(metadata[name]);
+        if (value !== null) {
+            return value;
+        }
+    }
+    return null;
+}
+function metadataListValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter((item) => item.length > 0);
+    }
+    const scalar = metadataScalarValue(value);
+    return scalar ? [scalar] : [];
+}
+function metadataScalarValue(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return null;
+}
 async function readOptionalText(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -3819,28 +3976,10 @@ function tasksAdjudicationProjectionRef(scope) {
         ref: `${TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${tasksCollaborationScopeKey(scope)}`
     };
 }
-function verifiesAdjudicationProjectionRef(scope) {
+function executeAdjudicationProjectionRef(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)}`
+        ref: `${EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE}:${executeCollaborationScopeKey(scope)}`
     };
 }
 function shipAdjudicationProjectionRef(scope) {
@@ -3852,6 +3991,9 @@ function shipAdjudicationProjectionRef(scope) {
 function stableHash(value) {
     return createHash('sha256').update(value, 'utf8').digest('hex');
 }
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value.length > 0)));
+}
 function uniqueRuntimeRefs(refs) {
     const seen = new Set();
     return refs.filter((ref) => {
@@ -3863,6 +4005,12 @@ function uniqueRuntimeRefs(refs) {
         return true;
     });
 }
+function runtimeProjectionPayload(payload) {
+    if (!payload || typeof payload !== 'object' || !('payload' in payload)) {
+        return null;
+    }
+    return payload.payload;
+}
 function stableId(prefix, scope, ...parts) {
     const hash = createHash('sha256').update(JSON.stringify([scope, parts]), 'utf8').digest('hex').slice(0, 16);
     return `${prefix}-${hash}`;