sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/config/init-project.test.ts

@@ -19,7 +19,15 @@ test('initProject creates readable project config', async () => {
     assert.equal(config.contract, 'phase-1.2-project-contract');
     assert.equal(config.sdd.docs_language, 'zh-CN');
     assert.equal(config.lifecycle.decision_required, true);
-    assert.match(await readFile(init.configPath, 'utf8'), /Project-level SDD document prose language/);
+    assert.equal(config.runtime.runtime_store, '.sdd/runtime.sqlite');
+    assert.equal(config.runtime.stage_evidence, '.sdd/runs/<branch>/<stage>/*.md');
+    assert.equal(config.runtime.truth_alignment_mode, 'required');
+    const renderedConfig = await readFile(init.configPath, 'utf8');
+    assert.match(renderedConfig, /Project-level SDD document prose language/);
+    assert.match(renderedConfig, /runtime_store: \.sdd\/runtime\.sqlite/);
+    assert.match(renderedConfig, /stage_evidence: \.sdd\/runs\/<branch>\/<stage>\/\*\.md/);
+    assert.match(renderedConfig, /truth_alignment_mode: required/);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs')));
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -186,13 +194,13 @@ test('initProject projects managed Claude Code entries by default', async () =>
     const init = await initProject(root);
     const skill = await readFile(path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md'), 'utf8');
     const doctorCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'doctor.md'), 'utf8');
+    const updateCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'update.md'), 'utf8');
 
     const specCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'spec.md'), 'utf8');
     const planCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'plan.md'), 'utf8');
     const tasksCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'tasks.md'), 'utf8');
     const doCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'do.md'), 'utf8');
     const testCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'test.md'), 'utf8');
-    const syncBackCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'sync-back.md'), 'utf8');
     const shipCommand = await readFile(path.join(root, '.claude', 'commands', 'sdd', 'ship.md'), 'utf8');
 
     assert.equal(init.aiTools.length, 1);
@@ -203,12 +211,12 @@ test('initProject projects managed Claude Code entries by default', async () =>
     assert.match(skill, /do not paste or restate full status/);
     assert.match(skill, /natural-language intent/);
     assert.match(skill, /CLI\/core output/);
-    assert.match(skill, /projected command entry/);
+    assert.match(skill, /projected command bundle/);
     assert.match(skill, /ambiguous after status/);
     assert.match(skill, /sdd tasks inspect <task_id>/);
-    assert.match(skill, /treat `sdd sync-back inspect\|apply` as diagnostic\/recovery\/replay only/);
-    assert.match(skill, /sdd ship --branch <branch> --dry-run/);
-    assert.match(skill, /`test`/);
+    assert.doesNotMatch(skill, /sync-back|sync_back/);
+    assert.match(skill, /sdd ship close --branch <branch> --json/);
+    assert.match(skill, /`test -> goal-verify`/);
     assert.doesNotMatch(skill, /follow apply_policy/);
     assert.match(skill, /workflow_status=not_started/);
     assert.match(skill, /workflow branch entry/);
@@ -218,14 +226,15 @@ test('initProject projects managed Claude Code entries by default', async () =>
     await assert.rejects(access(path.join(root, '.claude', 'commands', 'sdd', 'init.md')), /ENOENT/);
     await assert.rejects(access(path.join(root, '.claude', 'commands', 'sdd', 'verify.md')), /ENOENT/);
     await assert.rejects(access(path.join(root, '.claude', 'commands', 'sdd', 'verifies.md')), /ENOENT/);
-    await assert.rejects(access(path.join(root, '.claude', 'commands', 'sdd', 'update.md')), /ENOENT/);
     await assert.rejects(access(path.join(root, '.claude', 'commands', 'sdd', 'instructions.md')), /ENOENT/);
+    await assert.rejects(access(path.join(root, '.claude', 'commands', 'sdd', 'sync-back.md')), /ENOENT/);
     assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-root'), false);
     assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-init'), false);
     assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-verify'), false);
     assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-verifies'), false);
-    assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-update'), false);
+    assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-update'), true);
     assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-instructions'), false);
+    assert.equal(init.aiTools[0].entries.some((entry) => entry.id === 'sdd-sync-back'), false);
     assert.match(specCommand, /sdd instructions spec --json/);
     assert.match(planCommand, /sdd instructions plan --json/);
     assert.match(tasksCommand, /sdd instructions tasks --json/);
@@ -235,34 +244,37 @@ test('initProject projects managed Claude Code entries by default', async () =>
     assert.match(tasksCommand, /metadata inside the ```sdd-task fenced block/);
     assert.match(specCommand, /workflow partition entry/);
     assert.match(specCommand, /not a technical design/);
-    assert.match(planCommand, /Refine the existing SDD plan document/);
-    assert.match(planCommand, /deliverable technical solution/);
-    assert.match(planCommand, /based_on_spec_hash/);
+    assert.match(planCommand, /Refine specs\/<branch>\/plan\.md and \.sdd\/runs\/<branch>\/plan\/\*\.md/);
+    assert.match(planCommand, /technical bridge from approved spec to task-ready execution/);
+    assert.match(planCommand, /plan-collaboration-contract-vN\.md/);
     assert.match(planCommand, /PlantUML/);
-    assert.match(planCommand, /state-machine risk needs a state diagram/);
-    assert.match(tasksCommand, /executable task and verification contracts/);
-    assert.match(tasksCommand, /based_on_plan_hash/);
+    assert.match(planCommand, /state diagrams for state-machine risk/);
+    assert.match(tasksCommand, /user-visible bundle for the `tasks -> verifies` runtime stages/);
+    assert.match(tasksCommand, /tasks-collaboration-contract-vN\.md/);
+    assert.match(tasksCommand, /sdd tasks close --branch <branch> --target verifies --json/);
+    assert.match(tasksCommand, /verifies-collaboration-contract-vN\.md/);
     assert.match(doCommand, /sdd status/);
     assert.match(doCommand, /sdd instructions do --json/);
-    assert.match(doCommand, /sdd tasks inspect <task_id>/);
-    assert.match(doCommand, /artifacts\/implement-<task_id>\.md/);
-    assert.match(doCommand, /--agent implementer/);
-    assert.match(doCommand, /sdd do task <task_id>/);
-    assert.match(doCommand, /sdd test batch/);
-    assert.match(doCommand, /sdd test wave/);
+    assert.match(doCommand, /sdd tasks inspect <bound_task_id>/);
+    assert.match(doCommand, /runs\/<branch>\/do\/implementation-vN\.md/);
+    assert.match(doCommand, /runs\/<branch>\/do\/code-review-vN\.md/);
+    assert.match(doCommand, /runs\/<branch>\/do\/do-manager-vN\.md/);
+    assert.match(doCommand, /sdd do task <task_id-or-task-text> --branch <branch>/);
+    assert.match(doCommand, /write only SQLite projections\/run state/);
     assert.match(testCommand, /sdd instructions test --json/);
-    assert.match(testCommand, /sdd test batch <batch_id> --branch <branch>/);
-    assert.match(testCommand, /sdd test wave --branch <branch> --wave <n>/);
-    assert.match(testCommand, /Execute validation from the frozen tasks\.md \+ verify\.md contract/);
-    assert.match(testCommand, /sdd ship --branch <branch> --dry-run/);
-    assert.match(syncBackCommand, /sdd instructions sync-back --json/);
-    assert.match(syncBackCommand, /sdd sync-back inspect --branch <branch> --task <task_id>/);
-    assert.match(syncBackCommand, /explicit recovery\/replay/);
-    assert.match(syncBackCommand, /Do not apply without inspect/);
+    assert.match(testCommand, /sdd test <validation_unit_id-or-validation_text> --branch <branch>/);
+    assert.match(testCommand, /Bind validation intent to an accepted verify\.md validation unit/);
+    assert.match(testCommand, /test-collaboration-contract-vN\.md/);
+    assert.match(testCommand, /user-visible bundle for the `test -> goal-verify` runtime stages/);
+    assert.match(testCommand, /sdd test close --branch <branch> --target goal-verify --json/);
+    assert.match(testCommand, /runs\/<branch>\/goal-verify\/\*\.md/);
+    assert.match(updateCommand, /sdd update/);
+    assert.match(updateCommand, /does not execute imported skills/);
+    assert.doesNotMatch(`${skill}\n${doCommand}\n${testCommand}\n${shipCommand}\n${updateCommand}`, /sync-back|sync_back/);
     assert.match(shipCommand, /sdd instructions ship --json/);
-    assert.match(shipCommand, /sdd ship --branch <branch> --dry-run/);
-    assert.match(shipCommand, /does not authorize npm publish/);
-    assert.match(shipCommand, /statusline --branch <branch>/);
+    assert.match(shipCommand, /sdd ship close --branch <branch> --json/);
+    assert.match(shipCommand, /truthAlignment/);
+    assert.match(shipCommand, /ship-collaboration-contract-vN\.md/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }

package/node_modules/@sdd-agent-platform/core/src/config/init-project.ts

@@ -1,7 +1,8 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { applyAiToolEntries, type AiProjectionResult, type AiToolSelection } from '../ai-tools.js';
-import { getProjectConfigPath, getRunsDir, getSddDir } from '../runtime-paths.js';
+import { importRuntimeSkillCapability, type RuntimeSkillImportRequest, type RuntimeSkillImportResult } from '../router/runtime-import.js';
+import { getProjectConfigPath, getSddDir } from '../runtime-paths.js';
 import { detectProjectConfig, readProjectConfig, renderProjectConfig } from './project-config.js';
 import { assertSafePathSegment } from '../path-safety.js';
 import { exists } from '../storage/json-io.js';
@@ -27,18 +28,18 @@ export interface InitProjectResult {
   created: boolean;
   documents: InitDocumentsResult;
   aiTools: AiProjectionResult[];
+  skillImports: RuntimeSkillImportResult[];
 }
 
 export async function applyInitDocuments(projectRoot: string, options: { branch: string; force?: boolean; scaffoldDocuments: boolean; docsLanguage: string }): Promise<InitDocumentsResult> {
   assertSafePathSegment(options.branch, 'branch');
   const docsRoot = path.join(projectRoot, 'specs', options.branch);
-  const now = new Date().toISOString();
-  const tasksContent = renderInitTasksDocument(options.branch, now, options.docsLanguage);
+  const tasksContent = renderInitTasksDocument(options.branch, options.docsLanguage);
   const documents = [
-    { name: 'spec.md', content: renderInitSpecDocument(options.branch, now, options.docsLanguage) },
-    { name: 'plan.md', content: renderInitPlanDocument(options.branch, now, options.docsLanguage) },
+    { name: 'spec.md', content: renderInitSpecDocument(options.branch, options.docsLanguage) },
+    { name: 'plan.md', content: renderInitPlanDocument(options.branch, options.docsLanguage) },
     { name: 'tasks.md', content: tasksContent },
-    { name: 'verify.md', content: renderInitVerifyDocument(options.branch, now, options.docsLanguage, tasksContent) }
+    { name: 'verify.md', content: renderInitVerifyDocument(options.branch, options.docsLanguage) }
   ];
 
   if (!options.scaffoldDocuments) {
@@ -82,16 +83,14 @@ export async function applyInitDocuments(projectRoot: string, options: { branch:
   return { branch: options.branch, root: path.relative(projectRoot, docsRoot), documents: reports };
 }
 
-export async function initProject(projectRoot: string, options: { force?: boolean; aiTool?: AiToolSelection; branch?: string; scaffoldDocuments?: boolean } = {}): Promise<InitProjectResult> {
+export async function initProject(projectRoot: string, options: { force?: boolean; aiTool?: AiToolSelection; branch?: string; scaffoldDocuments?: boolean; skillImports?: RuntimeSkillImportRequest[] } = {}): Promise<InitProjectResult> {
   const sddDir = getSddDir(projectRoot);
-  const runsDir = getRunsDir(projectRoot);
   const configPath = getProjectConfigPath(projectRoot);
   const requestedBranch = options.branch?.trim();
   const scaffoldDocuments = options.scaffoldDocuments ?? true;
   const branch = requestedBranch || 'master';
   assertSafePathSegment(branch, 'branch');
-  await mkdir(runsDir, { recursive: true });
-
+  await mkdir(sddDir, { recursive: true });
   let created = false;
   let projectConfig = null;
   if (options.force || !await exists(configPath)) {
@@ -116,5 +115,9 @@ export async function initProject(projectRoot: string, options: { force?: boolea
 
   await mkdir(sddDir, { recursive: true });
   const aiTools = await applyAiToolEntries(projectRoot, { tool: options.aiTool ?? 'auto' });
-  return { configPath, created, documents, aiTools };
+  const skillImports: RuntimeSkillImportResult[] = [];
+  for (const request of options.skillImports ?? []) {
+    skillImports.push(await importRuntimeSkillCapability(projectRoot, { ...request, force: request.force ?? options.force }));
+  }
+  return { configPath, created, documents, aiTools, skillImports };
 }

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

@@ -41,7 +41,9 @@ export interface ProjectConfig<TAgentRuntimeConfig = unknown> {
   runtime: {
     background_write: boolean;
     worktree_isolation: boolean;
-    sync_back_mode: 'proposal';
+    runtime_store: string;
+    stage_evidence: string;
+    truth_alignment_mode: string;
   };
   lifecycle: {
     decision_required: boolean;
@@ -93,7 +95,9 @@ export function defaultProjectConfig<TAgentRuntimeConfig = unknown>(projectName:
     runtime: {
       background_write: false,
       worktree_isolation: false,
-      sync_back_mode: 'proposal'
+      runtime_store: '.sdd/runtime.sqlite',
+      stage_evidence: '.sdd/runs/<branch>/<stage>/*.md',
+      truth_alignment_mode: 'required'
     },
     lifecycle: {
       decision_required: true,
@@ -105,7 +109,7 @@ export function defaultProjectConfig<TAgentRuntimeConfig = unknown>(projectName:
 export function renderProjectConfig(config: ProjectConfig<unknown>): string {
   const detection = config.detection ? `detection:\n  confidence: ${config.detection.confidence}\n  mixed_stack: ${config.detection.mixed_stack}\n  primary: ${config.detection.primary}\n  candidates:\n${config.detection.candidates.map((candidate) => `    - id: ${candidate.id}\n      confidence: ${candidate.confidence}\n      score: ${candidate.score}`).join('\n')}\n` : '';
   const defaultBranch = config.sdd.default_branch ? `  default_branch: ${config.sdd.default_branch}\n` : '';
-  return `contract: ${config.contract}\nproject:\n  name: ${config.project.name}\n  language: ${config.project.language}\n  framework: ${config.project.framework}\n${detection}sdd:\n  spec_dir: ${config.sdd.spec_dir}\n${defaultBranch}  # Project-level SDD document prose language; runtime CLI/JSON output remains English.\n  docs_language: ${config.sdd.docs_language}\n  compatible_with: ${config.sdd.compatible_with}\nvalidation:\n  default:\n${config.validation.default.map((command) => `    - ${command}`).join('\n')}\nediting:\n  prefer_hashline: ${config.editing.prefer_hashline}\n  native_edit_fallback: ${config.editing.native_edit_fallback}\nruntime:\n  background_write: ${config.runtime.background_write}\n  worktree_isolation: ${config.runtime.worktree_isolation}\n  sync_back_mode: ${config.runtime.sync_back_mode}\nlifecycle:\n  decision_required: ${config.lifecycle.decision_required}\n  profiles:\n${config.lifecycle.profiles.map((profile) => `    - ${profile}`).join('\n')}\n`;
+  return `contract: ${config.contract}\nproject:\n  name: ${config.project.name}\n  language: ${config.project.language}\n  framework: ${config.project.framework}\n${detection}sdd:\n  spec_dir: ${config.sdd.spec_dir}\n${defaultBranch}  # Project-level SDD document prose language; runtime CLI/JSON output remains English.\n  docs_language: ${config.sdd.docs_language}\n  compatible_with: ${config.sdd.compatible_with}\nvalidation:\n  default:\n${config.validation.default.map((command) => `    - ${command}`).join('\n')}\nediting:\n  prefer_hashline: ${config.editing.prefer_hashline}\n  native_edit_fallback: ${config.editing.native_edit_fallback}\nruntime:\n  background_write: ${config.runtime.background_write}\n  worktree_isolation: ${config.runtime.worktree_isolation}\n  runtime_store: ${config.runtime.runtime_store}\n  stage_evidence: ${config.runtime.stage_evidence}\n  truth_alignment_mode: ${config.runtime.truth_alignment_mode}\nlifecycle:\n  decision_required: ${config.lifecycle.decision_required}\n  profiles:\n${config.lifecycle.profiles.map((profile) => `    - ${profile}`).join('\n')}\n`; 
 }
 
 export async function readProjectConfig<TAgentRuntimeConfig = unknown>(projectRoot: string, parseAgentRuntime?: (raw: string) => TAgentRuntimeConfig | undefined): Promise<ProjectConfig<TAgentRuntimeConfig>> {
@@ -163,7 +167,9 @@ export function parseProjectConfig<TAgentRuntimeConfig = unknown>(raw: string, c
     runtime: {
       background_write: readBoolean(raw, 'background_write', false),
       worktree_isolation: readBoolean(raw, 'worktree_isolation', false),
-      sync_back_mode: 'proposal'
+      runtime_store: readScalar(raw, 'runtime_store') ?? '.sdd/runtime.sqlite',
+      stage_evidence: readScalar(raw, 'stage_evidence') ?? '.sdd/runs/<branch>/<stage>/*.md',
+      truth_alignment_mode: readScalar(raw, 'truth_alignment_mode') ?? 'required'
     },
     lifecycle: {
       decision_required: readBoolean(raw, 'decision_required', true),

package/node_modules/@sdd-agent-platform/core/src/config/starter-documents.ts

@@ -1,10 +1,9 @@
-import { hashDocumentContent, hashTasksContract } from '../sdd-docs/document-hashes.js';
 
 function usesChineseInitDocs(value: string): boolean {
   return value === 'zh-CN';
 }
 
-export function renderInitSpecDocument(branch: string, timestamp: string, docsLanguage: string): string {
+export function renderInitSpecDocument(branch: string, docsLanguage: string): string {
   const zh = usesChineseInitDocs(docsLanguage);
   const title = zh ? '# Spec: Project Onboarding / 项目入门' : '# Spec: Project Onboarding';
   const objectiveLines = zh ? `- User value: 仓库在第一个真实变更前已有可见的 SDD 入口。
@@ -39,8 +38,6 @@ ${title}
 - lifecycle_profile: \`direct\`
 - source_request: \`Created by sdd init\`
 - status: \`draft\`
-- created_at: \`${timestamp}\`
-- updated_at: \`${timestamp}\`
 
 ## 1. Objective / Customer Value
 
@@ -79,7 +76,7 @@ ${story}
 
 - Running background agents.
 - Creating worktrees.
-- Applying sync-back without explicit user approval.
+- Claiming truth-alignment or release approval without accepted runtime evidence.
 
 ## 6. Requirements
 
@@ -131,7 +128,7 @@ ${story}
 `;
 }
 
-export function renderInitPlanDocument(branch: string, timestamp: string, docsLanguage: string): string {
+export function renderInitPlanDocument(branch: string, docsLanguage: string): string {
   const zh = usesChineseInitDocs(docsLanguage);
   const title = zh ? '# Plan: Project Onboarding / 项目入门' : '# Plan: Project Onboarding';
   const background = zh
@@ -160,8 +157,6 @@ ${title}
 - spec_id: \`onboarding\`
 - plan_id: \`onboarding\`
 - branch: \`${branch}\`
-- created_at: \`${timestamp}\`
-- updated_at: \`${timestamp}\`
 
 ## 0.1 Requirement Trace
 
@@ -263,7 +258,7 @@ Explain why \`specs/${branch}/tasks.md\` should be split into the planned task b
 `;
 }
 
-export function renderInitTasksDocument(branch: string, timestamp: string, docsLanguage: string): string {
+export function renderInitTasksDocument(branch: string, docsLanguage: string): string {
   const zh = usesChineseInitDocs(docsLanguage);
   const title = zh ? '# Tasks: Project Onboarding / 项目入门' : '# Tasks: Project Onboarding';
   const boundary = zh
@@ -289,8 +284,6 @@ ${title}
 - branch: \`${branch}\`
 - lifecycle_profile: \`direct\`
 - status: \`draft\`
-- created_at: \`${timestamp}\`
-- updated_at: \`${timestamp}\`
 
 ## 1. Delivery Map
 
@@ -349,7 +342,7 @@ Forbidden scope:
 - Do not create worktrees.
 - Do not start background agents.
 - Do not commit changes.
-- Do not apply sync-back automatically.
+- Do not claim truth-alignment or release approval automatically.
 
 #### Acceptance
 
@@ -391,31 +384,25 @@ ${implementationNotes}
 `;
 }
 
-export function renderInitVerifyDocument(branch: string, timestamp: string, docsLanguage: string, tasksContent: string): string {
+export function renderInitVerifyDocument(branch: string, docsLanguage: string): string {
   const zh = usesChineseInitDocs(docsLanguage);
   const title = zh ? '# Verify: Project Onboarding / 项目入门' : '# Verify: Project Onboarding';
   const purpose = zh
-    ? '这份 verify.md 是从 starter tasks 派生的 verification guidance，不是 runtime evidence，也不替代 `sdd test task|batch|wave` 产生的验证证据。'
-    : 'This verify.md is task-derived verification guidance, not runtime evidence, and it does not replace validation evidence produced by `sdd test task|batch|wave`.';
+    ? '这份 verify.md 是从 starter tasks 派生的 verification guidance，不是 runtime evidence，也不替代 `sdd test <validation_unit_id-or-validation_text>` 产生的验证证据。'
+    : 'This verify.md is task-derived verification guidance, not runtime evidence, and it does not replace validation evidence produced by `sdd test <validation_unit_id-or-validation_text>`.';
   const availability = zh
     ? '在替换真实 spec/plan/tasks 前，只能检查 onboarding scaffold 是否仍然可见且未被误当作已批准实现。'
     : 'Before replacing the real spec/plan/tasks, verification can only inspect that the onboarding scaffold is visible and not mistaken for approved implementation.';
-  const tasksContractHash = hashTasksContract(tasksContent) ?? 'missing';
-  const tasksHash = hashDocumentContent(tasksContent);
   return `---
 template: sdd-init-onboarding-verify-v1
 version: 1.4.0
 contract: sdd-verify-doc-v1
 sdd_managed_starter: true
 branch: ${branch}
-based_on_tasks_contract_hash: ${tasksContractHash}
-based_on_tasks_hash: ${tasksHash}
 author_role: verification-designer
 independent_from_roles:
   - task-planner
   - implementer
-created_at: ${timestamp}
-updated_at: ${timestamp}
 ---
 
 ${title}
@@ -428,18 +415,18 @@ ${purpose}
 
 | Task | Acceptance refs | Validation commands | Required artifacts | Verification availability |
 |---|---|---|---|---|
-| ONBOARDING-1 | AC-1<br>AC-2 | sdd status --branch ${branch}<br>sdd test task ONBOARDING-1 --branch ${branch} | none | ${availability} |
+| ONBOARDING-1 | AC-1<br>AC-2 | sdd status --branch ${branch}<br>sdd test task-ONBOARDING-1 --branch ${branch} | none | ${availability} |
 
 ## 3. Verification Rules
 
-- This starter verify contract does not authorize source changes, validation execution, runtime mutation, sync-back, commit, push, publish, or release.
+- This starter verify contract does not authorize source changes, validation execution, runtime mutation, truth-alignment approval, commit, push, publish, or release.
 - Replace starter spec, plan, tasks, and verify documents with a real branch contract before implementation.
-- Runtime PASS is judged by \`sdd test task <task_id> --branch ${branch}\`, \`sdd test batch <batch_id> --branch ${branch}\`, or \`sdd test wave --branch ${branch}\` consuming the current verify contract; low-level verify remains available for compatibility diagnostics.
+- Runtime PASS is judged by \`sdd test <validation_unit_id-or-validation_text> --branch ${branch}\` consuming the current verify contract; \`sdd test task|batch|wave\` remains available for explicit low-level diagnostics.
 - Re-run \`sdd verifies write --branch ${branch} --force\` only after reviewing changed task expectations.
 
 ## 4. Out of Scope
 
 - This document is not evidence in \`.sdd/runtime.sqlite\`.
-- This document is not a release, ship, or sync-back approval.
+- This document is not a release, ship, or truth-alignment approval.
 `;
 }

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

@@ -7,7 +7,7 @@ import { contextBudgetForProfile, type ContextBudget, type ContextProfile } from
 import { contextSourceRefForAbsolutePath, contextSourceRefForProjectPath, uniqueContextSourceRefs } from './source-refs.js';
 import type { ContextSourceRef } from './source-refs.js';
 
-export type ContextBuildMode = 'do' | 'verify' | 'sync-back' | 'doctor';
+export type ContextBuildMode = 'do' | 'verify' | 'doctor';
 export type ContextBuildRole = 'default' | 'implementer' | 'reviewer' | 'validator' | 'context-curator';
 
 export interface ContextBuildPackage {
@@ -254,9 +254,6 @@ function contextMustReadRefs(mode: ContextBuildMode, role: ContextBuildRole, doc
   if (mode === 'verify') {
     return [docs[0], ...artifacts];
   }
-  if (mode === 'sync-back') {
-    return [docs[0], ...affected];
-  }
   return [docs[0]];
 }
 
@@ -307,10 +304,7 @@ function contextNextCommands(taskId: string, branch: string, mode: ContextBuildM
     return [`sdd do task ${taskId} --branch ${branch}`];
   }
   if (mode === 'verify') {
-    return [`sdd test task ${taskId} --branch ${branch}`, `sdd evidence summary <run_id> --task ${taskId} --json`];
-  }
-  if (mode === 'sync-back') {
-    return [`sdd sync-back inspect --branch ${branch} --task ${taskId}`];
+    return [`sdd test task-${taskId} --branch ${branch}`, `sdd evidence summary <run_id> --task ${taskId} --json`];
   }
   const agentSuffix = agent ? ` --agent ${agent}` : '';
   return [`sdd doctor fast --branch ${branch}`, `sdd context build --task ${taskId} --branch ${branch} --mode verify${agentSuffix} --json`];

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

@@ -55,7 +55,8 @@ test('evidence summary projection is hash-backed and not usable for PASS', async
       assert.equal(summary.usableForPass, false);
       assert.equal(summary.taskId, 'T1');
       assert.ok(summary.sources.some((source) => source.path.endsWith('runtime.sqlite') && source.kind === 'run_state' && source.hash.length === 64));
-      assert.ok(summary.sources.some((source) => source.path.endsWith('.sdd/runs/master/evidence/artifacts/validation-T1.md') && source.kind === 'artifact'));
+      assert.ok(summary.sources.some((source) => source.path === '.sdd/runs/master/test/validation-T1.md' && source.kind === 'artifact' && source.hash.length === 64));
+      assert.equal(summary.sources.some((source) => source.path.includes('evidence/artifacts')), false);
       assert.ok(summary.policyRefs.some((ref) => ref.includes('reject-derived-source-evidence')));
       assert.equal(projection?.scope_key, 'summary-run:T1');
       assert.equal(payload.contract, 'sdd-evidence-summary-v1');
@@ -88,7 +89,7 @@ test('context build packages differ by mode and agent while remaining derived gu
       assert.ok(validatorPackage.mustRead.some((ref) => ref.path === 'artifacts/validation-T1.md'));
       assert.notDeepEqual(implementerPackage.mustRead.map((ref) => ref.path), validatorPackage.mustRead.map((ref) => ref.path));
       assert.ok(validatorPackage.warnings.some((warning) => warning.includes('cannot satisfy PASS evidence')));
-      assert.ok(validatorPackage.nextCommands.includes('sdd test task T1 --branch master'));
+      assert.ok(validatorPackage.nextCommands.includes('sdd test task-T1 --branch master'));
       assert.equal(validatorPackage.nextCommands.some((command) => command.startsWith('sdd verify task')), false);
       assert.ok(implementerPackage.budget.estimatedBytes <= implementerPackage.budget.maxBytes);
       assert.ok(implementerPackage.budget.estimatedTokens > 0);

package/node_modules/@sdd-agent-platform/core/src/context/evidence-summary.ts

@@ -71,19 +71,28 @@ export async function buildEvidenceSummaryProjection(projectRoot: string, option
   const admittedClaims = await readRuntimeEvidenceClaims(projectRoot, state.runId, taskId ?? null);
   const artifactIngestions = Object.values(state.artifactIngestions ?? {}).filter((record) => !taskId || record.task === taskId);
   const artifacts = state.artifacts.filter((artifact) => !taskId || artifact.task === taskId);
+  const branch = state.gitBranch ?? state.partition ?? 'unscoped';
   const ledgerArtifactRefs = invocationLedger
     .filter((entry) => entry.kind === 'artifact_hash' && entry.artifactPath)
-    .map((entry) => ({ path: entry.artifactPath as string, kind: 'artifact' as const }));
-  const branchEvidenceRoot = `.sdd/runs/${branchToSafePartition(state.gitBranch ?? state.partition ?? 'unscoped')}/evidence`;
-  const artifactSourceRefs = [
-    ...artifacts.map((artifact) => ({ path: `${branchEvidenceRoot}/${artifact.path}`, kind: 'artifact' as const })),
-    ...ledgerArtifactRefs.map((artifact) => ({ path: `${branchEvidenceRoot}/${artifact.path}`, kind: artifact.kind }))
+    .map((entry) => ({
+      path: stageEvidenceDisplayRefForRuntimeArtifact(branch, entry.artifactPath as string, 'artifact'),
+      kind: 'artifact' as const,
+      hash: entry.outputHash ?? null
+    }));
+  const artifactSourceRefs = artifacts.map((artifact) => ({ path: stageEvidenceDisplayRefForRuntimeArtifact(branch, artifact.path, artifact.kind), kind: 'artifact' as const }));
+  const hashedArtifactSourceRefs: ContextSourceRef[] = ledgerArtifactRefs
+    .filter((artifact): artifact is { path: string; kind: 'artifact'; hash: string } => artifact.hash !== null)
+    .map((artifact) => ({ path: artifact.path, kind: artifact.kind, hash: artifact.hash }));
+  const unresolvedArtifactSourceRefs = [
+    ...artifactSourceRefs,
+    ...ledgerArtifactRefs.filter((artifact) => artifact.hash === null).map((artifact) => ({ path: artifact.path, kind: artifact.kind }))
   ];
   const sources = await uniqueContextSourceRefs([
     await contextSourceRefForProjectPath(projectRoot, `.sdd/runtime.sqlite`, 'run_state'),
     await contextSourceRefForProjectPath(projectRoot, `.sdd/runtime.sqlite`, 'command_output'),
     await contextSourceRefForProjectPath(projectRoot, `.sdd/runtime.sqlite`, 'ledger'),
-    ...(await Promise.all(artifactSourceRefs.map((artifact) => contextSourceRefForProjectPath(projectRoot, artifact.path, artifact.kind))))
+    ...hashedArtifactSourceRefs,
+    ...(await Promise.all(unresolvedArtifactSourceRefs.map((artifact) => contextSourceRefForProjectPath(projectRoot, artifact.path, artifact.kind))))
   ]);
   const issueCodes = uniqueEvidenceIssueCodes(artifactIngestions.flatMap((record) => record.issues));
   const passCount = Math.max(admittedClaims.filter((claim) => claim.status === 'PASS').length, artifactIngestions.filter((record) => record.status === 'accepted' && (record.resultStatus === 'PASS' || record.resultStatus === 'PASS_WITH_GAPS')).length);
@@ -91,8 +100,8 @@ export async function buildEvidenceSummaryProjection(projectRoot: string, option
   const blockedCount = Math.max(admittedClaims.filter((claim) => claim.status === 'BLOCKED').length, artifactIngestions.filter((record) => record.resultStatus === 'BLOCKED' || record.resultStatus === 'TIMED_OUT' || record.resultStatus === 'CANCELLED' || record.gaps.length > 0).length);
   const highlights = [
     `run=${state.runId} status=${state.status} phase=${state.phase ?? 'none'}`,
-    `task=${taskId ?? 'none'} validation=${state.validation.status} sync_back=${state.syncBack.status}`,
-    `artifacts=${artifacts.length} ingestions=${artifactIngestions.length} admitted_claims=${admittedClaims.length} events=${events.length} ledger=${invocationLedger.length}`,
+    `task=${taskId ?? 'none'} validation=${state.validation.status}`,
+    `stage_evidence_refs=${artifacts.length} ingestions=${artifactIngestions.length} admitted_claims=${admittedClaims.length} events=${events.length} ledger=${invocationLedger.length}`,
     `pass=${passCount} blocked=${blockedCount} fail=${failCount}`
   ];
   if (issueCodes.length > 0) {
@@ -120,6 +129,16 @@ export async function buildEvidenceSummaryProjection(projectRoot: string, option
   return projection;
 }
 
+function stageEvidenceDisplayRefForRuntimeArtifact(branch: string, artifactPath: string, kind: string): string {
+  const portablePath = artifactPath.replace(/\\/g, '/').replace(/^\.\//, '');
+  if (portablePath.startsWith('.sdd/runs/')) {
+    return portablePath;
+  }
+  const fileName = portablePath.split('/').filter(Boolean).pop() ?? 'evidence.md';
+  const stage = kind === 'validation' || kind === 'test-validation' || fileName.startsWith('validation-') || fileName.startsWith('test-validation-') ? 'test' : 'do';
+  return `.sdd/runs/${branchToSafePartition(branch)}/${stage}/${fileName}`;
+}
+
 export async function readRuntimeEvidenceClaims(projectRoot: string, runId: string, taskId: string | null): Promise<EvidenceClaim[]> {
   return withRuntimeStore(projectRoot, ({ db }) => {
     const rows = taskId

package/node_modules/@sdd-agent-platform/core/src/context/log-worker.ts

@@ -33,9 +33,9 @@ export function validateLogWorkerSummary(summary: LogWorkerSummary): LogWorkerSu
   }
   const forbiddenAuthority = Array.isArray(candidate.forbiddenAuthority) ? candidate.forbiddenAuthority.filter((item) => typeof item === 'string') : [];
   if (forbiddenAuthority.length > 0) {
-    issues.push(contractIssue('forbiddenAuthority', `Log worker summary claims forbidden workflow authority: ${forbiddenAuthority.join(', ')}.`, 'Remove PASS/BLOCKED/route/doctor/sync-back decisions from worker summaries.'));
+    issues.push(contractIssue('forbiddenAuthority', `Log worker summary claims forbidden workflow authority: ${forbiddenAuthority.join(', ')}.`, 'Remove PASS/BLOCKED/route/doctor/truth-alignment decisions from worker summaries.'));
   }
-  for (const field of ['status', 'verdict', 'routeDecision', 'doctorVerdict', 'syncBackReady']) {
+  for (const field of ['status', 'verdict', 'routeDecision', 'doctorVerdict', 'truthAlignmentReady']) {
     if (field in candidate) {
       issues.push(contractIssue(field, `Log worker summary must not expose workflow decision field ${field}.`, 'Keep decision fields in core runtime outputs only.'));
     }

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

@@ -26,7 +26,7 @@ export interface ContextOffloadDecision {
   scope: RuntimeScope;
   action: ContextOffloadAction;
   loadSignalRef: RuntimeRef;
-  requiredBefore: 'stage-output' | 'handoff' | 'sync-back' | 'ship' | 'never';
+  requiredBefore: 'stage-output' | 'handoff' | 'ship' | 'never';
   inlineRefs: RuntimeRef[];
   summarizeRefs: RuntimeRef[];
   dispatchRefs: RuntimeRef[];

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

@@ -73,10 +73,11 @@ export const CONTEXT_OFFLOAD_DECISION_CONTRACT_VERSION = 'sdd-context-offload-de
 export const SCOPED_CONTEXT_HANDOFF_CONTRACT_VERSION = 'sdd-scoped-context-handoff-v1';
 export const TEST_EVIDENCE_RUN_CONTRACT_VERSION = 'sdd-test-evidence-run-v1';
 export const MODEL_PRODUCED_ARTIFACT_CONTRACT_VERSION = 'sdd-model-produced-artifact-v1';
+export const STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION = 'phase-9.1-stage-collaboration-runtime-v1';
 
 export type RuntimeConfidence = 'high' | 'medium' | 'low';
 export type RuntimeProjectionStaleness = 'fresh' | 'stale' | 'incompatible' | 'unknown';
-export type SddStage = 'spec' | 'plan' | 'tasks' | 'verifies' | 'do' | 'test' | 'goal-verify' | 'sync-back' | 'ship';
+export type SddStage = 'spec' | 'plan' | 'tasks' | 'verifies' | 'do' | 'test' | 'goal-verify' | 'ship';
 export type RuntimeRefKind = 'document' | 'task' | 'run' | 'artifact' | 'projection' | 'evidence' | 'command' | 'external';
 
 export interface RuntimeScope {

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

@@ -20,4 +20,7 @@ export interface DelegationRecord {
   expectedArtifact: string;
   terminalEventRequired: boolean;
   terminalEventAt?: string | null;
+  attempt?: number;
+  retryOf?: string | null;
+  replayReason?: 'document_contract_refresh' | 'artifact_reingest' | 'validation_replay' | 'manual_retry' | 'runtime_recovery' | null;
 }

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

@@ -1,5 +1,5 @@
 import { DELEGATION_LIVENESS_CONTRACT, DELEGATION_LIVENESS_VERSION } from '../contracts.js';
-import { toArtifactRootRelativePath } from '../runtime-paths.js';
+import { normalizeStageEvidenceOrLegacyArtifactRef } from '../runtime-paths.js';
 import { validateSddResultArtifact } from '../artifacts/sdd-result.js';
 import type { DelegationRecord, DelegationStatus } from './model.js';
 
@@ -17,7 +17,7 @@ export interface DelegationValidationReport {
   issues: ContractValidationIssue[];
 }
 
-export function createDelegationRecord(input: { delegationId: string; task: string; agent: string; expectedArtifact: string; runMode?: DelegationRecord['runMode']; blocking?: boolean; requiredForPhaseExit?: boolean; startedAt?: string; timeoutSeconds?: number; status?: DelegationStatus }): DelegationRecord {
+export function createDelegationRecord(input: { delegationId: string; task: string; agent: string; expectedArtifact: string; runMode?: DelegationRecord['runMode']; blocking?: boolean; requiredForPhaseExit?: boolean; startedAt?: string; timeoutSeconds?: number; status?: DelegationStatus; attempt?: number; retryOf?: string | null; replayReason?: DelegationRecord['replayReason'] }): DelegationRecord {
   return {
     contract: DELEGATION_LIVENESS_CONTRACT,
     version: DELEGATION_LIVENESS_VERSION,
@@ -33,7 +33,10 @@ export function createDelegationRecord(input: { delegationId: string; task: stri
     timeoutSeconds: input.timeoutSeconds ?? 900,
     expectedArtifact: input.expectedArtifact,
     terminalEventRequired: true,
-    terminalEventAt: null
+    terminalEventAt: null,
+    attempt: input.attempt,
+    retryOf: input.retryOf ?? null,
+    replayReason: input.replayReason ?? null
   };
 }
 
@@ -105,9 +108,9 @@ function validateDelegationShape(delegation: DelegationRecord): ContractValidati
 
 function validateRunRelativeArtifactReference(value: string, issues: ContractValidationIssue[], field = 'artifacts'): void {
   try {
-    toArtifactRootRelativePath(value);
+    normalizeStageEvidenceOrLegacyArtifactRef(value);
   } catch (error) {
-    issues.push(contractIssue(field, messageFromError(error), 'Use run-relative artifacts/<file> paths that stay under the run artifact directory.'));
+    issues.push(contractIssue(field, messageFromError(error), 'Use repo-relative .sdd/runs/<branch>/<stage>/*.md stage evidence refs for new delegation evidence.'));
   }
 }
 

package/node_modules/@sdd-agent-platform/core/src/doctor/checks/document-chain.ts

@@ -57,7 +57,7 @@ export async function inspectDocumentChainEvidence(projectRoot: string, branch?:
             level: 'WARN',
             check: 'document_chain_high_risk_evidence',
             message: `High-risk task ${task.id} should require explicit reviewer and validator evidence artifacts.`,
-            action: 'Add artifacts/review-<task>.md and artifacts/validation-<task>.md or equivalent evidence paths.'
+            action: 'Add .sdd/runs/<branch>/do/code-review-vN.md and .sdd/runs/<branch>/test/validation-vN.md or equivalent accepted stage evidence paths.'
           });
         }
         if (task.verificationAvailability.length === 0) {