sdd-agent-platform 0.4.0 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/lifecycle/ship.ts

@@ -3,6 +3,8 @@ import path from 'node:path';
 import { doctor } from '../doctor/doctor.js';
 import type { DoctorLevel, DoctorReport } from '../doctor/model.js';
 import { getProjectStatus, type ProjectStatus } from '../status/project-status.js';
+import { evaluateAndRecordWorkflowGateDecision } from '../workflow-gate/evidence-packet.js';
+import { listRuntimeRepairs, type RuntimeRepairRecord } from '../storage/runtime-store.js';
 
 export interface ShipReadinessCheck {
   name: string;
@@ -32,6 +34,9 @@ export interface ShipResult {
     dependencyBlockers: number;
     tokenProjection: ProjectStatus['tokenProjection'];
     lifecycleRisk: ProjectStatus['lifecycleRisk'];
+    capabilityHealth: ProjectStatus['capabilityHealth'];
+    workflowGateHealth: ProjectStatus['workflowGateHealth'];
+    truthReconciliation: ProjectStatus['truthReconciliation'];
   };
   doctor: {
     status: DoctorLevel;
@@ -46,12 +51,17 @@ export async function runShip(projectRoot: string, options: { branch?: string |
   const checkedAt = new Date().toISOString();
   const projectStatus = await getProjectStatus(projectRoot, { branch: options.branch ?? undefined, branchSource: options.branch ? 'cli_option' : undefined });
   const doctorReport = await doctor(projectRoot, { latestOnly: true, branch: projectStatus.branch });
-  const checks = buildShipChecks(projectStatus, doctorReport);
+  const gateDecision = projectStatus.latestRun?.taskId
+    ? (await evaluateAndRecordWorkflowGateDecision(projectRoot, { branch: projectStatus.branch, taskId: projectStatus.latestRun.taskId, runId: projectStatus.latestRun.runId, decisionKind: 'ship' })).decision
+    : null;
+  const projectStatusWithGate = gateDecision ? await getProjectStatus(projectRoot, { branch: options.branch ?? undefined, branchSource: options.branch ? 'cli_option' : undefined }) : projectStatus;
+  const openRepairs = await listRuntimeRepairs(projectRoot, { branchSlug: projectStatus.branch, status: 'open' });
+  const checks = buildShipChecks(projectStatusWithGate, doctorReport, gateDecision, openRepairs);
   const blocked = checks.some((check) => check.status === 'BLOCKED');
   const status = blocked ? 'BLOCKED' : 'PASS';
   const releasePath = path.join(projectStatus.context.specDir, 'release.md');
   const nextActions = shipNextActions(projectStatus.branch, checks);
-  const releaseDocument = renderReleaseDocument({ checkedAt, projectStatus, doctorReport, checks, nextActions, status });
+  const releaseDocument = renderReleaseDocument({ checkedAt, projectStatus: projectStatusWithGate, doctorReport, checks, nextActions, status });
   const dryRun = options.dryRun === true;
   if (!dryRun) {
     const absoluteReleasePath = path.join(projectRoot, releasePath);
@@ -69,29 +79,32 @@ export async function runShip(projectRoot: string, options: { branch?: string |
     checks,
     nextActions,
     projectStatus: {
-      workflowStatus: projectStatus.workflowStatus,
-      tasks: projectStatus.tasks,
-      taskRisk: projectStatus.taskRisk,
-      latestRun: projectStatus.latestRun,
-      latestRunEvidence: projectStatus.latestRunEvidence,
-      staleReasons: projectStatus.latestRunStaleReasons,
-      affectedFileConflicts: projectStatus.affectedFileConflicts.length,
-      dependencyBlockers: projectStatus.dependencyBlockers.length,
-      tokenProjection: projectStatus.tokenProjection,
-      lifecycleRisk: projectStatus.lifecycleRisk,
+      workflowStatus: projectStatusWithGate.workflowStatus,
+      tasks: projectStatusWithGate.tasks,
+      taskRisk: projectStatusWithGate.taskRisk,
+      latestRun: projectStatusWithGate.latestRun,
+      latestRunEvidence: projectStatusWithGate.latestRunEvidence,
+      staleReasons: projectStatusWithGate.latestRunStaleReasons,
+      affectedFileConflicts: projectStatusWithGate.affectedFileConflicts.length,
+      dependencyBlockers: projectStatusWithGate.dependencyBlockers.length,
+      tokenProjection: projectStatusWithGate.tokenProjection,
+      lifecycleRisk: projectStatusWithGate.lifecycleRisk,
+      capabilityHealth: projectStatusWithGate.capabilityHealth,
+      workflowGateHealth: projectStatusWithGate.workflowGateHealth,
+      truthReconciliation: projectStatusWithGate.truthReconciliation
     },
     doctor: summarizeDoctor(doctorReport),
     releaseDocument
   };
 }
 
-function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorReport): ShipReadinessCheck[] {
+function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorReport, gateDecision: ProjectStatus['workflowGateHealth']['latestDecision'], openRepairs: RuntimeRepairRecord[]): ShipReadinessCheck[] {
   const checks: ShipReadinessCheck[] = [];
   checks.push({
     name: 'documents',
     status: projectStatus.documents.specExists && projectStatus.documents.planExists && projectStatus.documents.tasksExists && projectStatus.documents.verifyExists ? 'PASS' : 'BLOCKED',
     message: `spec=${projectStatus.documents.specExists} plan=${projectStatus.documents.planExists} tasks=${projectStatus.documents.tasksExists} verify=${projectStatus.documents.verifyExists}`,
-    nextAction: 'sdd init --branch <branch> --scaffold-docs'
+    nextAction: `Run missing document stages for ${projectStatus.branch}: sdd spec, sdd plan, then sdd tasks so verify.md is regenerated from the frozen tasks contract.`
   });
   checks.push({
     name: 'workflow_gaps',
@@ -107,18 +120,30 @@ function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorRepor
   });
   checks.push({
     name: 'doctor_fast',
-    status: doctorReport.status === 'PASS' ? 'PASS' : 'BLOCKED',
+    status: doctorReport.status === 'FAIL' ? 'BLOCKED' : 'PASS',
     message: `doctor_status=${doctorReport.status}`,
     nextAction: `sdd doctor fast --branch ${projectStatus.branch}`
   });
+  checks.push({
+    name: 'open_repairs',
+    status: openRepairs.length === 0 ? 'PASS' : 'BLOCKED',
+    message: `open=${openRepairs.length} types=${[...new Set(openRepairs.map((repair) => repair.repairType))].join(',') || 'none'}`,
+    nextAction: openRepairs[0]?.recommendedCommands[0] ?? `sdd doctor --branch ${projectStatus.branch} --latest-only`
+  });
   checks.push({
     name: 'latest_run',
     status: latestRunReady(projectStatus) ? 'PASS' : 'BLOCKED',
     message: projectStatus.latestRun
-      ? `run=${projectStatus.latestRun.runId} status=${projectStatus.latestRun.status} validation=${projectStatus.latestRun.validationStatus} sync_back=${projectStatus.latestRun.syncBackStatus}`
+      ? `run=${projectStatus.latestRun.runId} status=${projectStatus.latestRun.status} validation=${projectStatus.latestRun.validationStatus}`
       : 'run=none',
     nextAction: projectStatus.latestRun ? `sdd run inspect ${projectStatus.latestRun.runId}` : `sdd do task <task_id> --branch ${projectStatus.branch}`
   });
+  checks.push({
+    name: 'truth_reconciliation',
+    status: projectStatus.truthReconciliation ? 'BLOCKED' : 'PASS',
+    message: projectStatus.truthReconciliation ? `change=${projectStatus.truthReconciliation.changeKind} impact=${projectStatus.truthReconciliation.semanticImpact} owner=${projectStatus.truthReconciliation.ownerStage}-manager frontier=${projectStatus.truthReconciliation.minimalFrontier.join('>') || 'none'}` : 'none',
+    nextAction: projectStatus.truthReconciliation?.nextIntent.canonicalCommand
+  });
   checks.push({
     name: 'evidence_health',
     status: projectStatus.latestRunStaleReasons.length === 0 && projectStatus.affectedFileConflicts.length === 0 ? 'PASS' : 'BLOCKED',
@@ -155,6 +180,18 @@ function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorRepor
     message: `status=${projectStatus.subagentDispatches.status} blocking_open=${projectStatus.subagentDispatches.blockingOpen} failed=${projectStatus.subagentDispatches.failed} archived=${projectStatus.subagentDispatches.archived} superseded=${projectStatus.subagentDispatches.superseded}`,
     nextAction: subagentDispatchesReady(projectStatus) ? undefined : projectStatus.subagentDispatches.reasons.join(' ')
   });
+  checks.push({
+    name: 'capability_health',
+    status: projectStatus.capabilityHealth.status === 'blocked' ? 'BLOCKED' : 'PASS',
+    message: `status=${projectStatus.capabilityHealth.status} baseline=${projectStatus.capabilityHealth.baselineDomains.length}/${projectStatus.capabilityHealth.requiredProfessionalDomains.length} release_critical_gaps=${projectStatus.capabilityHealth.releaseCriticalGaps.join(',') || 'none'} adoption_closures=${projectStatus.capabilityHealth.adoptions.releaseCriticalClosures.join(',') || 'none'} evidence_candidate=${projectStatus.capabilityHealth.evidence.candidate} evidence_quarantined=${projectStatus.capabilityHealth.evidence.quarantined} evidence_blocked=${projectStatus.capabilityHealth.evidence.blocked}` ,
+    nextAction: projectStatus.capabilityHealth.status === 'blocked' ? `Run sdd test <validation_unit_id-or-validation_text> for ${projectStatus.branch} to record accepted runtime evidence; capability output remains advisory.` : undefined
+  });
+  checks.push({
+    name: 'workflow_gate',
+    status: gateDecision && gateDecision.status !== 'PASS' ? 'BLOCKED' : 'PASS',
+    message: gateDecision ? `decision=${gateDecision.decisionId} status=${gateDecision.status} hard_blocks=${gateDecision.hardBlocks.length} warnings=${gateDecision.warnings.length} human_required=${gateDecision.humanRequired}` : 'decision=none',
+    nextAction: gateDecision && gateDecision.status !== 'PASS' ? gateDecision.allowedNextActions.join(', ') : undefined
+  });
   return checks;
 }
 
@@ -163,8 +200,7 @@ function latestRunReady(projectStatus: ProjectStatus): boolean {
     return false;
   }
   return projectStatus.latestRun.status === 'completed'
-    && projectStatus.latestRun.validationStatus === 'pass'
-    && projectStatus.latestRun.syncBackStatus === 'applied';
+    && projectStatus.latestRun.validationStatus === 'pass';
 }
 
 function lifecycleRiskReady(projectStatus: ProjectStatus): boolean {
@@ -227,10 +263,13 @@ function renderReleaseDocument(input: {
     `- tasks: total=${input.projectStatus.tasks.total} pending=${input.projectStatus.tasks.pending} in_progress=${input.projectStatus.tasks.inProgress} completed=${input.projectStatus.tasks.completed} blocked=${input.projectStatus.tasks.blocked} gaps=${input.projectStatus.tasks.gaps}`,
     `- dependency_blockers: ${input.projectStatus.dependencyBlockers.map((blocker) => `${blocker.taskId}->${blocker.dependencyId}`).join(',') || 'none'}`,
     `- task_risk: high=${input.projectStatus.taskRisk.highRiskTasks.join(',') || 'none'} medium=${input.projectStatus.taskRisk.mediumRiskTasks.join(',') || 'none'} source_boundary=${input.projectStatus.taskRisk.sourceBoundaryTasks.join(',') || 'none'} context=${input.projectStatus.taskRisk.contextRiskTasks.join(',') || 'none'} token=${input.projectStatus.taskRisk.tokenRiskTasks.join(',') || 'none'} performance=${input.projectStatus.taskRisk.performanceRiskTasks.join(',') || 'none'}`,
-    latestRun ? `- latest_run: ${latestRun.runId} status=${latestRun.status} validation=${latestRun.validationStatus} sync_back=${latestRun.syncBackStatus}` : '- latest_run: none',
+    latestRun ? `- latest_run: ${latestRun.runId} status=${latestRun.status} validation=${latestRun.validationStatus}` : '- latest_run: none',
     evidence ? `- latest_run_evidence: route_preflight=${evidence.routePreflight} agent_executions=${evidence.agentExecutions} team_sessions=${evidence.teamSessions} worker_runtimes=${evidence.workerRuntimes} stale_worker_runtimes=${evidence.staleWorkerRuntimes} artifact_ingestions=${evidence.artifactIngestions}` : '- latest_run_evidence: none',
     `- token_health: ${input.projectStatus.tokenProjection.health} estimated_tokens=${input.projectStatus.tokenProjection.estimatedTokens ?? 'unknown'} context_packages=${input.projectStatus.tokenProjection.contextPackages} team_runtime_decisions=${input.projectStatus.tokenProjection.teamRuntimeDecisions}`,
     `- lifecycle_risk: status=${input.projectStatus.lifecycleRisk.status} profile=${input.projectStatus.lifecycleRisk.profile ?? 'none'} approval=${input.projectStatus.lifecycleRisk.approvalPolicy ?? 'none'} input=${input.projectStatus.lifecycleRisk.inputHash ?? 'none'} expected=${input.projectStatus.lifecycleRisk.expectedInputHash}`,
+    `- capability_health: status=${input.projectStatus.capabilityHealth.status} baseline=${input.projectStatus.capabilityHealth.baselineDomains.length}/${input.projectStatus.capabilityHealth.requiredProfessionalDomains.length} active=${input.projectStatus.capabilityHealth.activeDomains.join(',') || 'none'} release_critical_gaps=${input.projectStatus.capabilityHealth.releaseCriticalGaps.join(',') || 'none'} adoption_closures=${input.projectStatus.capabilityHealth.adoptions.releaseCriticalClosures.join(',') || 'none'} evidence_candidate=${input.projectStatus.capabilityHealth.evidence.candidate} evidence_quarantined=${input.projectStatus.capabilityHealth.evidence.quarantined} evidence_blocked=${input.projectStatus.capabilityHealth.evidence.blocked}`, 
+    `- workflow_gate: decisions=${input.projectStatus.workflowGateHealth.decisions} latest=${input.projectStatus.workflowGateHealth.latestDecision ? `${input.projectStatus.workflowGateHealth.latestDecision.decisionKind}:${input.projectStatus.workflowGateHealth.latestDecision.status}:${input.projectStatus.workflowGateHealth.latestDecision.decisionId}` : 'none'}`,
+    input.projectStatus.truthReconciliation ? `- truth_reconciliation: change=${input.projectStatus.truthReconciliation.changeKind} impact=${input.projectStatus.truthReconciliation.semanticImpact} owner=${input.projectStatus.truthReconciliation.ownerStage}-manager frontier=${input.projectStatus.truthReconciliation.minimalFrontier.join('>') || 'none'} next=${input.projectStatus.truthReconciliation.nextIntent.canonicalCommand}` : '- truth_reconciliation: none',
     `- doctor_fast: status=${input.doctorReport.status} checks=${input.doctorReport.checks.length}`,
     '',
     '## Next actions',

package/node_modules/@sdd-agent-platform/core/src/orchestration/contracts.ts

@@ -6,7 +6,7 @@ import type { SubagentDispatch, SubagentResult } from '../subagents/contracts.js
 import type { WorkUnit } from '../work-units/contracts.js';
 
 export type OrchestrationGateStatus = 'PASS' | 'WARN' | 'BLOCKED';
-export type OrchestrationGateTarget = 'route' | 'execution' | 'handoff' | 'sync-back' | 'ship' | 'test';
+export type OrchestrationGateTarget = 'route' | 'execution' | 'handoff' | 'ship' | 'test';
 
 export interface OrchestrationGate {
   status: OrchestrationGateStatus;

package/node_modules/@sdd-agent-platform/core/src/orchestration/runtime.ts

@@ -2,8 +2,8 @@ import { STAGE_RUN_CONTRACT_VERSION, SUBAGENT_DISPATCH_CONTRACT_VERSION, SUBAGEN
 import { evaluateContextLoadSignal, decideContextOffload, recordContextLoadSignalProjection, recordContextOffloadDecisionProjection } from '../context-offload/runtime.js';
 import type { ContextLoadSignal, ContextOffloadDecision } from '../context-offload/contracts.js';
 import type { ArtifactResultIngestionRecord } from '../artifacts/ingestion.js';
-import { evaluateLifecycleRiskDecisionForModel } from '../risk/consumer-diagnostics.js';
-import { lifecycleRiskDecisionScopeKey, recordLifecycleRiskDecisionProjection } from '../risk/kernel.js';
+import { evaluateLifecycleRiskDecisionForModel, inspectLifecycleRiskDecisionForModel, type LifecycleRiskConsumerDiagnostic, type LifecycleRiskDiagnosticStatus } from '../risk/consumer-diagnostics.js';
+import { lifecycleRiskDecisionScopeKey, recordLifecycleRiskDecisionProjection, readLifecycleRiskDecisionProjection } from '../risk/kernel.js';
 import type { LifecycleRiskDecision } from '../risk/contracts.js';
 import type { SddTask, SddTaskModel } from '../sdd-docs/task-parser.js';
 import { recordStageRunProjection, recordWorkflowHandoffProjection, validateWorkflowHandoff } from '../stage-runtime/runtime.js';
@@ -15,23 +15,55 @@ import { recordWorkUnitProjection, workUnitBlocksGate, WORK_UNIT_PROJECTION_TYPE
 import type { WorkUnit, WorkUnitStatus } from '../work-units/contracts.js';
 import type { CompleteExecutionOrchestrationInput, EnsureExecutionOrchestrationInput, EnsureTaskOrchestrationInput, OrchestrationGate, OrchestrationGateTarget } from './contracts.js';
 
-export async function ensureLifecycleRiskDecision(projectRoot: string, model: SddTaskModel, input: { branch: string; task?: SddTask | null; runId?: string }): Promise<LifecycleRiskDecision> {
-  const scope = runtimeScope(input.branch, input.task?.id, input.runId);
-  const decision = input.task
-    ? taskLifecycleRiskDecision(input.branch, input.task, model)
-    : evaluateLifecycleRiskDecisionForModel(input.branch, model);
-  const scopedDecision: LifecycleRiskDecision = { ...decision, scope };
-  await recordLifecycleRiskDecisionProjection(projectRoot, scopedDecision);
-  return scopedDecision;
+export interface StageLocalLifecycleRiskDecisionResolution {
+  status: LifecycleRiskDiagnosticStatus;
+  decision: LifecycleRiskDecision;
+  persisted: boolean;
+  diagnostic: LifecycleRiskConsumerDiagnostic;
+  reasons: string[];
+  nextAction: string;
+}
+
+export async function ensureLifecycleRiskDecision(projectRoot: string, model: SddTaskModel, input: { branch: string }): Promise<LifecycleRiskDecision> {
+  const decision = evaluateLifecycleRiskDecisionForModel(input.branch, model);
+  await recordLifecycleRiskDecisionProjection(projectRoot, decision);
+  return decision;
+}
+
+export async function resolveStageLocalLifecycleRiskDecision(projectRoot: string, model: SddTaskModel, input: { branch: string }): Promise<StageLocalLifecycleRiskDecisionResolution> {
+  const diagnostic = await inspectLifecycleRiskDecisionForModel(projectRoot, input.branch, model);
+  const existing = await readLifecycleRiskDecisionProjection(projectRoot, { branch: input.branch });
+  const nextAction = 'Run /sdd or /sdd:spec to create or refresh the lifecycle decision before using stage-local entries.';
+  if (existing && (diagnostic.status === 'fresh' || diagnostic.status === 'blocked')) {
+    return {
+      status: diagnostic.status,
+      decision: existing.payload,
+      persisted: true,
+      diagnostic,
+      reasons: diagnostic.reasons,
+      nextAction
+    };
+  }
+  const expected = evaluateLifecycleRiskDecisionForModel(input.branch, model);
+  const reasons = stageLocalLifecycleBlockReasons(diagnostic);
+  return {
+    status: diagnostic.status,
+    decision: blockedStageLocalLifecycleDecision(expected, reasons),
+    persisted: false,
+    diagnostic,
+    reasons,
+    nextAction
+  };
 }
 
 export async function ensureTaskOrchestration(projectRoot: string, model: SddTaskModel, task: SddTask | null, input: EnsureTaskOrchestrationInput): Promise<{ riskDecision: LifecycleRiskDecision; stageRun: StageRun; contextLoadSignal: ContextLoadSignal; contextOffloadDecision: ContextOffloadDecision }> {
-  await ensureLifecycleRiskDecision(projectRoot, model, { branch: input.branch });
-  const riskDecision = await ensureLifecycleRiskDecision(projectRoot, model, { branch: input.branch, task, runId: input.runId });
+  const lifecycle = await resolveStageLocalLifecycleRiskDecision(projectRoot, model, { branch: input.branch });
+  const riskDecision = lifecycle.decision;
   const scope = runtimeScope(input.branch, input.taskId, input.runId);
   const now = new Date().toISOString();
   const stage = input.stage ?? 'do';
-  const stageRun = buildStageRun(scope, stage, input.agent ?? 'implementer', input.status ?? 'active', riskDecision, input.outputRefs ?? [], now);
+  const stageStatus = lifecycle.status === 'fresh' ? input.status ?? 'active' : 'blocked';
+  const stageRun = buildStageRun(scope, stage, input.agent ?? 'implementer', stageStatus, riskDecision, input.outputRefs ?? [], now);
   await recordStageRunProjection(projectRoot, stageRun);
   const contextLoadSignal = evaluateContextLoadSignal({
     scope,
@@ -133,7 +165,7 @@ export async function inspectOrchestrationGate(projectRoot: string, input: { bra
     blockingReasons.push(`Lifecycle risk blocks workflow: ${riskDecision.reasons.join(' ')}`);
   } else if (riskDecision?.approvalPolicy === 'human-required' && target !== 'test') {
     blockingReasons.push('Lifecycle risk requires human approval before automated workflow continuation.');
-  } else if (riskDecision?.approvalPolicy === 'review-required' && ['sync-back', 'ship'].includes(target)) {
+  } else if (riskDecision?.approvalPolicy === 'review-required' && target === 'ship') {
     warnings.push('Lifecycle risk requires review evidence before final workflow closure.');
   }
   if (contextOffloadDecision?.action === 'block-for-curation') {
@@ -144,7 +176,7 @@ export async function inspectOrchestrationGate(projectRoot: string, input: { bra
   const blockingSubagentDispatches = dispatches.filter((dispatch) => subagentDispatchBlocksGate(dispatch, resultByDispatch.get(dispatch.id) ?? null) && dispatch.requiredBefore === gateName);
   blockingReasons.push(...blockingWorkUnits.map((workUnit) => `Work unit ${workUnit.id} blocks ${gateName}: status=${workUnit.status}.`));
   blockingReasons.push(...blockingSubagentDispatches.map((dispatch) => `Subagent dispatch ${dispatch.id} blocks ${dispatch.requiredBefore}: status=${dispatch.status}.`));
-  if (['sync-back', 'ship'].includes(target) && handoff && handoff.status !== 'accepted' && handoff.status !== 'proposed') {
+  if (target === 'ship' && handoff && handoff.status !== 'accepted' && handoff.status !== 'proposed') {
     blockingReasons.push(`Workflow handoff ${handoff.fromStage}->${handoff.toStage} is ${handoff.status}.`);
   }
   const status = blockingReasons.length > 0 ? 'BLOCKED' : warnings.length > 0 ? 'WARN' : 'PASS';
@@ -179,8 +211,31 @@ export function lifecycleAutonomyCeilingFromDecision(decision: LifecycleRiskDeci
   return 'research_before_implementation';
 }
 
-function taskLifecycleRiskDecision(branch: string, task: SddTask, model: SddTaskModel): LifecycleRiskDecision {
-  return evaluateLifecycleRiskDecisionForModel(branch, { ...model, tasks: [task], gaps: model.gaps.filter((gap) => !gap.taskId || gap.taskId === task.id || gap.severity === 'blocking') });
+function blockedStageLocalLifecycleDecision(expected: LifecycleRiskDecision, reasons: string[]): LifecycleRiskDecision {
+  return {
+    ...expected,
+    profile: 'blocked',
+    requiredStages: [],
+    blockedStages: expected.requiredStages,
+    requiredEvidence: [],
+    requiredReviews: [],
+    humanCheckpointRequired: true,
+    approvalPolicy: 'blocked',
+    confidence: 'high',
+    reasons,
+    generatedAt: new Date().toISOString()
+  };
+}
+
+function stageLocalLifecycleBlockReasons(diagnostic: LifecycleRiskConsumerDiagnostic): string[] {
+  const headline = diagnostic.status === 'missing'
+    ? 'Stage-local entry requires an active lifecycle decision created by /sdd or /sdd:spec.'
+    : diagnostic.status === 'stale'
+      ? 'Stage-local entry requires a refreshed lifecycle decision because the active projection is stale.'
+      : diagnostic.status === 'incompatible'
+        ? 'Stage-local entry requires a refreshed lifecycle decision because the active projection is incompatible.'
+        : 'Stage-local entry is blocked by the active lifecycle decision.';
+  return uniqueStrings([headline, ...diagnostic.reasons]);
 }
 
 function buildStageRun(scope: RuntimeScope, stage: SddStage, agent: string, status: StageRun['status'], riskDecision: LifecycleRiskDecision, outputRefs: RuntimeRef[], now: string): StageRun {
@@ -308,9 +363,6 @@ function nextStage(stage: SddStage): SddStage {
     return 'goal-verify';
   }
   if (stage === 'goal-verify') {
-    return 'sync-back';
-  }
-  if (stage === 'sync-back') {
     return 'ship';
   }
   return 'do';
@@ -320,8 +372,8 @@ function gateNameForTarget(target: OrchestrationGateTarget): WorkUnit['requiredB
   if (target === 'ship') {
     return 'ship';
   }
-  if (target === 'sync-back' || target === 'test') {
-    return 'sync-back';
+  if (target === 'test') {
+    return 'handoff';
   }
   if (target === 'execution') {
     return 'stage-output';

package/node_modules/@sdd-agent-platform/core/src/phase8-contracts.test.ts

@@ -33,7 +33,7 @@ test('Phase 8 contract objects expose required runtime boundaries', () => {
     contract: LIFECYCLE_RISK_DECISION_CONTRACT_VERSION,
     scope,
     profile: 'compact',
-    requiredStages: ['tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back'],
+    requiredStages: ['tasks', 'verifies', 'do', 'test', 'goal-verify'],
     skippedStages: [],
     blockedStages: [],
     requiredEvidence: [],
@@ -208,9 +208,9 @@ test('work units, subagents, context offload, evidence, and model artifacts stay
     policyJudgment: 'PASS',
     commands: [],
     acceptanceCoverage: [],
-    syncBackReady: true,
+    capabilityEvidence: [],
     gaps: [],
-    next: 'sdd sync-back inspect --branch master',
+    next: 'sdd test close --branch master --target goal-verify --compact-json',
     generatedAt: now
   };
 

package/node_modules/@sdd-agent-platform/core/src/phase8-risk-kernel.test.ts

@@ -38,7 +38,7 @@ test('lifecycle risk kernel selects compact for bounded context and evidence sig
   });
 
   assert.equal(decision.profile, 'compact');
-  assert.deepEqual(decision.requiredStages, ['tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back']);
+  assert.deepEqual(decision.requiredStages, ['tasks', 'verifies', 'do', 'test', 'goal-verify']);
   assert.equal(decision.approvalPolicy, 'review-required');
   assert.equal(decision.requiredReviews.some((review) => review.kind === 'evidence'), true);
 });
@@ -52,7 +52,7 @@ test('lifecycle risk kernel selects full for source runtime and security risks',
   const decision = evaluateLifecycleRiskDecisionFromProfile(profile, knownFacts(), '2026-05-01T00:00:00.000Z');
 
   assert.equal(decision.profile, 'full');
-  assert.deepEqual(decision.requiredStages, ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back']);
+  assert.deepEqual(decision.requiredStages, ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
   assert.equal(decision.requiredReviews.some((review) => review.kind === 'source-boundary'), true);
   assert.equal(decision.requiredReviews.some((review) => review.kind === 'runtime-state'), true);
   assert.equal(decision.requiredReviews.some((review) => review.kind === 'security'), true);
@@ -90,7 +90,7 @@ test('lifecycle risk kernel blocks unknown intent or blocked signals first', ()
 
   assert.equal(unknownIntent.profile, 'blocked');
   assert.deepEqual(unknownIntent.requiredStages, []);
-  assert.deepEqual(unknownIntent.blockedStages, ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'sync-back', 'ship']);
+  assert.deepEqual(unknownIntent.blockedStages, ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship']);
   assert.equal(unknownIntent.approvalPolicy, 'blocked');
   assert.equal(blockedSignal.profile, 'blocked');
   assert.equal(blockedSignal.approvalPolicy, 'blocked');
@@ -244,6 +244,11 @@ function task(): SddTask {
     title: 'Integrate lifecycle risk diagnostics',
     status: 'pending',
     wave: null,
+    implementationWave: null,
+    validationBatch: null,
+    validationTiming: 'task_end',
+    requiresVerifyBeforeNext: true,
+    changeSurface: 'unknown',
     dependsOn: [],
     affectedFiles: ['packages/core/src/status/project-status.ts'],
     validation: ['npm test'],

package/node_modules/@sdd-agent-platform/core/src/planning/task-graph.test.ts

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { initProject } from '../config/init-project.js';
 import { doctor } from '../doctor/doctor.js';
 import { graphTaskMarkdown, harnessTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
 import { inspectTaskGraph } from './task-graph.js';
 
 test('task graph planner builds dependency and file overlap graph', async () => {
@@ -14,6 +15,7 @@ test('task graph planner builds dependency and file overlap graph', async () =>
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('G1', [], ['src/a.ts'], [])}\n${graphTaskMarkdown('G2', ['G1'], ['./src/a.ts', 'src/b.ts'], ['security'])}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const graph = await inspectTaskGraph(root, { branch: 'master' });
 

package/node_modules/@sdd-agent-platform/core/src/planning/wave-plan.test.ts

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { initProject } from '../config/init-project.js';
 import { doctor } from '../doctor/doctor.js';
 import { graphTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
 import { inspectWavePlan } from './wave-plan.js';
 
 test('wave planner builds dependency waves and separates file overlaps', async () => {
@@ -14,6 +15,7 @@ test('wave planner builds dependency waves and separates file overlaps', async (
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('W1', [], ['src/a.ts'], [])}\n${graphTaskMarkdown('W2', [], ['./src/a.ts'], [])}\n${graphTaskMarkdown('W3', ['W1'], ['src/c.ts'], [])}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
 
@@ -32,6 +34,7 @@ test('wave planner routes manual gates and downstream blocked tasks', async () =
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('DB1', [], ['db/schema.sql'], ['database'])}\n${graphTaskMarkdown('APP1', ['DB1'], ['src/app.ts'], [])}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });