sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -1,6 +1,7 @@
+import { readFile } from 'node:fs/promises';
 import { SDD_RESULT_CONTRACT, SDD_RESULT_VERSION } from '../contracts.js';
 import { readArtifact } from '../run-state/artifacts.js';
-import { toArtifactRootRelativePath } from '../runtime-paths.js';
+import { getBranchStageEvidencePathFromRef, isBranchStageEvidenceRef, normalizeStageEvidenceOrLegacyArtifactRef, toEvidencePayloadFileName } from '../runtime-paths.js';
 import { validateArtifactTrust } from './sdd-evidence.js';
 import type { ArtifactTrustValidationReport, ContractValidationIssue } from './sdd-evidence.js';
 
@@ -25,29 +26,29 @@ export interface SddResultValidationReport {
 
 export async function validateSddResultArtifact(projectRoot: string, runId: string, runRelativeArtifactPath: string, options: { expectedTask?: string; expectedAgent?: string } = {}): Promise<SddResultValidationReport> {
   const issues: ContractValidationIssue[] = [];
-  let artifactRootRelativePath: string;
+  let evidenceRef: string;
   try {
-    artifactRootRelativePath = toArtifactRootRelativePath(runRelativeArtifactPath);
+    evidenceRef = normalizeStageEvidenceOrLegacyArtifactRef(runRelativeArtifactPath);
   } catch (error) {
-    return { valid: false, result: null, issues: [contractIssue('artifacts', messageFromError(error), 'Use a run-relative artifacts/<file> path; the physical file lives under branch evidence .sdd/runs/<branchSlug>/evidence/artifacts/<file>. Source/test files belong in ## Evidence, not in sdd-result.artifacts.')] };
+    return { valid: false, result: null, issues: [contractIssue('artifacts', messageFromError(error), 'Use a repo-relative stage evidence ref under .sdd/runs/<branch>/<stage>/*.md. Source/test files belong in ## Evidence, not in sdd-result.artifacts.')] };
   }
 
   let raw: string;
   try {
-    raw = await readArtifact(projectRoot, runId, artifactRootRelativePath);
+    raw = await readSddResultEvidence(projectRoot, runId, evidenceRef);
   } catch (error) {
-    return { valid: false, result: null, issues: [contractIssue('artifacts', `Cannot read artifact ${runRelativeArtifactPath}: ${messageFromError(error)}`, `Create the expected artifact in branch evidence and pass the run-relative path ${runRelativeArtifactPath}.`)] };
+    return { valid: false, result: null, issues: [contractIssue('artifacts', `Cannot read evidence ${evidenceRef}: ${messageFromError(error)}`, `Create the expected stage evidence and pass ${evidenceRef}.`)] };
   }
 
   if (raw.trim().length === 0) {
-    issues.push(contractIssue('artifacts', `Artifact ${runRelativeArtifactPath} is empty.`, 'Write non-empty evidence and an sdd-result block.'));
+    issues.push(contractIssue('artifacts', `Evidence ${evidenceRef} is empty.`, 'Write non-empty evidence and an sdd-result block.'));
   }
   const parsed = parseSddResultMarkdown(raw);
   issues.push(...parsed.issues);
   let trust: ArtifactTrustValidationReport | undefined;
   if (parsed.result) {
-    issues.push(...validateSddResult(parsed.result, { ...options, runRelativeArtifactPath }));
-    trust = validateArtifactTrust(raw, parsed.result, runRelativeArtifactPath, options);
+    issues.push(...validateSddResult(parsed.result, { ...options, runRelativeArtifactPath: evidenceRef }));
+    trust = validateArtifactTrust(raw, parsed.result, evidenceRef, options);
     if (!trust.valid) {
       issues.push(...trust.issues);
     }
@@ -135,22 +136,30 @@ function validateSddResultMetadata(metadata: Record<string, string | string[]>):
     issues.push(contractIssue('status', `Unsupported sdd-result status ${status ?? 'missing'}.`, 'Use PASS, PASS_WITH_GAPS, FAIL, BLOCKED, TIMED_OUT, or CANCELLED.'));
   }
   if (artifacts.length === 0) {
-    issues.push(contractIssue('artifacts', 'sdd-result artifacts must contain at least one path.', 'Add the current run-relative artifact path, for example artifacts/<file>. Source/test files belong in ## Evidence.'));
+    issues.push(contractIssue('artifacts', 'sdd-result artifacts must contain at least one evidence ref.', 'Add the current stage evidence ref, for example .sdd/runs/<branch>/<stage>/<file>.md. Source/test files belong in ## Evidence.'));
   }
   for (const artifactPath of artifacts) {
-    validateRunRelativeArtifactReference(artifactPath, issues);
-    if (!artifactPath.replace(/\\/g, '/').startsWith('artifacts/')) {
-      issues.push(contractIssue('artifacts', `Source/test path ${artifactPath} is not a run artifact reference.`, 'Move source/test file citations to ## Evidence; keep only run-relative artifacts/<file> paths in sdd-result.artifacts.'));
-    }
+    validateSddResultEvidenceReference(artifactPath, issues);
   }
   return issues;
 }
 
-function validateRunRelativeArtifactReference(value: string, issues: ContractValidationIssue[], field = 'artifacts'): void {
+async function readSddResultEvidence(projectRoot: string, runId: string, evidenceRef: string): Promise<string> {
+  if (isBranchStageEvidenceRef(evidenceRef)) {
+    try {
+      return await readFile(getBranchStageEvidencePathFromRef(projectRoot, evidenceRef), 'utf8');
+    } catch {
+      return readArtifact(projectRoot, runId, toEvidencePayloadFileName(evidenceRef));
+    }
+  }
+  return readArtifact(projectRoot, runId, toEvidencePayloadFileName(evidenceRef));
+}
+
+function validateSddResultEvidenceReference(value: string, issues: ContractValidationIssue[], field = 'artifacts'): void {
   try {
-    toArtifactRootRelativePath(value);
+    normalizeStageEvidenceOrLegacyArtifactRef(value);
   } catch (error) {
-    issues.push(contractIssue(field, messageFromError(error), 'Use a run-relative artifacts/<file> path inside the active run.'));
+    issues.push(contractIssue(field, messageFromError(error), 'Use a repo-relative stage evidence ref under .sdd/runs/<branch>/<stage>/*.md.'));
   }
 }
 

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,13 +211,13 @@ 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, /\/sdd:\*/);
+    assert.match(skill, /projected command bundle/);
     assert.match(skill, /ambiguous after status/);
     assert.match(skill, /sdd tasks inspect <task_id>/);
-    assert.match(skill, /sdd sync-back inspect --branch <branch> --task <task_id>/);
-    assert.match(skill, /\/sdd:ship/);
-    assert.match(skill, /\/sdd:test/);
-    assert.match(skill, /follow apply_policy/);
+    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/);
     assert.match(doctorCommand, /sdd instructions doctor --json/);
