sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/execution/host-invocation.ts

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 
 import { SDD_RESULT_CONTRACT, SDD_RESULT_VERSION } from '../contracts.js';
 import { writeArtifact } from '../run-state/artifacts.js';
+import { toEvidencePayloadFileName } from '../runtime-paths.js';
 
 export interface HostInvocationCommandOptions {
   command?: string;
@@ -41,7 +42,7 @@ export async function invokeClaudeCodeSubagentHost(input: HostInvocationInput):
   const args = resolveHostArgs(input.commandOptions?.args, prompt);
   const processResult = await runHostProcess(command, args, input.projectRoot, input.timeoutSeconds ?? 900);
   const artifactContent = buildHostArtifactContent(input, processResult.stdout, processResult.stderr, processResult.exitCode, processResult.signal, processResult.timedOut);
-  const written = await writeArtifact(input.projectRoot, input.runId, toArtifactRootRelativePath(input.expectedArtifact), artifactContent);
+  await writeArtifact(input.projectRoot, input.runId, toEvidencePayloadFileName(input.expectedArtifact), artifactContent);
 
   return {
     command,
@@ -49,7 +50,7 @@ export async function invokeClaudeCodeSubagentHost(input: HostInvocationInput):
     exitCode: processResult.exitCode,
     signal: processResult.signal,
     timedOut: processResult.timedOut,
-    artifactPath: written.runRelativePath,
+    artifactPath: input.expectedArtifact,
     stdoutBytes: Buffer.byteLength(processResult.stdout, 'utf8'),
     stderrBytes: Buffer.byteLength(processResult.stderr, 'utf8')
   };
@@ -68,8 +69,8 @@ Expected result artifact: ${input.expectedArtifact}
 
 Rules:
 - Work only on this one delegation.
-- Do not run sync-back, ship, or workflow transition commands.
-- Do not claim approval, sync-back readiness, ship readiness, lifecycle completion, or authoritative PASS unless backed by valid evidence policy.
+- Do not run ship or workflow transition commands.
+- Do not claim approval, truth-alignment readiness, ship readiness, lifecycle completion, or authoritative PASS unless backed by valid evidence policy.
 - Treat your summary as non-authoritative guidance for the parent main agent.
 - Do not bypass Claude Code permission prompts.
 - Never create, edit, delete, move, or rewrite production/source files.

package/node_modules/@sdd-agent-platform/core/src/execution/resident-worker.test.ts

@@ -12,6 +12,8 @@ import { inspectRun } from '../run-state/inspect-run.js';
 import { readRunState } from '../run-state/run-state.js';
 import { validResultArtifact, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
 import { writeVerifyContract } from '../verification/verify-contract.js';
+import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { runBackgroundExecutor } from './background-executor.js';
 import {
   claimResidentWorkerRuntime,
@@ -22,12 +24,18 @@ import {
   writeResidentWorkerRuntimeRecord
 } from './resident-worker.js';
 
+async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
+  const model = await parseSddBranch(root, branch);
+  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
+}
+
 test('resident worker runtime claim persists run-bound runtime evidence', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-resident-worker-claim-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const result = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-implementer-test', leaseSeconds: 60 });
     const runtime = await readResidentWorkerRuntimeRecord(root, result.runId, 'R-B1-implementer-test');
@@ -38,7 +46,7 @@ test('resident worker runtime claim persists run-bound runtime evidence', async
     assert.equal(result.status, 'claimed');
     assert.equal(result.delegationId, 'B-B1-implementer-001');
     assert.equal(runtime.runtimeId, 'R-B1-implementer-test');
-    assert.equal(runtime.expectedArtifact, 'artifacts/implementer-B1.md');
+    assert.equal(runtime.expectedArtifact, '.sdd/runs/master/do/implementer-B1.md');
     assert.equal(list.runtimes.length, 1);
     assert.equal(list.activeRuntimes, 1);
     assert.equal(inspection.workerRuntimes.length, 1);
@@ -54,6 +62,7 @@ test('resident worker runtime heartbeat renews lease without completing task', a
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const claimed = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-heartbeat', leaseSeconds: 60 });
     const before = claimed.runtime?.leaseExpiresAt;
@@ -78,6 +87,7 @@ test('resident worker runtime stale lease is visible to status and doctor', asyn
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const claimed = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-stale', leaseSeconds: 60 });
     assert.ok(claimed.runtime);
@@ -109,6 +119,7 @@ test('resident worker runtime heartbeat does not reopen terminal delegations', a
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const claimed = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-terminal', leaseSeconds: 60 });
     await writeArtifact(root, claimed.runId, 'implementer-B1.md', validResultArtifact('implementer', 'B1', 'PASS', 'artifacts/implementer-B1.md'));

package/node_modules/@sdd-agent-platform/core/src/execution/resident-worker.ts

@@ -4,7 +4,7 @@ import { RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
 import { contractIssue, messageFromError, type ContractValidationIssue } from '../contracts/issues.js';
 import { listDelegationQueueItems } from '../delegation/queue.js';
 import { isDelegationTerminal } from '../delegation/validation.js';
-import { getLegacyWorkerRuntimeRecordPath, getLegacyWorkerRuntimesDir } from '../runtime-paths.js';
+import { getLegacyWorkerRuntimeRecordPath, getLegacyWorkerRuntimesDir, toBranchStageEvidenceRef } from '../runtime-paths.js';
 import { appendEvent } from '../run-state/events.js';
 import { readRunState, writeRunState } from '../run-state/run-state.js';
 import { exists } from '../storage/json-io.js';
@@ -181,6 +181,7 @@ export async function claimResidentWorkerRuntime(projectRoot: string, options: R
   const state = await readRunState(projectRoot, backgroundResult.runId);
   const delegation = state.delegations[backgroundResult.delegationId];
   const now = new Date().toISOString();
+  const branch = state.gitBranch ?? state.partition ?? 'unscoped';
   const runtime: ResidentWorkerRuntimeRecord = {
     version: RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION,
     runtimeId,
@@ -190,7 +191,7 @@ export async function claimResidentWorkerRuntime(projectRoot: string, options: R
     workerAdapterId,
     delegationId: backgroundResult.delegationId,
     queueItemId: backgroundResult.queueItemId,
-    expectedArtifact: delegation?.expectedArtifact ?? `artifacts/${agent}-${options.taskId}.md`,
+    expectedArtifact: delegation?.expectedArtifact ?? toBranchStageEvidenceRef(branch, agent === 'validator' ? 'test' : 'do', `${agent}-${options.taskId}.md`),
     status: 'claimed',
     claimedAt: now,
     lastHeartbeatAt: null,

package/node_modules/@sdd-agent-platform/core/src/execution/stage-team-runtime.test.ts

@@ -8,7 +8,7 @@ test('stage role results reject lifecycle transition authority fields', () => {
   const result = roleResult({ payload: { final_pass: true } });
 
   assert.throws(() => assertValidStageRoleResult(result), /final_pass/);
-  assert.throws(() => assertValidStageRoleResult({ ...roleResult(), syncBackApproved: true }), /syncBackApproved/);
+  assert.throws(() => assertValidStageRoleResult({ ...roleResult(), truthAlignmentApproved: true }), /truthAlignmentApproved/);
   assert.doesNotThrow(() => assertValidStageRoleResult(roleResult()));
 });
 

package/node_modules/@sdd-agent-platform/core/src/execution/stage-team-runtime.ts

@@ -119,8 +119,8 @@ const FORBIDDEN_LIFECYCLE_FIELDS = new Set([
   'stagePassed',
   'task_completed',
   'taskCompleted',
-  'sync_back_approved',
-  'syncBackApproved',
+  'truth_alignment_approved',
+  'truthAlignmentApproved',
   'ship_ready',
   'shipReady',
   'final_pass',

package/node_modules/@sdd-agent-platform/core/src/execution/wave-executor.test.ts

@@ -11,14 +11,22 @@ import { createRun, readRunState } from '../run-state/run-state.js';
 import { graphTaskMarkdown, validResultArtifact, writeBranchDocs } from '../test-support/fixtures.js';
 import { writeVerifyContract } from '../verification/verify-contract.js';
 import { bindTestRunState } from '../test-support/run-state.js';
+import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { inspectWaveExecutor, runWaveExecutor } from './wave-executor.js';
 
+async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
+  const model = await parseSddBranch(root, branch);
+  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
+}
+
 test('wave executor completes planner-safe waves from supplied artifacts', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-executor-complete-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('WX1', [], ['src/a.ts'], [])}\n${graphTaskMarkdown('WX2', [], ['src/b.ts'], [])}`);
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
     const run = await createRun(root, { runId: 'run-1' });
     await bindTestRunState(root, run.runId, 'master', 'WX1');
     await writeArtifact(root, run.runId, 'implementer-WX1.md', validResultArtifact('implementer', 'WX1', 'PASS', 'artifacts/implementer-WX1.md'));
@@ -53,6 +61,7 @@ test('wave executor blocks manual and blocked planner gates before execution', a
     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 });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const result = await runWaveExecutor(root);
 
@@ -72,6 +81,7 @@ test('wave executor safe-continue finishes current safe wave but does not cross
     await initProject(root);
     await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('WX1', [], ['src/a.ts'], [])}\n${graphTaskMarkdown('WX2', [], ['src/b.ts'], [])}\n${graphTaskMarkdown('WX3', ['WX1'], ['src/c.ts'], [])}`);
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
     const run = await createRun(root, { runId: 'run-1' });
     await bindTestRunState(root, run.runId, 'master', 'WX1');
     await writeArtifact(root, run.runId, 'implementer-WX2.md', validResultArtifact('implementer', 'WX2', 'PASS', 'artifacts/implementer-WX2.md'));

package/node_modules/@sdd-agent-platform/core/src/governance/policy.test.ts

@@ -10,14 +10,22 @@ import { runBackgroundExecutor } from '../execution/background-executor.js';
 import { readRunEvents } from '../run-state/events.js';
 import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
 import { writeVerifyContract } from '../verification/verify-contract.js';
+import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { evaluateGovernancePolicy, inspectGovernancePolicy } from './policy.js';
 
+async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
+  const model = await parseSddBranch(root, branch);
+  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
+}
+
 test('governance policy explains confirmation and concurrency gates', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-governance-policy-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', `# Tasks\n\n${validTaskMarkdown('G1', [])}\n${validTaskMarkdown('G2', [])}\n${validTaskMarkdown('G3', [])}\n${validTaskMarkdown('G4', [])}\n${validTaskMarkdown('G5', [])}`);
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
     const policy = await inspectGovernancePolicy(root);
     const risky = await evaluateGovernancePolicy(root, { operation: 'destructive_git' });
 

package/node_modules/@sdd-agent-platform/core/src/governance/policy.ts

@@ -7,7 +7,7 @@ import { readFile } from 'node:fs/promises';
 import { listDelegationQueueItems } from '../delegation/queue.js';
 import { readAllRunStates } from '../run-state/run-state.js';
 
-export type GovernancePolicyOperation = 'background_executor' | 'wave_executor' | 'sync_back_apply' | 'destructive_git' | 'external_interaction' | 'cleanup';
+export type GovernancePolicyOperation = 'background_executor' | 'wave_executor' | 'destructive_git' | 'external_interaction' | 'cleanup';
 export type GovernancePolicyDecisionStatus = 'allow' | 'block' | 'confirm';
 
 export interface GovernancePolicy {
@@ -69,7 +69,7 @@ const BUILT_IN_GOVERNANCE_POLICY: GovernancePolicy = {
     maxWaveExecutors: 1
   },
   manualConfirmation: {
-    operations: ['sync_back_apply', 'destructive_git', 'external_interaction', 'cleanup'],
+    operations: ['destructive_git', 'external_interaction', 'cleanup'],
     workerAdapters: ['manual-handoff-worker'],
     riskTags: ['database', 'security', 'permission', 'external', 'destructive-git', 'data-loss']
   },

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

@@ -18,32 +18,47 @@ test('instructions API returns stable JSON contract payloads', () => {
   assert.equal(doctorPayload.requiredCommands.includes('sdd doctor fast --branch <branch>'), true);
   assert.equal(doctorPayload.forbiddenSideEffects.includes('background write'), true);
   assert.equal(doctorPayload.forbiddenSideEffects.includes('run deep historical scans unless explicitly requested'), true);
-  assert.equal(overviewPayload.requiredCommands.includes('sdd test task <task_id> --branch <branch>'), true);
-  assert.equal(overviewPayload.requiredCommands.includes('sdd test batch <batch_id> --branch <branch>'), true);
-  assert.equal(overviewPayload.requiredCommands.includes('sdd test wave --branch <branch> --wave <n>'), true);
-  assert.equal(overviewPayload.forbiddenSideEffects.includes('unapproved sync-back apply'), true);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd test <validation_unit_id-or-validation_text> --branch <branch>'), true);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd test task <task_id> --branch <branch>'), false);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd test batch <batch_id> --branch <branch>'), false);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd test wave --branch <branch> --wave <n>'), false);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd test close --branch <branch> --target goal-verify --json'), true);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd ship close --branch <branch> --json'), true);
+  assert.equal(overviewPayload.nextSteps.some((step) => /\/sdd:tasks/.test(step) && /\/sdd:test/.test(step)), true);
+  assert.doesNotMatch(JSON.stringify(overviewPayload), /sync-back|sync_back/);
   assert.match(overviewPayload.summary, /natural-language SDD intent/);
   assert.equal(overviewPayload.nextSteps.some((step) => /natural-language intent router/.test(step)), true);
   assert.equal(overviewPayload.nextSteps.some((step) => /ambiguous after status/.test(step)), true);
   assert.equal(initPayload.allowedSideEffects.includes('write managed generated AI entries'), true);
   assert.equal(initPayload.allowedSideEffects.includes('write specs/<branch>/spec.md'), false);
   assert.equal(initPayload.forbiddenSideEffects.some((item) => /legacy --scaffold-docs/.test(item)), true);
-  assert.match(planPayload.summary, /deliverable technical solution document/);
-  assert.equal(planPayload.nextSteps.some((step) => /PlantUML/.test(step)), true);
-  assert.equal(planPayload.nextSteps.some((step) => /state-machine/.test(step) && /api_schema/.test(step)), true);
+  assert.match(planPayload.summary, /plan-stage evidence/);
+  assert.equal(planPayload.requiredCommands.includes('sdd plan close --branch <branch> --json'), true);
+  assert.equal(planPayload.forbiddenSideEffects.includes('runtime-authored Markdown artifacts'), true);
   assert.match(specPayload.summary, /workflow partition entry/);
   assert.equal(specPayload.forbiddenSideEffects.includes('design technical solution in spec.md'), true);
   assert.equal(specPayload.nextSteps.some((step) => /AC-1/.test(step) && /verification hints/.test(step)), true);
-  assert.match(tasksPayload.summary, /task and verification contracts/);
-  assert.equal(tasksPayload.forbiddenSideEffects.includes('turn tasks.md into project-management backlog'), true);
-  assert.equal(tasksPayload.nextSteps.some((step) => /acceptance_refs/.test(step) && /plan_refs/.test(step)), true);
-  assert.equal(doPayload.requiredCommands.includes('sdd artifact template artifacts/<agent>-<task_id>.md --task <task_id> --agent <agent> --run <run_id> --write'), true);
-  assert.equal(doPayload.forbiddenSideEffects.includes('mark missing evidence as PASS'), true);
-  assert.equal(doPayload.nextSteps.some((step) => /--run <run_id> --write/.test(step) && /do not manually create copies/.test(step)), true);
+  assert.match(tasksPayload.summary, /tasks -> verifies/);
+  assert.equal(tasksPayload.requiredCommands.includes('sdd tasks close --branch <branch> --json'), true);
+  assert.equal(tasksPayload.requiredCommands.includes('sdd tasks close --branch <branch> --target verifies --json'), true);
+  assert.equal(tasksPayload.requiredCommands.includes('sdd verifies close --branch <branch> --json'), false);
+  assert.equal(tasksPayload.forbiddenSideEffects.includes('write verify.md before tasks close produces a fresh verifies handoff'), true);
+  assert.equal(doPayload.requiredCommands.includes('write .sdd/runs/<branch>/do/implementation-vN.md'), true);
+  assert.equal(doPayload.allowedSideEffects.includes('write agent-authored .sdd/runs/<branch>/do/*.md evidence files'), true);
+  assert.equal(doPayload.forbiddenSideEffects.includes('runtime-authored Markdown artifacts'), true);
+  assert.equal(doPayload.nextSteps.some((step) => /runtime must read .*\.sdd\/runs\/<branch>\/do\/\*\.md/.test(step) && /write only SQLite/.test(step)), true);
+  assert.equal(doPayload.requiredCommands.includes('sdd do task <task_id-or-task-text> --branch <branch>'), true);
+  assert.equal(doPayload.nextSteps.some((step) => /task id and accepted task title\/text are equivalent/.test(step)), true);
   const testPayload = getSddInstructions('test');
-  assert.equal(testPayload.requiredCommands.includes('sdd test batch <batch_id> --branch <branch>'), true);
-  assert.equal(testPayload.requiredCommands.includes('sdd test wave --branch <branch> --wave <n>'), true);
-  assert.equal(testPayload.nextSteps.some((step) => /batch_end or wave_end/.test(step)), true);
-  assert.equal(verifyPayload.requiredCommands.includes('sdd artifact validate <run_id> <artifact> --task <task_id> --agent validator'), true);
-  assert.equal(verifyPayload.forbiddenSideEffects.includes('unapproved sync-back apply'), true);
+  assert.equal(testPayload.requiredCommands.includes('sdd test close --branch <branch> --json'), true);
+  assert.equal(testPayload.requiredCommands.includes('sdd test close --branch <branch> --target goal-verify --json'), true);
+  assert.equal(testPayload.requiredCommands.includes('sdd test <validation_unit_id-or-validation_text> --branch <branch>'), true);
+  assert.equal(testPayload.requiredCommands.includes('sdd test task <task_id> --branch <branch>'), false);
+  assert.equal(testPayload.requiredCommands.includes('sdd goal-verify close --branch <branch> --json'), false);
+  assert.match(testPayload.summary, /test -> goal-verify/);
+  assert.match(testPayload.summary, /validation unit/);
+  assert.equal(testPayload.nextSteps.some((step) => /\.sdd\/runs\/<branch>\/test\/\*\.md/.test(step)), true);
+  assert.equal(testPayload.forbiddenSideEffects.includes('treat command success alone as semantic PASS'), true);
+  assert.equal(verifyPayload.requiredCommands.includes('sdd verify task <task_id> [--branch <branch>] [--run <run_id>]'), true);
+  assert.doesNotMatch(JSON.stringify(verifyPayload), /sync-back|sync_back/);
 });

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

@@ -2,7 +2,7 @@ import { SDD_VERSION } from './ai-tools.js';
 
 export const SDD_INSTRUCTIONS_CONTRACT = 'sdd-instructions-v1';
 
-export type InstructionAction = 'overview' | 'init' | 'doctor' | 'update' | 'spec' | 'plan' | 'tasks' | 'verifies' | 'test' | 'do' | 'verify' | 'sync-back' | 'ship' | 'run-task' | 'verify-task';
+export type InstructionAction = 'overview' | 'init' | 'doctor' | 'update' | 'spec' | 'plan' | 'tasks' | 'verifies' | 'test' | 'do' | 'verify' | 'ship' | 'run-task' | 'verify-task';
 
 export interface SddInstructionPayload {
   contract: typeof SDD_INSTRUCTIONS_CONTRACT;
@@ -17,25 +17,25 @@ export interface SddInstructionPayload {
 
 const INSTRUCTION_PAYLOADS: Record<InstructionAction, Omit<SddInstructionPayload, 'contract' | 'version' | 'action'>> = {
   overview: {
-    summary: 'Route natural-language SDD intent from branch/source status to task execution, agent evidence, strict verification-contract consumption, and release readiness while keeping CLI/core output as source of truth.',
-    requiredCommands: ['sdd status', 'sdd lifecycle decide --from-text <text>', 'sdd doctor', 'sdd tasks inspect <task_id>', 'sdd do task <task_id>', 'sdd test task <task_id> --branch <branch>', 'sdd test batch <batch_id> --branch <branch>', 'sdd test wave --branch <branch> --wave <n>', 'sdd ship --branch <branch> --dry-run', 'sdd instructions ship --json'],
+    summary: 'Route natural-language SDD intent from branch/source status to task execution, agent evidence, strict verification-contract consumption, goal verification, truthAlignment, and release readiness while keeping CLI/core output as source of truth.',
+    requiredCommands: ['sdd status', 'sdd lifecycle decide --from-text <text>', 'sdd doctor', 'sdd tasks inspect <task_id>', 'sdd do task <task_id-or-task-text>', 'sdd test <validation_unit_id-or-validation_text> --branch <branch>', 'sdd test close --branch <branch> --target goal-verify --json', 'sdd ship close --branch <branch> --json', 'sdd instructions ship --json'],
     allowedSideEffects: ['read .sdd state', 'read specs documents', 'read generated AI entries'],
-    forbiddenSideEffects: ['background write', 'worktree creation', 'auto commit', 'force push', 'unapproved sync-back apply', 'publish or push release artifacts without explicit human confirmation'],
+    forbiddenSideEffects: ['background write', 'worktree creation', 'auto commit', 'force push', 'publish or push release artifacts without explicit human confirmation'],
     nextSteps: [
       'Treat /sdd as a natural-language intent router, then run sdd status first to see branch/source context and the recommended next command; report only workflow state, blocker/current task, and next action unless the user asks for full detail.',
       'Dynamic routing comes from CLI/core output; follow the recommended next command and do not infer dynamic state from generated markdown.',
+      'Use /sdd:tasks as the user-visible bundle for tasks -> verifies, and /sdd:test as the user-visible bundle for test -> goal-verify; do not invent separate slash entries for internal substages.',
       'If intent remains ambiguous after status, ask one clarifying question before spec/plan/tasks/do/test/ship work.',
-      'If status reports generated entry drift, missing config, compatibility drift, or legacy sync-back state, run sdd doctor and use diagnostic/recovery commands before normal do/test/ship.',
-      'If status recommends a pending task, run sdd tasks inspect <task_id> and execute only the approved task boundary; scout/implementer/reviewer/validator participation should be recorded as artifacts rather than hidden in the main chat.',
-      'For test, follow the task contract boundary: strict/task_end work uses sdd test task, batch_end work uses sdd test batch, and wave_end work uses sdd test wave; pass --run only for replay, CI, or old-run inspection.',
-      'After the selected test boundary returns PASS, proceed to a decision card if policy requires one, otherwise run `sdd ship --branch <branch> --dry-run`.',
-      'Use `sdd sync-back inspect|apply` only for explicit diagnostic, recovery, replay, or legacy compatibility work; do not add it as a normal happy-path step.'
+      'If status reports generated entry drift, missing config, compatibility drift, or projection drift, run sdd doctor and follow its current-run repair or rebuild recommendation before normal do/test/ship.',
+      'If status recommends a pending task, run sdd tasks inspect <task_id> and execute only the approved task boundary; scout/implementer/reviewer/validator participation should be recorded as stage evidence rather than hidden in the main chat.',
+      'For test, bind user intent to an accepted verify.md validation unit with sdd test <validation_unit_id-or-validation_text>; use task/batch/wave subcommands only for explicit low-level diagnostics or narrowed overrides.',
+      'After test closure is accepted, continue through /sdd:test with sdd test close --target goal-verify so runtime can record truthAlignment before ship readiness.'
     ]
   },
   init: {
     summary: 'Initialize .sdd project configuration and managed AI tool entries for the current repository; workflow partition documents are entered through the spec stage, not init.',
     requiredCommands: ['sdd init --ai claude-code', 'sdd status', 'sdd instructions spec --json', 'sdd doctor'],
-    allowedSideEffects: ['write .sdd/project.yml', 'write .sdd/runs', 'write managed generated AI entries'],
+    allowedSideEffects: ['write .sdd/project.yml', 'initialize runtime.sqlite state', 'write managed generated AI entries'],
     forbiddenSideEffects: ['create workflow partition documents unless explicitly using the spec stage or legacy --scaffold-docs', 'overwrite foreign AI entry files', 'background write', 'auto commit'],
     nextSteps: ['Run sdd init --ai claude-code.', 'Run sdd status to inspect current Git branch partition state and the recommended next command.', 'Use the spec stage to create or refine specs/<partition>/spec.md; omitted --branch uses the current Git branch, explicit --branch uses the requested partition.', 'Run sdd doctor after initialization.']
   },
@@ -61,74 +61,67 @@ const INSTRUCTION_PAYLOADS: Record<InstructionAction, Omit<SddInstructionPayload
     nextSteps: ['Resolve the workflow partition: omit --branch to use the current Git branch, or pass --branch <name> only when intentionally writing another partition.', 'Clarify user intent, objective/customer value, actors, scenarios, scope, and non-goals.', 'Run sdd lifecycle decide --from-text <text> when changes mention state-machine, concurrency, database, SQL, security, API/schema, CI/build, or external unknown risk.', 'Write acceptance criteria with stable IDs such as AC-1 and verification hints.', 'Record assumptions/dependencies, risks/hard gates, open questions, and lifecycle reference.', 'If this is a requirement change after plan/tasks/run work exists, update spec.md and let status expose stale downstream hashes before continuing.', 'Stop before technical design or implementation when requirement gaps remain.']
   },
   plan: {
-    summary: 'Refine specs/<partition>/plan.md as a deliverable technical solution document that bridges approved spec requirements into task-ready design and records based_on_spec_hash.',
-    requiredCommands: ['sdd status', 'read specs/<partition>/spec.md', 'read specs/<partition>/plan.md', 'write specs/<partition>/plan.md'],
-    allowedSideEffects: ['read project context', 'read spec document', 'write proposed or approved technical solution plan document'],
-    forbiddenSideEffects: ['implement code', 'silently advance to tasks', 'bypass unresolved spec gaps'],
-    nextSteps: ['Read the approved spec and acceptance criteria plus the current spec hash from sdd status.', 'Record based_on_spec_hash in plan.md so later spec-stage revisions can mark this plan stale.', 'Write plan.md as a technical solution document: background, goals/non-goals, current state, target design, architecture/component impact, interaction/sequence design, state/data design, API/schema design, concurrency/transaction/consistency design, key decisions, alternatives, risk control, rollout/rollback, validation matrix, and task breakdown rationale.', 'Use PlantUML diagrams when they clarify component impact, sequence/activity flow, state machines, or deployment/data relationships.', 'Apply risk-driven requirements: state-machine needs state design, concurrency needs sequence/activity and consistency design, database needs data/transaction/rollback design, api_schema needs interface/schema compatibility, security/sql needs risk control.', 'Stop with explicit plan gaps and tasks readiness.']
+    summary: 'Refine specs/<partition>/plan.md and .sdd/runs/<branch>/plan/*.md as agent-authored plan-stage evidence, then let runtime close validate refs/hashes/contracts into SQLite.',
+    requiredCommands: ['sdd status', 'read specs/<partition>/spec.md', 'write specs/<partition>/plan.md', 'write .sdd/runs/<branch>/plan/plan-review-vN.md', 'write .sdd/runs/<branch>/plan/plan-manager-vN.md', 'write .sdd/runs/<branch>/plan/plan-collaboration-contract-vN.md', 'sdd plan close --branch <branch> --json'],
+    allowedSideEffects: ['read project context', 'read spec document', 'write agent-authored plan-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/plan/'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'implement code', 'silently advance to tasks', 'bypass unresolved spec gaps'],
+    nextSteps: ['Read the approved spec and acceptance criteria plus the current normalized spec contract hash from sdd status.', 'Do not write based_on_* hash metadata into plan.md; accepted dependency edges belong to runtime close/accept projections.', 'Have planner/reviewer/plan-manager author plan-stage Markdown evidence under .sdd/runs/<branch>/plan/ including a StageCollaborationContract.', 'Run sdd plan close --branch <branch> --json; runtime must validate refs/frontmatter/contracts, compute hashes, and write only .sdd/runtime.sqlite.', 'Stop with explicit plan gaps and tasks readiness; do not let runtime create or repair Markdown.']
   },
   tasks: {
-    summary: 'Refine specs/<partition>/tasks.md and specs/<partition>/verify.md as frozen task and verification contracts with implementation waves, validation waves, and review gate declarations.',
-    requiredCommands: ['sdd status', 'read specs/<partition>/spec.md', 'read specs/<partition>/plan.md', 'sdd tasks format', 'write specs/<partition>/tasks.md', 'write specs/<partition>/verify.md', 'sdd tasks list', 'sdd tasks gaps', 'sdd verifies inspect --branch <branch>'],
-    allowedSideEffects: ['read spec and plan documents', 'write proposed or approved task execution/evidence contract', 'write task-derived verify contract'],
-    forbiddenSideEffects: ['implement code', 'execute dependency waves', 'run validation commands', 'silently advance to do', 'turn tasks.md into project-management backlog'],
-    nextSteps: ['Read approved spec acceptance IDs, approved plan design sections, and the current plan hash from sdd status.', 'Record based_on_plan_hash in tasks.md so later plan/spec revisions can mark these tasks stale.', 'Run sdd tasks format to get the canonical block format.', 'Map every task to acceptance_refs and plan_refs where applicable.', 'Declare change_surface, implementation_wave, validation_batch, validation_timing, requires_verify_before_next, required artifacts, and review gates before freezing tasks.', 'Use validation_timing task_end and requires_verify_before_next true for strict/high-risk tasks; use batch_end or wave_end with validation_batch only when sequential accumulation is safe.', 'Have the verification-designer produce verify.md from the frozen task contract, then inspect it with sdd verifies inspect --branch <branch>.', 'Keep #### Boundary, #### Acceptance, #### Definition of Done, #### Evidence Expectations, and #### Implementation Notes as companion sections outside the ```sdd-task fenced block; keep only metadata inside the fence.', 'Frontend-only tasks must not declare Maven/Gradle backend build validation.', 'For risky tasks, include allowed_agents, required_artifacts, verification_availability, and autonomy.', 'Run sdd tasks list and sdd tasks gaps.', 'Stop before do task when task boundary, acceptance refs, plan refs, evidence requirements, validation batches/waves, or verify expectations are unclear.']
+    summary: 'Use /sdd:tasks as the user-visible bundle for tasks -> verifies: refine specs/<partition>/tasks.md and .sdd/runs/<branch>/tasks/*.md first, then continue through the same bundle when runtime handoff targets verifies.',
+    requiredCommands: ['sdd status', 'read specs/<partition>/spec.md', 'read specs/<partition>/plan.md', 'sdd tasks format', 'write specs/<partition>/tasks.md', 'write .sdd/runs/<branch>/tasks/tasks-review-vN.md', 'write .sdd/runs/<branch>/tasks/tasks-manager-vN.md', 'write .sdd/runs/<branch>/tasks/tasks-collaboration-contract-vN.md', 'sdd tasks close --branch <branch> --json', 'write specs/<partition>/verify.md', 'write .sdd/runs/<branch>/verifies/verifies-review-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-manager-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-collaboration-contract-vN.md', 'sdd tasks close --branch <branch> --target verifies --json'],
+    allowedSideEffects: ['read spec and plan documents', 'write agent-authored tasks-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/tasks/', 'write agent-authored verifies-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/verifies/ after a runtime handoff to verifies'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'write verify.md before tasks close produces a fresh verifies handoff', 'implement code', 'execute dependency waves', 'run validation commands', 'silently advance to do', 'turn tasks.md into project-management backlog'],
+    nextSteps: ['Read approved spec acceptance IDs, approved plan design sections, and the current normalized plan contract hash from sdd status.', 'Do not write based_on_* hash metadata into tasks.md; accepted dependency edges belong to runtime close/accept projections.', 'Run sdd tasks format to get the canonical block format.', 'Map every task to acceptance_refs and plan_refs where applicable.', 'Declare change_surface, implementation_wave, validation_batch, validation_timing, requires_verify_before_next, evidence expectations, and review gates before freezing tasks.', 'Have task-planner/reviewer/tasks-manager author .sdd/runs/<branch>/tasks/*.md evidence including a StageCollaborationContract.', 'Run sdd tasks close --branch <branch> --json; runtime must validate refs/frontmatter/contracts, compute hashes, and write only .sdd/runtime.sqlite.', 'If runtime/status targets verifies inside the tasks bundle, have verification-designer/reviewer/verifies-manager author specs/<branch>/verify.md plus .sdd/runs/<branch>/verifies/*.md evidence.', 'Continue with sdd tasks close --branch <branch> --target verifies --json; runtime must validate verifies refs/contracts and return the next legal route.']
   },
   verifies: {
-    summary: 'Create or inspect specs/<partition>/verify.md as the task-derived verification contract before runtime evidence execution.',
-    requiredCommands: ['sdd status', 'sdd tasks list --branch <branch>', 'sdd verifies inspect --branch <branch>', 'sdd verifies write --branch <branch>'],
-    allowedSideEffects: ['read spec, plan, and tasks documents', 'write specs/<partition>/verify.md when explicitly using write'],
-    forbiddenSideEffects: ['run validation commands', 'update runtime.sqlite run state', 'create sync-back proposal', 'modify source files', 'auto commit'],
-    nextSteps: ['Run sdd status and confirm tasks.md is current.', 'Run sdd verifies inspect --branch <branch> to check whether verify.md exists and matches the current tasks hash.', 'Run sdd verifies write --branch <branch> to create verify.md, or add --force after reviewing task contract changes.', 'Use verify.md to guide validator evidence expectations; do not treat it as runtime evidence or as a replacement for `sdd test task|batch|wave`.']
+    summary: 'Diagnostic/internal action for verifies-stage closure; normal users enter it through /sdd:tasks with target=verifies.',
+    requiredCommands: ['sdd status', 'read specs/<partition>/tasks.md', 'write specs/<partition>/verify.md', 'write .sdd/runs/<branch>/verifies/verifies-review-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-manager-vN.md', 'write .sdd/runs/<branch>/verifies/verifies-collaboration-contract-vN.md', 'sdd tasks close --branch <branch> --target verifies --json'],
+    allowedSideEffects: ['read spec, plan, and tasks documents', 'write agent-authored verifies-stage Markdown under specs/<branch>/ and .sdd/runs/<branch>/verifies/'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'run validation commands', 'modify source files', 'auto commit'],
+    nextSteps: ['Run sdd status and confirm tasks.md is current.', 'Have verification-designer/reviewer/verifies-manager author verify.md plus .sdd/runs/<branch>/verifies/*.md evidence including a StageCollaborationContract.', 'Continue through sdd tasks close --branch <branch> --target verifies --json; runtime must validate refs/frontmatter/hashes/contracts and write only .sdd/runtime.sqlite.', 'Keep direct verifies-stage entry as diagnostic/recovery only, not the normal Phase 9 happy path.', 'Use accepted verify.md to guide later test evidence expectations; do not treat it as runtime-authored evidence.']
   },
   test: {
-    summary: 'Execute validation commands from the frozen tasks.md + verify.md contract boundary, capture command output, evaluate acceptance evidence coverage, and return one unified task, batch, or wave judgment without authoring verify.md.',
-    requiredCommands: ['sdd status', 'sdd test task <task_id> --branch <branch>', 'sdd test batch <batch_id> --branch <branch>', 'sdd test wave --branch <branch> --wave <n>'],
-    allowedSideEffects: ['run declared validation commands', 'write branch-scoped test evidence artifacts', 'update runtime.sqlite test run and validation wave records', 'write validator evidence artifact'],
-    forbiddenSideEffects: ['modify source files outside the validation command effects', 'author or refresh verify.md', 'apply sync-back', 'auto commit', 'publish or push', 'treat command success alone as semantic PASS'],
-    nextSteps: ['Run sdd status and resolve the task, batch, or wave boundary plus branch.', 'Confirm verify.md exists and is current for the selected branch; if it is missing or stale, return to /sdd:tasks or use explicit sdd verifies write recovery before executing tests.', 'Use sdd test task <task_id> --branch <branch> for strict/task_end tasks or deliberate narrowed overrides with --run, --command, --command-json, --command-file, or passthrough argv.', 'Use sdd test batch <batch_id> --branch <branch> or sdd test wave --branch <branch> --wave <n> for batch_end or wave_end tasks so accumulated implementation evidence is judged together.', 'Inspect the generated command logs, test index, validator artifacts, acceptance maps, and workflow gate decision.', 'If the selected test boundary returns PASS, proceed to a decision card if policy requires one, otherwise run `sdd ship --branch <branch> --dry-run`; if it returns FAIL or BLOCKED, fix the reported command/evidence gaps and rerun the same boundary.']
+    summary: 'Use /sdd:test as the user-visible bundle for test -> goal-verify: bind validation intent to an accepted verify.md validation unit, close test-stage evidence, then continue through the same bundle so runtime records truthAlignment before ship.',
+    requiredCommands: ['sdd status', 'sdd instructions test --json', 'sdd test <validation_unit_id-or-validation_text> --branch <branch>', 'write .sdd/runs/<branch>/test/test-execution-vN.md', 'write .sdd/runs/<branch>/test/test-review-vN.md', 'write .sdd/runs/<branch>/test/test-manager-vN.md', 'write .sdd/runs/<branch>/test/test-collaboration-contract-vN.md', 'sdd test close --branch <branch> --json', 'write .sdd/runs/<branch>/goal-verify/goal-verification-vN.md', 'sdd test close --branch <branch> --target goal-verify --json'],
+    allowedSideEffects: ['run declared validation-unit commands', 'write agent-authored .sdd/runs/<branch>/test/*.md evidence', 'write agent-authored .sdd/runs/<branch>/goal-verify/*.md evidence after a runtime handoff to goal-verify', 'update runtime.sqlite validation and closure projections'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'modify source files outside validation command effects', 'author or refresh verify.md', 'auto commit', 'publish or push', 'treat command success alone as semantic PASS'],
+    nextSteps: ['Run sdd status and resolve the verify.md validation-unit boundary plus branch.', 'Confirm accepted verify.md exists for the selected branch; if missing or stale, return through the /sdd:tasks bundle with target=verifies.', 'Run the declared validation unit through sdd test <validation_unit_id-or-validation_text>; PASS command output stays in runtime read models by default, while failure/blocker diagnostics may retain scoped payload refs.', 'Use sdd test task|batch|wave only for explicit low-level diagnostics, replay, or narrowed override flags.', 'Have test-runner/reviewer/test-manager author .sdd/runs/<branch>/test/*.md evidence including a StageCollaborationContract.', 'Run sdd test close --branch <branch> --json; runtime validates evidence refs/contracts and writes only .sdd/runtime.sqlite.', 'If runtime/status targets goal-verify inside the test bundle, have goal-verifier/reviewer author .sdd/runs/<branch>/goal-verify/*.md evidence.', 'Continue with sdd test close --branch <branch> --target goal-verify --json; runtime records truthAlignment before ship readiness.']
   },
   do: {
-    summary: 'Execute one approved task boundary through the ingestion-aware SDD task workflow with explicit scout/implementer/reviewer/validator evidence handoff.',
-    requiredCommands: ['sdd status', 'sdd instructions do --json', 'sdd tasks inspect <task_id>', 'sdd artifact template artifacts/<agent>-<task_id>.md --task <task_id> --agent <agent> --run <run_id> --write', 'sdd artifact validate <run_id> <artifact> --task <task_id> --agent <agent>', 'sdd do task <task_id>'],
-    allowedSideEffects: ['write branch-scoped .sdd/runs evidence artifacts', 'update runtime.sqlite run state', 'modify files within selected task boundary'],
-    forbiddenSideEffects: ['background write', 'worktree creation', 'auto commit', 'expand beyond selected task boundary without checkpoint', 'mark missing evidence as PASS'],
-    nextSteps: ['Run sdd status and resolve exactly one task id from the user request or recommended next command.', 'Run sdd instructions do --json and sdd tasks inspect <task_id>.', 'Restate only the task Boundary, blocking gaps, and validation commands before implementation.', 'Use scout for bounded context only, implementer for selected-boundary edits, reviewer for review evidence, and validator for validation plus acceptance mapping.', 'Create or resolve the task run id, then write implement/review/validation result artifacts only with sdd artifact template artifacts/<agent>-<task_id>.md --task <task_id> --agent <agent> --run <run_id> --write; do not manually create copies under specs/<branch>/artifacts/ or specs/<branch>/evidence/artifacts/.', 'Pass run-relative artifacts/<file> paths to CLI flags, and keep source/test files in ## Evidence, not in sdd-result.artifacts.', 'Run sdd artifact validate before passing artifacts into sdd do task <task_id>.', 'Run or coordinate implementation only within the selected task boundary.', 'Run sdd do task <task_id> with explicit artifact paths when evidence is available.', 'Report run id, final status, blocking gaps, and next gate; if completed, follow sdd status recommended next command: continue sequential sdd do task, run sdd test task for strict/task_end work, or run sdd test batch / sdd test wave at the declared validation boundary.']
+    summary: 'Semantically bind /sdd:do or sdd do task input to one accepted task boundary, then run do-stage collaboration: implementer/reviewer/do-manager write .sdd/runs/<branch>/do/*.md evidence and runtime reconciles gate truth into SQLite.',
+    requiredCommands: ['sdd status', 'sdd instructions do --json', 'sdd tasks inspect <bound_task_id>', 'write/update source files within the bound task boundary', 'write .sdd/runs/<branch>/do/implementation-vN.md', 'write .sdd/runs/<branch>/do/code-review-vN.md', 'write .sdd/runs/<branch>/do/do-manager-vN.md', 'sdd do task <task_id-or-task-text> --branch <branch>'],
+    allowedSideEffects: ['modify files within selected task boundary', 'write agent-authored .sdd/runs/<branch>/do/*.md evidence files', 'update runtime.sqlite projections and run state'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'background write', 'worktree creation', 'auto commit', 'expand beyond selected task boundary without checkpoint', 'mark missing evidence as PASS'],
+    nextSteps: ['Run sdd status, then let CLI/core bind the user request or recommended next command to exactly one accepted task boundary; task id and accepted task title/text are equivalent when they bind to the same task.', 'If binding is ambiguous, missing, stale, or boundary-expanding, stop and follow the CLI nextAction instead of implementing.', 'Run sdd instructions do --json and sdd tasks inspect <bound_task_id>.', 'Restate only the bound task Boundary, blocking gaps, and validation commands before implementation.', 'Implement only within affected_files and capture changed file refs/hashes in .sdd/runs/<branch>/do/implementation-vN.md frontmatter.', 'Have code-reviewer write .sdd/runs/<branch>/do/code-review-vN.md against the implementation evidence hash, whether approved or blocked.', 'Have do-manager write .sdd/runs/<branch>/do/do-manager-vN.md as a closure request that references the reviewed implementation and review hash.', 'Run sdd do task <task_id-or-task-text> --branch <branch>; runtime must read .sdd/runs/<branch>/do/*.md, validate frontmatter/hash/review/manager closure, and write only SQLite projections/run state.', 'Report run id, final status, binding target, blocking gaps, accepted evidence refs, and next gate; for verification proceed to sdd test <validation_unit_id-or-validation_text> --branch <branch>.']
   },
   verify: {
-    summary: 'Run compatibility/diagnostic task acceptance coverage from reviewer/validator artifacts, resolving the latest eligible run from partition + task id unless --run is explicit; `sdd test task|batch|wave` is the primary runtime gate.',
-    requiredCommands: ['sdd status', 'sdd instructions verify --json', 'sdd artifact template artifacts/validation-<task_id>.md --task <task_id> --agent validator --run <run_id> --write', 'sdd artifact validate <run_id> <artifact> --task <task_id> --agent validator', 'sdd verify task <task_id> [--branch <branch>] [--run <run_id>]'],
-    allowedSideEffects: ['write acceptance coverage artifact', 'update runtime.sqlite diagnostic verification state'],
-    forbiddenSideEffects: ['auto commit', 'force push', 'auto-fix failures', 'create sync-back proposal as normal happy path', 'unapproved sync-back apply', 'mark completed with blocking validation gaps'],
-    nextSteps: ['Run sdd status and resolve exactly one task id plus workflow partition from the recommended command or user request.', 'Omit --run by default so CLI resolves the latest eligible run for partition + task id; pass --run only for explicit replay, CI, or old-run inspection.', 'Ensure the validator artifact includes exact Acceptance text, preferably under ## Acceptance Mapping from sdd artifact template.', 'When a validator artifact must be created manually for a run, write it only with sdd artifact template artifacts/validation-<task_id>.md --task <task_id> --agent validator --run <run_id> --write; do not manually create copies under specs/<branch>/artifacts/ or specs/<branch>/evidence/artifacts/.', 'Pass run-relative artifacts/<file> paths to validate/verify CLI flags.', 'Run sdd artifact validate before compatibility verify.', 'Run sdd instructions verify --json and sdd verify task <task_id> --branch <branch> only for explicit low-level diagnostics.', 'For the primary lifecycle path, use `sdd test task|batch|wave`; after PASS proceed to a decision card if policy requires one or `sdd ship --branch <branch> --dry-run`.', 'Report PASS/BLOCKED status and unresolved blockers; avoid pasting full acceptance coverage unless requested.']
-  },
-  'sync-back': {
-    summary: 'Inspect or replay verified task completion write-back state for diagnostic, recovery, replay, and legacy compatibility use.',
-    requiredCommands: ['sdd status', 'sdd instructions sync-back --json', 'sdd sync-back inspect [<run_id>] --branch <branch> --task <task_id>', 'sdd sync-back apply [<run_id>] --branch <branch> --task <task_id> [--approved]'],
-    allowedSideEffects: ['read runtime.sqlite run state', 'read sync-back proposal artifact', 'read specs/<partition>/tasks.md', 'write specs/<partition>/tasks.md during apply', 'write specs/<partition>/verify.md only when explicit --refresh-verify is supplied', 'update run sync_back state only during apply'],
-    forbiddenSideEffects: ['auto commit', 'force push', 'apply without inspect', 'apply confirm-required proposals without human approval', 'change source files outside tasks.md'],
-    nextSteps: ['Run sdd status and resolve exactly one task id plus workflow partition from an explicit diagnostic, recovery, replay, CI, or old-run inspection request.', 'Run sdd sync-back inspect --branch <branch> --task <task_id> first; pass an explicit run id only for replay, CI, or old-run inspection.', 'Report the inspect target update before asking for approval: target tasks file, task id, markdown status transition, proposal path, evidence artifacts, apply_policy, and policy reasons.', 'If apply_policy=direct and status=ready, run sdd sync-back apply --branch <branch> --task <task_id> only for explicit recovery/replay; if approval_required=true, ask for explicit confirmation and then add --approved.', 'Explain that default apply writes the task block status to completed, appends the sync-back implementation note from the proposal/evidence, marks the run sync_back state applied, and rebuilds the local run index; --refresh-verify is an explicit recovery option after reviewed task-contract changes.', 'After apply, report the updated task id, tasks.md path, applied flag, and sync_back state.']
+    summary: 'Run low-level task acceptance coverage from runtime-selected reviewer/validator evidence; `sdd test <validation_unit_id-or-validation_text>` is the primary runtime gate.',
+    requiredCommands: ['sdd status', 'sdd instructions verify --json', 'sdd verify task <task_id> [--branch <branch>] [--run <run_id>]'],
+    allowedSideEffects: ['write acceptance coverage runtime evidence', 'update runtime.sqlite diagnostic verification state'],
+    forbiddenSideEffects: ['auto commit', 'force push', 'auto-fix failures', 'mark completed with blocking validation gaps'],
+    nextSteps: ['Run goal-level verify without --run for the latest eligible partition/task run, unless inspecting an explicit run.', 'Use sdd test <validation_unit_id-or-validation_text> for primary lifecycle judgment.']
   },
   ship: {
-    summary: 'Run local release readiness and optionally write specs/<branch>/release.md without publishing, pushing, tagging, or changing external release state.',
-    requiredCommands: ['sdd ship --branch <branch> --dry-run', 'sdd ship --branch <branch>', 'sdd statusline --branch <branch>', 'sdd doctor fast --branch <branch>', 'sdd update --check', 'npm run typecheck', 'npm test', 'npm run build', 'npm pack --dry-run --json', 'git status'],
-    allowedSideEffects: ['read project status', 'read SDD documents and run evidence', 'write specs/<branch>/release.md when not using --dry-run', 'run local validation commands'],
-    forbiddenSideEffects: ['npm publish', 'git push', 'git tag', 'create GitHub release', 'force push', 'auto commit', 'skip failed gates', 'treat historical doctor debt as a release blocker unless it affects current run evidence'],
-    nextSteps: ['Run sdd ship --branch <branch> --dry-run to inspect PASS/BLOCKED readiness without writing release docs.', 'If readiness output is acceptable, run sdd ship --branch <branch> to write specs/<branch>/release.md.', 'Use sdd statusline --branch <branch> for compact runtime/test/team/token/evidence health.', 'Run current-run health checks with sdd doctor fast --branch <branch>; use sdd doctor deep only for explicit historical audit.', 'Run npm run typecheck, npm test, npm run build, and npm pack --dry-run --json when preparing a real package release.', 'Report PASS/BLOCKED by readiness check, including exact failed commands and unresolved manual confirmations.', 'Stop before npm publish, git push, git tag, or external release creation unless the user explicitly approves that separate action.']
+    summary: 'Close ship readiness through agent-authored .sdd/runs/<branch>/ship/*.md evidence; optional release.md is ship-agent authored, not runtime-authored.',
+    requiredCommands: ['sdd status', 'sdd instructions ship --json', 'write .sdd/runs/<branch>/ship/ship-readiness-vN.md', 'write .sdd/runs/<branch>/ship/release-review-vN.md', 'write .sdd/runs/<branch>/ship/ship-manager-vN.md', 'write .sdd/runs/<branch>/ship/ship-collaboration-contract-vN.md', 'sdd ship close --branch <branch> --json', 'npm run build', 'npm pack --dry-run --json', 'git status'],
+    allowedSideEffects: ['read project status', 'read SDD documents and run evidence', 'write agent-authored .sdd/runs/<branch>/ship/*.md evidence', 'write optional agent-authored specs/<branch>/release.md', 'run local validation commands', 'record runtime ship projections in .sdd/runtime.sqlite'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'npm publish', 'git push', 'git tag', 'create GitHub release', 'force push', 'auto commit', 'skip failed gates', 'treat historical doctor debt as a release blocker unless it affects current run evidence'],
+    nextSteps: ['Run sdd status and confirm goal-verify has recorded aligned truthAlignment or validated reconciliation truth.', 'Have ship-manager/release agent author .sdd/runs/<branch>/ship/*.md evidence including a StageCollaborationContract; write specs/<branch>/release.md only as an explicit ship-agent artifact if needed.', 'Run sdd ship close --branch <branch> --json; runtime validates readiness refs/contracts/truthAlignment and writes only .sdd/runtime.sqlite.', 'Run package/build dry-run gates when preparing a real release.', 'Report PASS/BLOCKED by runtime ship readiness and local package checks.', 'Stop before npm publish, git push, git tag, or external release creation unless the user explicitly approves that separate action.']
   },
   'run-task': {
-    summary: 'Run the ingestion-aware task workflow using CLI/core runtime state and artifacts.',
-    requiredCommands: ['sdd tasks inspect <task_id>', 'sdd do task <task_id>'],
-    allowedSideEffects: ['write branch-scoped .sdd/runs evidence artifacts', 'update runtime.sqlite run state'],
-    forbiddenSideEffects: ['background write', 'worktree creation', 'auto commit'],
-    nextSteps: ['Inspect the task.', 'Run the task loop with explicit artifacts and validation evidence.']
+    summary: 'Compatibility entry for running one task through do-stage runtime closure.',
+    requiredCommands: ['sdd tasks inspect <task_id>', 'sdd do task <task_id> --branch <branch>'],
+    allowedSideEffects: ['write agent-authored .sdd/runs/<branch>/do/*.md evidence', 'update runtime.sqlite run state'],
+    forbiddenSideEffects: ['runtime-authored Markdown artifacts', 'background write', 'worktree creation', 'auto commit'],
+    nextSteps: ['Inspect the task.', 'Run do-stage closure through sdd do task with .sdd/runs/<branch>/do/*.md evidence.']
   },
   'verify-task': {
-    summary: 'Verify task acceptance coverage using CLI/core verifier artifacts and partition-aware run resolution.',
+    summary: 'Verify task acceptance coverage using runtime-selected evidence and partition-aware run resolution.',
     requiredCommands: ['sdd verify task <task_id> [--branch <branch>] [--run <run_id>]'],
-    allowedSideEffects: ['write acceptance coverage artifact', 'update .sdd run state'],
-    forbiddenSideEffects: ['auto commit', 'force push', 'unapproved sync-back apply'],
-    nextSteps: ['Run goal-level verify without --run for the latest eligible partition/task run, unless inspecting an explicit run.', 'Use sdd test task for primary lifecycle judgment; use sync-back only for explicit diagnostic/recovery/replay.']
+    allowedSideEffects: ['write acceptance coverage runtime evidence', 'update .sdd run state'],
+    forbiddenSideEffects: ['auto commit', 'force push'],
+    nextSteps: ['Run goal-level verify without --run for the latest eligible partition/task run, unless inspecting an explicit run.', 'Use sdd test task for primary lifecycle judgment.']
   }
   };
 
@@ -161,5 +154,5 @@ export function renderSddInstructions(payload: SddInstructionPayload): string {
 }
 
 function isInstructionAction(action: string): action is InstructionAction {
-  return action === 'overview' || action === 'init' || action === 'doctor' || action === 'update' || action === 'spec' || action === 'plan' || action === 'tasks' || action === 'verifies' || action === 'test' || action === 'do' || action === 'verify' || action === 'sync-back' || action === 'ship' || action === 'run-task' || action === 'verify-task';
+  return action === 'overview' || action === 'init' || action === 'doctor' || action === 'update' || action === 'spec' || action === 'plan' || action === 'tasks' || action === 'verifies' || action === 'test' || action === 'do' || action === 'verify' || action === 'ship' || action === 'run-task' || action === 'verify-task';
 }

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

@@ -54,7 +54,7 @@ test('lifecycle hard gates force full profile for contract and state risks', ()
   assert.equal(result.record.decision.profile, 'full');
   assert.equal(result.record.decision.hard_gate_hits.includes('api_schema_contract'), true);
   assert.equal(result.record.decision.hard_gate_hits.includes('state_machine_concurrency_liveness'), true);
-  assert.equal(result.record.decision.required_stages.includes('verify'), true);
+  assert.equal(result.record.decision.required_stages.includes('test'), true);
 });
 
 test('lifecycle database risk forces full hard gate and human checkpoint', () => {

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

@@ -322,7 +322,7 @@ function requiredStagesForProfile(profile: LifecycleProfile): string[] {
     return ['intent-or-mini-spec', 'task-boundary', 'implement', 'validation'];
   }
   if (profile === 'full') {
-    return ['spec', 'plan', 'tasks', 'do', 'verify', 'sync-back-proposal'];
+    return ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
   }
   return ['research', 'options', 'decision', 'architecture-artifact', 'implementation-spec'];
 }