sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -26,7 +26,7 @@ export interface SubagentDispatch {
   mode: SubagentDispatchMode;
   status: SubagentDispatchStatus;
   blocking: boolean;
-  requiredBefore: 'handoff' | 'sync-back' | 'ship' | 'never';
+  requiredBefore: 'handoff' | 'ship' | 'never';
   contextRef: RuntimeRef;
   createdAt: string;
   updatedAt: string;

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

@@ -90,7 +90,7 @@ test('subagent projections can be written read and inspected', async () => {
     assert.equal(fresh.status, 'fresh');
     assert.equal(fresh.completed, 1);
     assert.match(fresh.reasons[0], /non-authoritative/);
-    assert.match(fresh.reasons[0], /main workflow still owns approvals, sync-back, and ship/);
+    assert.match(fresh.reasons[0], /main workflow still owns approvals, truth-alignment, and ship/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -145,7 +145,7 @@ test('subagent inspection ignores dispatches from archived runs', async () => {
     assert.equal(inspected.dispatches, 0);
     assert.equal(inspected.failed, 0);
     assert.equal(inspected.blockingOpen, 0);
-    assert.match(inspected.reasons[0], /Main workflow still owns lifecycle gates, approvals, sync-back, and ship/);
+    assert.match(inspected.reasons[0], /Main workflow still owns lifecycle gates, approvals, truth-alignment, and ship/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -169,7 +169,7 @@ test('subagent inspection lets a newer successful rerun supersede an older faile
     assert.equal(inspected.blockingOpen, 0);
     assert.equal(inspected.completed, 1);
     assert.match(inspected.reasons[0], /non-authoritative/);
-    assert.match(inspected.reasons[0], /Main workflow still owns approvals, sync-back, and ship/);
+    assert.match(inspected.reasons[0], /Main workflow still owns approvals, truth-alignment, and ship/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }

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

@@ -230,11 +230,11 @@ function timestamp(value: string): number {
 }
 
 function subagentDispatchReasons(status: SubagentDispatchDiagnosticStatus, blockingOpen: number, failed: number, stale: number, archived: number, superseded: number): string[] {
-  const recoveryHint = 'Archive failed exploratory runs with sdd run archive <run_id> --reason <text>, or rerun the subagent worker to supersede the failed dispatch; subagent evidence still cannot approve high-risk execution, sync-back, or ship.';
+  const recoveryHint = 'Archive failed exploratory runs with sdd run archive <run_id> --reason <text>, or rerun the subagent worker to supersede the failed dispatch; subagent evidence still cannot approve high-risk execution, truth-alignment, or ship.';
   if (status === 'missing') {
     return archived > 0 || superseded > 0
-      ? [`No active subagent dispatch projections block the main workflow; ignored archived=${archived} superseded=${superseded}. Main workflow still owns lifecycle gates, approvals, sync-back, and ship.`]
-      : ['No subagent dispatch projections recorded; main workflow remains unblocked and still owns lifecycle gates, approvals, sync-back, and ship.'];
+      ? [`No active subagent dispatch projections block the main workflow; ignored archived=${archived} superseded=${superseded}. Main workflow still owns lifecycle gates, approvals, truth-alignment, and ship.`]
+      : ['No subagent dispatch projections recorded; main workflow remains unblocked and still owns lifecycle gates, approvals, truth-alignment, and ship.'];
   }
   if (status === 'blocked') {
     return [`${blockingOpen} blocking subagent dispatch(es) are incomplete. Complete, rerun, or archive stale exploratory runs before doctor/ship; do not use partial subagent evidence as approval.`];
@@ -249,8 +249,8 @@ function subagentDispatchReasons(status: SubagentDispatchDiagnosticStatus, block
     return [`Subagent dispatch projection producer is incompatible with ${SUBAGENT_RUNTIME_PRODUCER_VERSION}; refresh the subagent projection before relying on its diagnostic evidence.`];
   }
   return archived > 0 || superseded > 0
-    ? [`Subagent dispatch projections are fresh and non-authoritative; ignored archived=${archived} superseded=${superseded}. Main workflow still owns approvals, sync-back, and ship.`]
-    : ['Subagent dispatch projections are fresh and non-authoritative; main workflow still owns approvals, sync-back, and ship.'];
+    ? [`Subagent dispatch projections are fresh and non-authoritative; ignored archived=${archived} superseded=${superseded}. Main workflow still owns approvals, truth-alignment, and ship.`]
+    : ['Subagent dispatch projections are fresh and non-authoritative; main workflow still owns approvals, truth-alignment, and ship.'];
 }
 
 function normalizeSubagentRelativePath(relativePath: string): string | null {
@@ -280,8 +280,8 @@ function safeAllowedWritePattern(pattern: string): boolean {
     || pattern === '**/*.spec.ts'
     || /(^|\/)\*\*\/\*\.(test|spec)\.ts$/.test(pattern)
     || /(^|\*)\.(test|spec)\.ts$/.test(pattern)
-    || pattern.startsWith('artifacts/')
-    || pattern.startsWith('.sdd/runs/');
+    || /^runs\/[^/]+\/(spec|plan|tasks|verifies|do|test|goal-verify|ship)\/[^/]+\.md$/.test(pattern)
+    || /^runs\/[^/]+\/(spec|plan|tasks|verifies|do|test|goal-verify|ship)\/\*\.md$/.test(pattern);
 }
 
 function matchesWritePattern(relativePath: string, pattern: string): boolean {

package/node_modules/@sdd-agent-platform/core/src/test-support/fixtures.ts

@@ -34,7 +34,7 @@ export function phase63ProjectRuntimeConfig(): string {
       forbidden_authority:
         - lifecycle gate authority
         - stage completion decision
-        - sync-back apply decision
+        - truth-alignment approval
         - ship readiness pass
         - permission escalation
       allowed_use: declarative taxonomy and capability mapping only

package/node_modules/@sdd-agent-platform/core/src/test-support/run-state.ts

@@ -1,8 +1,6 @@
-import { writeArtifact } from '../run-state/artifacts.js';
 import { readRunState, writeRunState } from '../run-state/run-state.js';
 import { inspectSddTask } from '../sdd-docs/task-inspection.js';
 import { parseSddBranch } from '../sdd-docs/task-parser.js';
-import { hashTestDocument } from './fixtures.js';
 
 export async function bindTestRunState(root: string, runId: string, branch: string, taskId: string): Promise<void> {
   const state = await readRunState(root, runId);
@@ -22,6 +20,7 @@ export async function bindTestRunState(root: string, runId: string, branch: stri
       specContractHash: model.documents.specContractHash ?? null,
       planContractHash: model.documents.planContractHash ?? null,
       tasksContractHash: model.documents.tasksContractHash ?? null,
+      taskContractHash: task?.contractHash ?? null,
       planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
       tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
       planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
@@ -30,41 +29,28 @@ export async function bindTestRunState(root: string, runId: string, branch: stri
   });
 }
 
-export async function markTestRunReadyForSyncBack(root: string, runId: string, taskId: string): Promise<void> {
+export async function markTestRunReadyForShip(root: string, runId: string, taskId: string): Promise<void> {
   const state = await readRunState(root, runId);
-  const proposal = 'status: verified\n';
-  await writeArtifact(root, runId, 'sync-back-proposal.md', proposal);
+  const evidence = [`artifacts/validation-${taskId}.md`];
   await writeRunState(root, {
     ...state,
     status: 'completed',
     tasks: {
       ...state.tasks,
       [taskId]: {
+        ...state.tasks[taskId],
         status: 'implemented_verified',
         implementationStatus: 'implemented',
         verificationStatus: 'pass',
-        validationBatch: null,
-        validationTiming: 'task_end',
-        requiresVerifyBeforeNext: true,
-        gaps: [],
-        artifacts: ['artifacts/sync-back-proposal.md']
+        validationStatus: 'pass',
+        artifacts: [...(state.tasks[taskId]?.artifacts ?? []), ...evidence]
       }
     },
     validation: {
       status: 'pass',
       commands: ['npm test'],
-      evidence: ['artifacts/sync-back-proposal.md']
-    },
-    syncBack: {
-      mode: 'proposal',
-      proposalPath: 'artifacts/sync-back-proposal.md',
-      proposalDigest: hashTestDocument(proposal),
-      sourceVerifyStatus: 'PASS',
-      status: 'proposed'
-    },
-    artifacts: [
-      ...state.artifacts,
-      { path: 'artifacts/sync-back-proposal.md', kind: 'sync_back_proposal', task: taskId, agent: null, createdAt: new Date().toISOString() }
-    ]
+      evidence
+    }
   });
 }
+

package/node_modules/@sdd-agent-platform/core/src/truth-reconciliation.test.ts

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import type { TruthAlignmentProjection } from './stage-collaboration.js';
+import { buildTruthReconciliationDecision, truthDriftClassForAlignment } from './truth-reconciliation.js';
+import { workflowNextIntent } from './workflow-state/resolve.js';
+
+test('truth reconciliation preserves accepted evidence for documentation catch-up', () => {
+  const decision = buildTruthReconciliationDecision({
+    truthAlignment: truthAlignment({
+      ownerStage: 'tasks',
+      semanticImpact: 'none',
+      invalidatesStages: ['tasks'],
+      staleRefs: [{ kind: 'document', ref: 'specs/master/tasks.md', hash: 'old-tasks-hash' }]
+    }),
+    nextIntent: workflowNextIntent('tasks', 'reconcile_truth', 'sdd tasks close --branch master --compact-json', 'Reconcile task document truth.', null, { targetRuntimeStage: 'tasks', resumeMode: 'reconcile' })
+  });
+
+  assert.equal(decision.changeKind, 'documentation_catchup');
+  assert.equal(decision.ownerStage, 'tasks');
+  assert.deepEqual(decision.minimalFrontier, ['tasks']);
+  assert.deepEqual(decision.preservesEvidenceRefs.map((ref) => ref.ref), ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/do/implementation-v1.md']);
+  assert.deepEqual(decision.supersedesEvidenceRefs, []);
+  assert.equal(decision.nextIntent.canonicalCommand.includes('sync-back'), false);
+});
+
+test('truth reconciliation supersedes accepted evidence for material implementation mismatch', () => {
+  const decision = buildTruthReconciliationDecision({
+    truthAlignment: truthAlignment({
+      ownerStage: 'do',
+      semanticImpact: 'material',
+      invalidatesStages: ['do'],
+      staleRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-implementation-hash' }]
+    }),
+    nextIntent: workflowNextIntent('do', 'reconcile_truth', 'sdd do task <task_id> --branch master', 'Reconcile implementation truth.', null, { targetRuntimeStage: 'do', resumeMode: 'reconcile' })
+  });
+
+  assert.equal(decision.changeKind, 'implementation_mismatch');
+  assert.equal(decision.ownerStage, 'do');
+  assert.deepEqual(decision.minimalFrontier, ['do', 'test', 'goal-verify', 'ship']);
+  assert.deepEqual(decision.preservesEvidenceRefs, []);
+  assert.deepEqual(decision.supersedesEvidenceRefs.map((ref) => ref.ref), ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/do/implementation-v1.md']);
+});
+
+test('truth drift taxonomy routes validation and gate mismatches to runtime owner stages', () => {
+  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: 'test', semanticImpact: 'bounded', invalidatesStages: [] }), 'validation_mismatch');
+  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: 'goal-verify', semanticImpact: 'bounded', invalidatesStages: [] }), 'gate_policy_mismatch');
+  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: null, semanticImpact: 'material', invalidatesStages: ['ship'] }), 'gate_policy_mismatch');
+});
+
+function truthAlignment(input: Pick<TruthAlignmentProjection, 'ownerStage' | 'semanticImpact' | 'invalidatesStages' | 'staleRefs'>): TruthAlignmentProjection {
+  return {
+    contract: 'sdd-truth-alignment-v1',
+    branch: 'master',
+    sourceStage: 'goal-verify',
+    declaredTruthRefs: [
+      { kind: 'document', ref: 'specs/master/spec.md', hash: 'spec-hash' },
+      { kind: 'document', ref: 'specs/master/tasks.md', hash: 'tasks-hash' }
+    ],
+    acceptedRealityRefs: [
+      { kind: 'artifact', ref: '.sdd/runs/master/goal-verify/goal-verification-v1.md', hash: 'goal-hash' },
+      { kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'implementation-hash' }
+    ],
+    status: 'drift_detected',
+    ownerStage: input.ownerStage,
+    semanticImpact: input.semanticImpact,
+    staleRefs: input.staleRefs,
+    invalidatesStages: input.invalidatesStages,
+    reasons: ['truth drift requires reconciliation'],
+    createdAt: '2026-06-01T00:00:00.000Z'
+  };
+}

package/node_modules/@sdd-agent-platform/core/src/truth-reconciliation.ts

@@ -0,0 +1,177 @@
+import type { RuntimeProjectionEnvelope, RuntimeRef, SddStage } from './contracts.js';
+import { TRUTH_RECONCILIATION_PROJECTION_TYPE, runtimeProjectionStableHash } from './runtime-projection-p0.js';
+import { listRuntimeProjections, recordRuntimeProjectionEnvelope, type RuntimeProjectionEnvelopeWriteResult } from './storage/runtime-store.js';
+import type { TruthAlignmentProjection } from './stage-collaboration.js';
+import type { WorkflowNextIntent } from './workflow-state/resolve.js';
+
+export const TRUTH_RECONCILIATION_CONTRACT = 'sdd-truth-reconciliation-v1' as const;
+export const TRUTH_RECONCILIATION_PRODUCER_VERSION = 'phase9.21-truth-reconciliation-v1' as const;
+
+export type TruthDriftClass = 'documentation_catchup' | 'clarification' | 'acceptance_change' | 'scope_change' | 'implementation_mismatch' | 'validation_mismatch' | 'gate_policy_mismatch';
+export type SemanticImpact = 'none' | 'bounded' | 'material';
+export type TruthReconciliationOwnerStage = SddStage;
+
+export interface TruthReconciliationDecision {
+  contract: typeof TRUTH_RECONCILIATION_CONTRACT;
+  branch: string;
+  ownerStage: TruthReconciliationOwnerStage;
+  changedRef: RuntimeRef;
+  oldHash: string;
+  newHash: string;
+  changeKind: TruthDriftClass;
+  semanticImpact: SemanticImpact;
+  preservesEvidenceRefs: RuntimeRef[];
+  supersedesEvidenceRefs: RuntimeRef[];
+  invalidatesStages: SddStage[];
+  minimalFrontier: SddStage[];
+  nextIntent: WorkflowNextIntent;
+  reasons: string[];
+}
+
+export const TRUTH_DRIFT_OWNER_STAGE: Record<TruthDriftClass, SddStage> = {
+  documentation_catchup: 'spec',
+  clarification: 'spec',
+  acceptance_change: 'tasks',
+  scope_change: 'spec',
+  implementation_mismatch: 'do',
+  validation_mismatch: 'test',
+  gate_policy_mismatch: 'goal-verify'
+};
+
+const STAGE_ORDER: readonly SddStage[] = ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
+const DOCUMENT_OWNER_STAGES = new Set<SddStage>(['spec', 'plan', 'tasks', 'verifies']);
+
+export function truthReconciliationScopeKey(input: Pick<TruthReconciliationDecision, 'branch' | 'changedRef'>): string {
+  return [input.branch, input.changedRef.ref, 'truth-reconciliation'].join(':');
+}
+
+export function buildTruthReconciliationDecision(input: { truthAlignment: TruthAlignmentProjection; nextIntent: WorkflowNextIntent; changedRef?: RuntimeRef; oldHash?: string; newHash?: string; changeKind?: TruthDriftClass }): TruthReconciliationDecision {
+  const changeKind = input.changeKind ?? truthDriftClassForAlignment(input.truthAlignment);
+  const ownerStage = truthReconciliationOwnerStage(changeKind, input.truthAlignment.ownerStage);
+  const changedRef = input.changedRef ?? firstRef(input.truthAlignment.staleRefs) ?? firstRef(input.truthAlignment.declaredTruthRefs) ?? { kind: 'projection', ref: `phase9_12_truth_alignment:${input.truthAlignment.branch}` };
+  const oldHash = input.oldHash ?? changedRef.hash ?? 'unknown';
+  const newHash = input.newHash ?? 'unknown';
+  const invalidatesStages = uniqueStages(input.truthAlignment.invalidatesStages);
+  const minimalFrontier = minimalReworkFrontier({ ownerStage, semanticImpact: input.truthAlignment.semanticImpact, invalidatesStages });
+  const preservesEvidenceRefs = input.truthAlignment.semanticImpact === 'material' ? [] : uniqueRuntimeRefs(input.truthAlignment.acceptedRealityRefs);
+  const supersedesEvidenceRefs = input.truthAlignment.semanticImpact === 'material' ? uniqueRuntimeRefs(input.truthAlignment.acceptedRealityRefs) : [];
+  return {
+    contract: TRUTH_RECONCILIATION_CONTRACT,
+    branch: input.truthAlignment.branch,
+    ownerStage,
+    changedRef,
+    oldHash,
+    newHash,
+    changeKind,
+    semanticImpact: input.truthAlignment.semanticImpact,
+    preservesEvidenceRefs,
+    supersedesEvidenceRefs,
+    invalidatesStages,
+    minimalFrontier,
+    nextIntent: input.nextIntent,
+    reasons: reconciliationReasons(input.truthAlignment, changeKind, ownerStage, minimalFrontier, preservesEvidenceRefs, supersedesEvidenceRefs)
+  };
+}
+
+export async function recordTruthReconciliationDecision(projectRoot: string, decision: TruthReconciliationDecision, generatedAt?: string): Promise<RuntimeProjectionEnvelopeWriteResult<TruthReconciliationDecision>> {
+  return recordRuntimeProjectionEnvelope(projectRoot, {
+    projectionType: TRUTH_RECONCILIATION_PROJECTION_TYPE,
+    scopeKey: truthReconciliationScopeKey(decision),
+    inputHash: runtimeProjectionStableHash(decision),
+    producer: 'phase9.21-truth-reconciliation-runtime',
+    producerVersion: TRUTH_RECONCILIATION_PRODUCER_VERSION,
+    generatedAt,
+    payload: decision
+  });
+}
+
+export async function readTruthReconciliationProjection(projectRoot: string, branch: string): Promise<RuntimeProjectionEnvelope<TruthReconciliationDecision> | null> {
+  const projections = await listRuntimeProjections(projectRoot, [TRUTH_RECONCILIATION_PROJECTION_TYPE]);
+  return projections
+    .map((projection) => projection.payload as RuntimeProjectionEnvelope<TruthReconciliationDecision>)
+    .filter((envelope) => envelope?.projectionType === TRUTH_RECONCILIATION_PROJECTION_TYPE && envelope.payload?.branch === branch)
+    .sort((left, right) => right.generatedAt.localeCompare(left.generatedAt))[0] ?? null;
+}
+
+export function truthDriftClassForAlignment(alignment: Pick<TruthAlignmentProjection, 'status' | 'ownerStage' | 'semanticImpact' | 'invalidatesStages'>): TruthDriftClass {
+  if (alignment.ownerStage === 'do' || alignment.invalidatesStages.includes('do')) {
+    return 'implementation_mismatch';
+  }
+  if (alignment.ownerStage === 'test' || alignment.invalidatesStages.includes('test')) {
+    return 'validation_mismatch';
+  }
+  if (alignment.ownerStage === 'goal-verify' || alignment.ownerStage === 'ship' || alignment.invalidatesStages.includes('goal-verify') || alignment.invalidatesStages.includes('ship')) {
+    return 'gate_policy_mismatch';
+  }
+  if (alignment.ownerStage === 'tasks' || alignment.ownerStage === 'verifies') {
+    return alignment.semanticImpact === 'none' ? 'documentation_catchup' : 'acceptance_change';
+  }
+  if (alignment.semanticImpact === 'none') {
+    return 'documentation_catchup';
+  }
+  if (alignment.semanticImpact === 'bounded') {
+    return 'clarification';
+  }
+  return 'scope_change';
+}
+
+export function truthReconciliationOwnerStage(changeKind: TruthDriftClass, alignmentOwnerStage: SddStage | null): SddStage {
+  if (changeKind === 'documentation_catchup' && alignmentOwnerStage && DOCUMENT_OWNER_STAGES.has(alignmentOwnerStage)) {
+    return alignmentOwnerStage;
+  }
+  if (changeKind === 'clarification' && alignmentOwnerStage && DOCUMENT_OWNER_STAGES.has(alignmentOwnerStage)) {
+    return alignmentOwnerStage;
+  }
+  return TRUTH_DRIFT_OWNER_STAGE[changeKind];
+}
+
+export function minimalReworkFrontier(input: { ownerStage: SddStage; semanticImpact: SemanticImpact; invalidatesStages: SddStage[] }): SddStage[] {
+  if (input.semanticImpact === 'none') {
+    return [input.ownerStage];
+  }
+  if (input.semanticImpact === 'bounded') {
+    return orderedUniqueStages([input.ownerStage, ...input.invalidatesStages]);
+  }
+  return orderedUniqueStages([input.ownerStage, ...input.invalidatesStages, ...downstreamStages(input.ownerStage)]);
+}
+
+function reconciliationReasons(alignment: TruthAlignmentProjection, changeKind: TruthDriftClass, ownerStage: SddStage, minimalFrontier: SddStage[], preservesEvidenceRefs: RuntimeRef[], supersedesEvidenceRefs: RuntimeRef[]): string[] {
+  return [
+    ...alignment.reasons,
+    `Truth drift ${changeKind} routes to ${ownerStage}-manager; stage remains the lifecycle boundary, not an actor.`,
+    `Minimal rework frontier: ${minimalFrontier.join(' -> ')}.`,
+    preservesEvidenceRefs.length > 0 ? `Preserves ${preservesEvidenceRefs.length} accepted evidence ref(s).` : 'No accepted evidence refs are preserved by this reconciliation decision.',
+    supersedesEvidenceRefs.length > 0 ? `Supersedes ${supersedesEvidenceRefs.length} accepted reality ref(s); new do/test evidence must be append-only.` : 'No accepted reality refs are superseded.'
+  ];
+}
+
+function downstreamStages(stage: SddStage): SddStage[] {
+  const index = STAGE_ORDER.indexOf(stage);
+  return index < 0 ? [] : [...STAGE_ORDER.slice(index + 1)];
+}
+
+function orderedUniqueStages(stages: SddStage[]): SddStage[] {
+  const set = new Set(stages);
+  return STAGE_ORDER.filter((stage) => set.has(stage));
+}
+
+function uniqueStages(stages: SddStage[]): SddStage[] {
+  return orderedUniqueStages(stages);
+}
+
+function uniqueRuntimeRefs(refs: RuntimeRef[]): RuntimeRef[] {
+  const seen = new Set<string>();
+  const result: RuntimeRef[] = [];
+  for (const ref of refs) {
+    const key = `${ref.kind}:${ref.ref}:${ref.hash ?? ''}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(ref);
+    }
+  }
+  return result;
+}
+
+function firstRef(refs: RuntimeRef[]): RuntimeRef | null {
+  return refs[0] ?? null;
+}

package/node_modules/@sdd-agent-platform/core/src/verification/goal-verify.test.ts

@@ -2,7 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { execFile } from 'node:child_process';
 import { DatabaseSync } from 'node:sqlite';
-import { mkdtemp, readFile, rm, utimes, writeFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
@@ -17,11 +17,8 @@ import { readArtifact, writeArtifact } from '../run-state/artifacts.js';
 import { appendEvent, readRunEvents } from '../run-state/events.js';
 import { listInvocationLedgerEntries } from '../run-state/invocation-ledger.js';
 import { inspectRun } from '../run-state/inspect-run.js';
-import { queryLocalRunIndex } from '../run-state/run-index.js';
-import { createRun, listRuns, readRunState, writeRunState } from '../run-state/run-state.js';
-import { applySyncBack } from '../sync-back/apply.js';
-import { inspectSyncBack } from '../sync-back/inspect.js';
-import { hashTestDocument, validResultArtifact, validTaskMarkdown, validTrustEvidence, writeBranchDocs } from '../test-support/fixtures.js';
+import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
+import { validResultArtifact, validTaskMarkdown, validTrustEvidence, writeBranchDocs } from '../test-support/fixtures.js';
 import { bindTestRunState } from '../test-support/run-state.js';
 import { getRuntimeStorePath } from '../runtime-paths.js';
 import { runGoalVerify } from './goal-verify.js';
@@ -194,7 +191,7 @@ test('runGoalVerify fails closed for cross-partition admitted evidence', async (
 });
 
 
-test('runGoalVerify maps validation evidence to acceptance and writes sync-back proposal', async () => {
+test('runGoalVerify maps validation evidence to acceptance coverage without legacy sync-back artifacts', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-pass-'));
   try {
     await initProject(root);
@@ -206,6 +203,7 @@ test('runGoalVerify maps validation evidence to acceptance and writes sync-back
     await bindTestRunState(root, state.runId, 'feature', 'T1');
     await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
     await writeArtifact(root, state.runId, 'validation-T1.md', `${validResultArtifact('validator', 'T1', 'PASS', 'artifacts/validation-T1.md')}${validTrustEvidence('T1', 'AC-1', 'artifacts/validation-T1.md')}`);
+    const tasksBeforeGoalVerify = await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8');
 
     const result = await runGoalVerify(root, {
       runId: state.runId,
@@ -216,9 +214,10 @@ test('runGoalVerify maps validation evidence to acceptance and writes sync-back
     });
     const restored = await readRunState(root, state.runId);
     const coverage = await readArtifact(root, state.runId, 'acceptance-coverage-T1.md');
-    const proposal = await readArtifact(root, state.runId, 'sync-back-proposal.md');
     const events = stringifyEvents(await readRunEvents(root, state.runId));
-    const tasksBeforeSyncBack = await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8');
+    const tasksAfterGoalVerify = await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8');
+    const inspection = await inspectRun(root, state.runId);
+    const status = await getProjectStatus(root, { branch: 'feature' });
 
     assert.equal(result.status, 'PASS');
     assert.equal(result.standardStatus, 'PASS');
@@ -228,42 +227,20 @@ test('runGoalVerify maps validation evidence to acceptance and writes sync-back
     assert.deepEqual(result.acceptanceCoverage.map((item) => item.acceptance), ['AC-1']);
     assert.match(coverage, /Acceptance Mapping/);
     assert.match(coverage, /AC-1/);
-    assert.match(proposal, /status: verified/);
-    assert.equal(restored.syncBack.proposalDigest, hashTestDocument(proposal));
-    assert.equal(restored.syncBack.sourceVerifyStatus, 'PASS');
     assert.match(events, /Phase 1.9 goal-level verify PASS/);
-    assert.match(tasksBeforeSyncBack, /status: pending/);
-
-    const runs = await listRuns(root);
-    const inspection = await inspectRun(root, state.runId);
-    const status = await getProjectStatus(root, { branch: 'feature' });
-    const syncBack = await inspectSyncBack(root, { runId: state.runId, branch: 'feature', taskId: 'T1' });
+    assert.equal(tasksAfterGoalVerify, tasksBeforeGoalVerify);
+    await assert.rejects(readArtifact(root, state.runId, 'sync-back-proposal.md'));
 
-    assert.equal(runs[0].runId, state.runId);
-    assert.equal(runs[0].validationStatus, 'pass');
-    assert.equal(runs[0].syncBackStatus, 'proposed');
     assert.equal(inspection.summary.runId, state.runId);
     assert.equal(inspection.validation.status, 'pass');
-    assert.equal(inspection.syncBack.status, 'proposed');
     assert.equal(inspection.eventCount > 0, true);
     assert.equal(inspection.recentEvents.length > 0, true);
     assert.equal(inspection.taskRunEvidence.version, 'phase-5.3-task-run-evidence-v1');
     assert.equal(inspection.taskRunEvidence.runId, state.runId);
     assert.equal(inspection.taskRunEvidence.validation.status, 'pass');
-    assert.equal(inspection.taskRunEvidence.syncBackProposal, 'artifacts/sync-back-proposal.md');
-    assert.equal(inspection.invocationLedger.some((entry) => entry.kind === 'artifact_hash' && entry.ref === 'artifacts/sync-back-proposal.md'), true);
-    assert.equal(inspection.taskRunEvidence.invocationLedger.some((entry) => entry.kind === 'artifact_hash' && entry.ref === 'artifacts/sync-back-proposal.md'), true);
     assert.equal(status.latestRun?.runId, state.runId);
     assert.equal(status.tasks.pending, 1);
-    assert.equal(status.recommendedNextCommand, 'sdd ship --branch feature --dry-run');
-    assert.equal(syncBack.status, 'ready');
-    assert.equal(syncBack.markdownStatus, 'pending');
-    assert.match(syncBack.proposal ?? '', /status: verified/);
-    assert.equal(syncBack.proposalDigest, restored.syncBack.proposalDigest);
-    assert.equal(syncBack.proposalDigestValid, true);
-    assert.equal(syncBack.applyPolicy.mode, 'confirm');
-    assert.equal(syncBack.applyPolicy.requiresApproval, true);
-    assert.equal(syncBack.applyPolicy.reasons.some((reason) => /source-boundary|CLI\/core source boundary/.test(reason)), true);
+    assert.equal(status.recommendedNextCommand, 'sdd ship close --branch feature --compact-json');
 
     const ledgerBeforeRerun = await listInvocationLedgerEntries(root, state.runId);
     await runGoalVerify(root, {
@@ -276,59 +253,8 @@ test('runGoalVerify maps validation evidence to acceptance and writes sync-back
     const ledgerAfterRerun = await listInvocationLedgerEntries(root, state.runId);
     assert.equal(ledgerAfterRerun.filter((entry) => entry.kind === 'artifact_hash').length, ledgerBeforeRerun.filter((entry) => entry.kind === 'artifact_hash').length);
     assert.equal(ledgerAfterRerun.filter((entry) => entry.kind === 'command' && entry.status === 'declared').length, ledgerBeforeRerun.filter((entry) => entry.kind === 'command' && entry.status === 'declared').length);
-
-    const applied = await applySyncBack(root, { runId: state.runId, branch: 'feature', taskId: 'T1', approved: true });
-    const tasksAfterSyncBack = await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8');
-    const appliedState = await readRunState(root, state.runId);
-    const appliedEvents = await readRunEvents(root, state.runId);
-
-    assert.equal(applied.applied, true);
-    assert.match(tasksAfterSyncBack, /status: completed/);
-    assert.match(tasksAfterSyncBack, /Sync-back applied from run `run-1`/);
-    assert.match(tasksAfterSyncBack, /sync-back-proposal\.md/);
-    assert.equal(appliedState.syncBack.status, 'applied');
-    assert.equal(appliedEvents.some((event) => event.event === 'sync_back_applied'), true);
-
-    const postApplyIndex = await queryLocalRunIndex(root, { runId: state.runId });
-    const postApplyDoctor = await doctor(root, { latestOnly: true });
-    const postApplyStatus = await getProjectStatus(root, { branch: 'feature' });
-
-    assert.equal(postApplyIndex.runs[0]?.syncBackStatus, 'applied');
-    assert.equal(appliedState.documentSnapshot.tasksHash, postApplyStatus.documents.tasksHash);
-    assert.deepEqual(postApplyStatus.latestRunStaleReasons, []);
-    assert.equal(postApplyDoctor.checks.some((check) => check.check === 'local_run_index' && check.level === 'WARN'), false);
-
-    const repeated = await applySyncBack(root, { runId: state.runId, branch: 'feature', taskId: 'T1' });
-    const repeatedTasks = await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8');
-
-    assert.equal(repeated.applied, false);
-    assert.equal(repeatedTasks.match(/Sync-back applied from run `run-1`/g)?.length, 1);
-
-    const reverified = await runGoalVerify(root, {
-      runId: state.runId,
-      branch: 'feature',
-      taskId: 'T1',
-      reviewArtifact: 'artifacts/review-T1.md',
-      validationArtifact: 'artifacts/validation-T1.md'
-    });
-    const reverifiedState = await readRunState(root, state.runId);
-    const reverifiedProposal = await readArtifact(root, state.runId, 'sync-back-proposal.md');
-    assert.equal(reverified.status, 'PASS');
-    assert.equal(reverifiedState.syncBack.status, 'applied');
-    assert.equal(reverifiedState.syncBack.proposalDigest, hashTestDocument(reverifiedProposal));
-
-    await writeRunState(root, { ...appliedState, documentSnapshot: restored.documentSnapshot });
-    const legacyAppliedStatus = await getProjectStatus(root, { branch: 'feature' });
-    assert.deepEqual(legacyAppliedStatus.latestRunStaleReasons, []);
-
-    await writeFile(path.join(root, 'specs', 'feature', 'tasks.md'), `${repeatedTasks}\n<!-- external edit after apply -->\n`, 'utf8');
-    const externalEditTime = new Date(Date.now() + 5000);
-    await utimes(path.join(root, 'specs', 'feature', 'tasks.md'), externalEditTime, externalEditTime);
-    const externallyChangedStatus = await getProjectStatus(root, { branch: 'feature' });
-    assert.equal(
-      externallyChangedStatus.latestRunStaleReasons.some((reason) => reason.includes('Run snapshot for tasks.md')),
-      true
-    );
+    assert.equal(await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8'), tasksBeforeGoalVerify);
+    await assert.rejects(readArtifact(root, state.runId, 'sync-back-proposal.md'));
   } finally {
     await rm(root, { recursive: true, force: true });
   }