@@ -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,31 +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 evidence contract/);
-    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 task <task_id> --branch <branch>/);
+    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 verifies inspect --branch <branch>/);
-    assert.match(testCommand, /Execute task validation commands/);
-    assert.match(syncBackCommand, /sdd instructions sync-back --json/);
-    assert.match(syncBackCommand, /sdd sync-back inspect --branch <branch> --task <task_id>/);
-    assert.match(syncBackCommand, /approval_required=true/);
-    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,17 +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, 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: 'tasks.md', content: renderInitTasksDocument(options.branch, now, options.docsLanguage) },
-    { name: 'verify.md', content: renderInitVerifyDocument(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, options.docsLanguage) }
   ];
 
   if (!options.scaffoldDocuments) {
@@ -81,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)) {
@@ -115,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,8 +1,9 @@
+
 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 入口。
@@ -37,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
 
@@ -77,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
 
@@ -129,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
@@ -158,8 +157,6 @@ ${title}
 - spec_id: \`onboarding\`
 - plan_id: \`onboarding\`
 - branch: \`${branch}\`
-- created_at: \`${timestamp}\`
-- updated_at: \`${timestamp}\`
 
 ## 0.1 Requirement Trace
 
@@ -261,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
@@ -287,8 +284,6 @@ ${title}
 - branch: \`${branch}\`
 - lifecycle_profile: \`direct\`
 - status: \`draft\`
-- created_at: \`${timestamp}\`
-- updated_at: \`${timestamp}\`
 
 ## 1. Delivery Map
 
@@ -347,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
 
@@ -389,12 +384,12 @@ ${implementationNotes}
 `;
 }
 
-export function renderInitVerifyDocument(branch: string, timestamp: string, docsLanguage: 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` 产生的验证证据。'
-    : 'This verify.md is task-derived verification guidance, not runtime evidence, and it does not replace validation evidence produced by `/sdd:test`.';
+    ? '这份 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.';
@@ -404,8 +399,10 @@ version: 1.4.0
 contract: sdd-verify-doc-v1
 sdd_managed_starter: true
 branch: ${branch}
-created_at: ${timestamp}
-updated_at: ${timestamp}
+author_role: verification-designer
+independent_from_roles:
+  - task-planner
+  - implementer
 ---
 
 ${title}
@@ -418,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 verifies inspect --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\` / \`sdd test task <task_id> --branch ${branch}\`; 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

@@ -56,6 +56,8 @@ export const WORKFLOW_STATE_RESOLVER_CONTRACT_VERSION = 'phase-7.3-workflow-stat
 export const VERIFY_DOCUMENT_CONTRACT_VERSION = 'sdd-verify-doc-v1';
 export const AGENT_CAPABILITY_CATALOG_CONTRACT_VERSION = 'phase-7.6-agent-capability-catalog-v1';
 export const COMMAND_TEAM_RUNTIME_CONTRACT_VERSION = 'phase-7.7-command-team-runtime-v1';
+export const STAGE_TEAM_RUNTIME_CONTRACT_VERSION = 'phase-8.15-stage-team-runtime-v1';
+export const WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION = 'phase-8.16-workflow-gate-runtime-v1';
 export const RUNTIME_PROJECTION_ENVELOPE_CONTRACT_VERSION = 'sdd-runtime-projection-envelope-v1';
 export const CODING_FACT_SET_CONTRACT_VERSION = 'sdd-coding-fact-set-v1';
 export const CODING_RISK_PROFILE_CONTRACT_VERSION = 'sdd-coding-risk-profile-v1';
@@ -71,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;
 }