sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { initProject } from '../config/init-project.js';
+import { recordTruthAlignmentProjection, type TruthAlignmentProjection } from '../stage-collaboration.js';
+import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { runShip } from './ship.js';
+
+test('ship dry-run blocks unresolved truth reconciliation and points to owner-manager route', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-truth-reconcile-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
+    await recordTruthAlignmentProjection(root, truthAlignmentProjection());
+
+    const ship = await runShip(root, { branch: 'master', dryRun: true });
+    const check = ship.checks.find((entry) => entry.name === 'truth_reconciliation');
+
+    assert.equal(ship.status, 'BLOCKED');
+    assert.equal(check?.status, 'BLOCKED');
+    assert.match(check?.message ?? '', /change=implementation_mismatch impact=material owner=do-manager frontier=do>test>goal-verify>ship/);
+    assert.equal(check?.nextAction, 'sdd do task <task_id> --branch master');
+    assert.equal(ship.projectStatus.truthReconciliation?.nextIntent.canonicalCommand.includes('sync-back'), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+function truthAlignmentProjection(): TruthAlignmentProjection {
+  return {
+    contract: 'sdd-truth-alignment-v1',
+    branch: 'master',
+    sourceStage: 'goal-verify',
+    declaredTruthRefs: [{ kind: 'document', ref: 'specs/master/tasks.md', hash: 'tasks-hash' }],
+    acceptedRealityRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'implementation-hash' }],
+    status: 'drift_detected',
+    ownerStage: 'do',
+    semanticImpact: 'material',
+    staleRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-implementation-hash' }],
+    invalidatesStages: ['do'],
+    reasons: ['accepted implementation evidence no longer matches declared truth'],
+    createdAt: '2026-06-01T00:00:00.000Z'
+  };
+}

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

@@ -4,6 +4,7 @@ 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;
@@ -35,6 +36,7 @@ export interface ShipResult {
     lifecycleRisk: ProjectStatus['lifecycleRisk'];
     capabilityHealth: ProjectStatus['capabilityHealth'];
     workflowGateHealth: ProjectStatus['workflowGateHealth'];
+    truthReconciliation: ProjectStatus['truthReconciliation'];
   };
   doctor: {
     status: DoctorLevel;
@@ -53,7 +55,8 @@ export async function runShip(projectRoot: string, options: { branch?: string |
     ? (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 checks = buildShipChecks(projectStatusWithGate, doctorReport, gateDecision);
+  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');
@@ -87,14 +90,15 @@ export async function runShip(projectRoot: string, options: { branch?: string |
       tokenProjection: projectStatusWithGate.tokenProjection,
       lifecycleRisk: projectStatusWithGate.lifecycleRisk,
       capabilityHealth: projectStatusWithGate.capabilityHealth,
-      workflowGateHealth: projectStatusWithGate.workflowGateHealth
+      workflowGateHealth: projectStatusWithGate.workflowGateHealth,
+      truthReconciliation: projectStatusWithGate.truthReconciliation
     },
     doctor: summarizeDoctor(doctorReport),
     releaseDocument
   };
 }
 
-function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorReport, gateDecision: ProjectStatus['workflowGateHealth']['latestDecision']): ShipReadinessCheck[] {
+function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorReport, gateDecision: ProjectStatus['workflowGateHealth']['latestDecision'], openRepairs: RuntimeRepairRecord[]): ShipReadinessCheck[] {
   const checks: ShipReadinessCheck[] = [];
   checks.push({
     name: 'documents',
@@ -120,14 +124,26 @@ function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorRepor
     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',
@@ -167,8 +183,8 @@ function buildShipChecks(projectStatus: ProjectStatus, doctorReport: DoctorRepor
   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'} 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 task, sdd test batch, or sdd test wave for ${projectStatus.branch} to record accepted runtime evidence; capability output remains advisory.` : undefined
+    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',
@@ -247,12 +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'} evidence_candidate=${input.projectStatus.capabilityHealth.evidence.candidate} evidence_quarantined=${input.projectStatus.capabilityHealth.evidence.quarantined} evidence_blocked=${input.projectStatus.capabilityHealth.evidence.blocked}`,
+    `- 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: [],
@@ -209,9 +209,8 @@ test('work units, subagents, context offload, evidence, and model artifacts stay
     commands: [],
     acceptanceCoverage: [],
     capabilityEvidence: [],
-    syncBackReady: false,
     gaps: [],
-    next: 'sdd ship --branch master --dry-run',
+    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');