sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/registries/agent-capability-catalog.ts

@@ -3,7 +3,7 @@ import { parseProjectConfig } from '../config/project-config.js';
 import { getProjectConfigPath } from '../runtime-paths.js';
 import { readFile } from 'node:fs/promises';
 
-export type WorkflowCapabilityDomain = 'norm_discovery' | 'uncertainty_resolution' | 'performance_planning' | 'verification_design' | 'evidence_collection' | 'sync_back_risk_review' | 'release_summary' | 'context_curation';
+export type WorkflowCapabilityDomain = 'norm_discovery' | 'uncertainty_resolution' | 'performance_planning' | 'verification_design' | 'evidence_collection' | 'truth_alignment_review' | 'release_summary' | 'context_curation';
 export type ProfessionalCapabilityDomain = 'solution-design' | 'architecture-design' | 'backend-engineering' | 'frontend-engineering' | 'db-data-engineering' | 'testing-quality-engineering' | 'security-engineering' | 'performance-engineering' | 'observability-engineering' | 'release-engineering' | 'ui-ux-product-design';
 export type AgentCapabilityDomain = WorkflowCapabilityDomain | ProfessionalCapabilityDomain;
 export type AgentCapabilityDomainGroup = 'workflow' | 'professional';
@@ -20,7 +20,8 @@ export const REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS: ProfessionalCapabilityDom
   'release-engineering',
   'ui-ux-product-design'
 ];
-export type AgentCapabilityStage = 'spec' | 'plan' | 'tasks' | 'verifies' | 'test' | 'do' | 'verify' | 'sync-back' | 'ship';
+export type AgentCapabilityStage = 'spec' | 'plan' | 'tasks' | 'verifies' | 'test' | 'do' | 'verify' | 'goal-verify' | 'ship';
+export type CapabilityLifecycleHook = 'spec.capability_review' | 'plan.capability_strategy' | 'tasks.capability_topology' | 'do.capability_execution' | 'test.capability_validation' | 'goal_verify.capability_truth_alignment' | 'ship.capability_release_risk';
 export type AgentCapabilityAuthority = 'advisory_only' | 'gate_evidence' | 'validation_runner';
 export type MaterialPackLoadPolicy = 'route_when_triggered' | 'summary_only' | 'never_inline';
 export type AgentCapabilityMaterialPolicy = 'metadata_only' | 'route_baseline_pack' | 'runtime_evidence_required';
@@ -53,6 +54,7 @@ export interface AgentCapabilityCatalogEntry {
   authority: AgentCapabilityAuthority;
   materialPolicy: AgentCapabilityMaterialPolicy;
   evidenceExpectation: AgentCapabilityEvidenceExpectation;
+  lifecycleHooks: CapabilityLifecycleHook[];
   routing: {
     riskTags: string[];
     projectStackTags: string[];
@@ -64,6 +66,7 @@ export interface AgentCapabilityCatalogEntry {
     sourceVersion: string;
     quarantineRequired: boolean;
   };
+  finalAuthority: 'sdd_contract' | 'sdd_gate';
 }
 
 export interface CapabilityCommandMapping {
@@ -100,7 +103,7 @@ const MATERIAL_PACKS: AgentCapabilityMaterialPack[] = [
     'sdd_runtime_contract',
     'small',
     ['norm alignment note', 'coding convention cue'],
-    ['lifecycle gate authority', 'stage completion decision', 'sync-back apply decision', 'ship readiness pass']
+    ['lifecycle gate authority', 'stage completion decision', 'truth-alignment gate authority', 'ship readiness pass']
   ),
   materialPack(
     'uncertainty-map',
@@ -113,7 +116,7 @@ const MATERIAL_PACKS: AgentCapabilityMaterialPack[] = [
     'sdd_runtime_contract',
     'tiny',
     ['resolved assumption note', 'question checkpoint'],
-    ['lifecycle gate authority', 'stage completion decision', 'sync-back apply decision', 'ship readiness pass']
+    ['lifecycle gate authority', 'stage completion decision', 'truth-alignment gate authority', 'ship readiness pass']
   ),
   materialPack(
     'performance-risk',
@@ -126,7 +129,7 @@ const MATERIAL_PACKS: AgentCapabilityMaterialPack[] = [
     'sdd_runtime_contract',
     'tiny',
     ['performance risk note', 'context budget note'],
-    ['lifecycle gate authority', 'stage completion decision', 'sync-back apply decision', 'ship readiness pass']
+    ['lifecycle gate authority', 'stage completion decision', 'truth-alignment gate authority', 'ship readiness pass']
   ),
   materialPack(
     'verification-design',
@@ -139,20 +142,20 @@ const MATERIAL_PACKS: AgentCapabilityMaterialPack[] = [
     'sdd_runtime_contract',
     'small',
     ['verification matrix', 'evidence requirement'],
-    ['lifecycle gate authority', 'stage completion decision', 'sync-back apply decision', 'ship readiness pass']
+    ['lifecycle gate authority', 'stage completion decision', 'truth-alignment gate authority', 'ship readiness pass']
   ),
   materialPack(
-    'sync-back-risk',
-    ['sync_back_risk_review', 'release_summary'],
-    'Risk checks for applying semantic completion back into tasks and release state.',
-    ['sync-back', 'ship'],
-    ['sync-back', 'ship', 'release', 'apply', '发布'],
+    'truth-alignment-risk',
+    ['truth_alignment_review', 'release_summary'],
+    'Risk checks for aligning accepted goal verification reality with declared SDD truth before release.',
+    ['goal-verify', 'ship'],
+    ['truth-alignment', 'goal-verify', 'ship', 'release', '发布'],
     'summary_only',
     'governance_policy',
     'sdd_runtime_contract',
     'tiny',
-    ['apply risk note', 'release readiness concern'],
-    ['lifecycle gate authority', 'stage completion decision', 'sync-back apply decision', 'ship readiness pass']
+    ['truth alignment risk note', 'release readiness concern'],
+    ['lifecycle gate authority', 'stage completion decision', 'truth-alignment gate authority', 'ship readiness pass']
   ),
   professionalMaterialPack('baseline-solution-design', 'solution-design', 'Problem framing, option tradeoff, scope boundary, and success criteria review.', ['spec', 'plan'], ['solution', 'scope', 'tradeoff', 'goal', '方案'], ['problem framing', 'option tradeoff', 'scope boundary'], 'small'),
   professionalMaterialPack('baseline-architecture-design', 'architecture-design', 'System boundary, component responsibility, integration, and runtime constraint review.', ['plan', 'tasks'], ['architecture', 'boundary', 'integration', 'component', '架构'], ['architecture decision note', 'component boundary note', 'handoff risk'], 'small'),
@@ -163,7 +166,7 @@ const MATERIAL_PACKS: AgentCapabilityMaterialPack[] = [
   professionalMaterialPack('baseline-security-engineering', 'security-engineering', 'Trust boundary, secret handling, permissions, abuse case, and security evidence review.', ['spec', 'plan', 'tasks', 'do', 'test', 'ship'], ['security', 'secret', 'permission', 'auth', '安全'], ['security risk note', 'abuse case', 'security evidence requirement'], 'small'),
   professionalMaterialPack('baseline-performance-engineering', 'performance-engineering', 'Hot path, latency, resource use, benchmark, and capacity-risk review.', ['plan', 'tasks', 'do', 'test', 'ship'], ['performance', 'latency', 'resource', 'benchmark', '性能'], ['performance risk note', 'benchmark need', 'capacity consideration'], 'small'),
   professionalMaterialPack('baseline-observability-engineering', 'observability-engineering', 'Logging, metrics, tracing, diagnostic signal, and operator-readiness review.', ['plan', 'tasks', 'do', 'test', 'ship'], ['observability', 'logging', 'metrics', 'tracing', '可观测'], ['logging/metrics/tracing need', 'diagnostic gap', 'operability note'], 'small'),
-  professionalMaterialPack('baseline-release-engineering', 'release-engineering', 'Release scope, CI state, deployment risk, rollback, and readiness review.', ['tasks', 'test', 'sync-back', 'ship'], ['release', 'ci', 'deploy', 'rollback', '发布'], ['release readiness note', 'deployment risk', 'ship blocker'], 'small'),
+  professionalMaterialPack('baseline-release-engineering', 'release-engineering', 'Release scope, CI state, deployment risk, rollback, and readiness review.', ['tasks', 'test', 'goal-verify', 'ship'], ['release', 'ci', 'deploy', 'rollback', '发布'], ['release readiness note', 'deployment risk', 'ship blocker'], 'small'),
   professionalMaterialPack('baseline-ui-ux-product-design', 'ui-ux-product-design', 'User journey, interaction state, UX acceptance, accessibility, and design evidence review.', ['spec', 'plan', 'tasks', 'do', 'test'], ['ui', 'ux', 'design', 'figma', '交互'], ['UX acceptance note', 'interaction gap', 'design evidence requirement'], 'small')
 ];
 
@@ -173,20 +176,20 @@ const CAPABILITIES: AgentCapabilityCatalogEntry[] = [
   workflowCapability('cap.performance-planning', 'performance_planning', ['plan', 'tasks'], ['target design', 'runtime path', 'context usage', 'validation cost'], ['performance impact note', 'token risk note', 'validation cost control'], 'advisory_only', ['performance', 'context_budget', 'token_risk'], ['performance-risk'], 'skill_agent_eval'),
   workflowCapability('cap.verification-design', 'verification_design', ['verifies', 'test', 'verify'], ['tasks.md', 'verify.md', 'acceptance refs', 'runtime evidence'], ['verification matrix', 'evidence requirement', 'policy boundary'], 'gate_evidence', ['acceptance', 'evidence', 'policy'], ['verification-design'], 'verify_contract'),
   workflowCapability('cap.evidence-collection', 'evidence_collection', ['test', 'do', 'verify'], ['validation command', 'artifact refs', 'run state'], ['command evidence', 'artifact ref', 'provenance ref'], 'validation_runner', ['validation', 'runtime_evidence'], ['verification-design'], 'test_runtime'),
-  workflowCapability('cap.sync-back-risk-review', 'sync_back_risk_review', ['sync-back'], ['verify decision', 'sync-back proposal', 'tasks.md'], ['apply risk note', 'approval requirement'], 'gate_evidence', ['shared_state', 'semantic_update'], ['sync-back-risk'], 'governance_policy'),
-  workflowCapability('cap.release-summary', 'release_summary', ['ship'], ['task status', 'doctor report', 'pack output', 'git state'], ['release readiness summary', 'blocked release gap'], 'advisory_only', ['release', 'external_state'], ['sync-back-risk'], 'governance_policy'),
+  workflowCapability('cap.truth-alignment-review', 'truth_alignment_review', ['goal-verify', 'ship'], ['goal-verify decision', 'truthAlignment projection', 'declared truth refs'], ['truth alignment risk note', 'reconciliation requirement'], 'gate_evidence', ['shared_state', 'semantic_update'], ['truth-alignment-risk'], 'governance_policy'),
+  workflowCapability('cap.release-summary', 'release_summary', ['ship'], ['task status', 'doctor report', 'pack output', 'git state'], ['release readiness summary', 'blocked release gap'], 'advisory_only', ['release', 'external_state'], ['truth-alignment-risk'], 'governance_policy'),
   workflowCapability('cap.context-curation', 'context_curation', ['spec', 'plan', 'do', 'verify', 'ship'], ['material packs', 'context budget', 'run summaries'], ['context pack selection', 'excluded material list'], 'advisory_only', ['context_budget', 'prompt_bloat'], ['project-norms', 'uncertainty-map', 'performance-risk'], 'project_context_pack'),
-  professionalCapability('cap.solution-design', 'solution-design', ['spec', 'plan'], ['user goal', 'constraints', 'success criteria'], ['problem framing', 'solution option tradeoff', 'scope boundary'], ['architecture', 'ambiguous'], ['baseline-solution-design', 'project-norms', 'uncertainty-map']),
-  professionalCapability('cap.architecture-design', 'architecture-design', ['plan', 'tasks'], ['system boundaries', 'integration points', 'runtime constraints'], ['architecture decision', 'component boundary', 'handoff risk'], ['architecture', 'source_boundary'], ['baseline-architecture-design', 'project-norms', 'performance-risk']),
-  professionalCapability('cap.backend-engineering', 'backend-engineering', ['plan', 'tasks', 'do', 'test'], ['API contracts', 'service logic', 'runtime path'], ['backend implementation note', 'API risk note', 'validation need'], ['api-schema', 'runtime_state'], ['baseline-backend-engineering', 'project-norms', 'verification-design']),
-  professionalCapability('cap.frontend-engineering', 'frontend-engineering', ['plan', 'tasks', 'do', 'test'], ['UI state', 'component boundary', 'browser behavior'], ['frontend implementation note', 'interaction state risk', 'browser validation need'], ['frontend', 'accessibility'], ['baseline-frontend-engineering', 'project-norms', 'verification-design']),
-  professionalCapability('cap.db-data-engineering', 'db-data-engineering', ['plan', 'tasks', 'do', 'test', 'ship'], ['schema change', 'query path', 'migration plan'], ['data safety note', 'migration risk', 'rollback consideration'], ['database', 'data-loss'], ['baseline-db-data-engineering', 'project-norms', 'verification-design']),
-  professionalCapability('cap.testing-quality-engineering', 'testing-quality-engineering', ['verifies', 'test', 'verify'], ['acceptance refs', 'test command', 'quality risk'], ['test strategy', 'coverage gap', 'evidence requirement'], ['validation', 'acceptance'], ['baseline-testing-quality-engineering', 'verification-design']),
-  professionalCapability('cap.security-engineering', 'security-engineering', ['spec', 'plan', 'tasks', 'do', 'test', 'ship'], ['trust boundary', 'secret handling', 'permission model'], ['security risk note', 'abuse case', 'security evidence requirement'], ['security', 'token_secret'], ['baseline-security-engineering', 'project-norms', 'verification-design']),
-  professionalCapability('cap.performance-engineering', 'performance-engineering', ['plan', 'tasks', 'do', 'test', 'ship'], ['hot path', 'resource use', 'latency constraint'], ['performance risk note', 'benchmark need', 'capacity consideration'], ['performance', 'context_budget'], ['baseline-performance-engineering', 'performance-risk', 'verification-design']),
-  professionalCapability('cap.observability-engineering', 'observability-engineering', ['plan', 'tasks', 'do', 'test', 'ship'], ['runtime signal', 'failure mode', 'operator need'], ['logging/metrics/tracing need', 'diagnostic gap', 'operability note'], ['observability', 'runtime_state'], ['baseline-observability-engineering', 'project-norms', 'verification-design']),
-  professionalCapability('cap.release-engineering', 'release-engineering', ['tasks', 'test', 'sync-back', 'ship'], ['release scope', 'CI state', 'rollback need'], ['release readiness note', 'deployment risk', 'ship blocker'], ['release', 'ci-build'], ['baseline-release-engineering', 'sync-back-risk', 'verification-design']),
-  professionalCapability('cap.ui-ux-product-design', 'ui-ux-product-design', ['spec', 'plan', 'tasks', 'do', 'test'], ['user journey', 'interaction state', 'design constraint'], ['UX acceptance note', 'interaction gap', 'design evidence requirement'], ['ui-ux', 'accessibility'], ['baseline-ui-ux-product-design', 'project-norms', 'uncertainty-map'])
+  professionalCapability('cap.solution-design', 'solution-design', ['spec', 'plan'], ['spec.capability_review', 'plan.capability_strategy'], ['user goal', 'constraints', 'success criteria'], ['problem framing', 'solution option tradeoff', 'scope boundary'], ['architecture', 'ambiguous'], ['baseline-solution-design', 'project-norms', 'uncertainty-map']),
+  professionalCapability('cap.architecture-design', 'architecture-design', ['plan', 'tasks'], ['plan.capability_strategy', 'tasks.capability_topology'], ['system boundaries', 'integration points', 'runtime constraints'], ['architecture decision', 'component boundary', 'handoff risk'], ['architecture', 'source_boundary'], ['baseline-architecture-design', 'project-norms', 'performance-risk']),
+  professionalCapability('cap.backend-engineering', 'backend-engineering', ['plan', 'tasks', 'do', 'test'], ['plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation'], ['API contracts', 'service logic', 'runtime path'], ['backend implementation note', 'API risk note', 'validation need'], ['api-schema', 'runtime_state'], ['baseline-backend-engineering', 'project-norms', 'verification-design']),
+  professionalCapability('cap.frontend-engineering', 'frontend-engineering', ['spec', 'plan', 'tasks', 'do', 'test'], ['spec.capability_review', 'plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation'], ['UI state', 'component boundary', 'browser behavior'], ['frontend implementation note', 'interaction state risk', 'browser validation need'], ['frontend', 'accessibility'], ['baseline-frontend-engineering', 'project-norms', 'verification-design']),
+  professionalCapability('cap.db-data-engineering', 'db-data-engineering', ['plan', 'tasks', 'do', 'test', 'ship'], ['plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation', 'ship.capability_release_risk'], ['schema change', 'query path', 'migration plan'], ['data safety note', 'migration risk', 'rollback consideration'], ['database', 'data-loss'], ['baseline-db-data-engineering', 'project-norms', 'verification-design']),
+  professionalCapability('cap.testing-quality-engineering', 'testing-quality-engineering', ['verifies', 'test', 'verify'], ['tasks.capability_topology', 'test.capability_validation'], ['acceptance refs', 'test command', 'quality risk'], ['test strategy', 'coverage gap', 'evidence requirement'], ['validation', 'acceptance'], ['baseline-testing-quality-engineering', 'verification-design']),
+  professionalCapability('cap.security-engineering', 'security-engineering', ['spec', 'plan', 'tasks', 'do', 'test', 'ship'], ['spec.capability_review', 'plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation', 'ship.capability_release_risk'], ['trust boundary', 'secret handling', 'permission model'], ['security risk note', 'abuse case', 'security evidence requirement'], ['security', 'token_secret'], ['baseline-security-engineering', 'project-norms', 'verification-design']),
+  professionalCapability('cap.performance-engineering', 'performance-engineering', ['plan', 'tasks', 'do', 'test', 'ship'], ['plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation', 'ship.capability_release_risk'], ['hot path', 'resource use', 'latency constraint'], ['performance risk note', 'benchmark need', 'capacity consideration'], ['performance', 'context_budget'], ['baseline-performance-engineering', 'performance-risk', 'verification-design']),
+  professionalCapability('cap.observability-engineering', 'observability-engineering', ['plan', 'tasks', 'do', 'test', 'ship'], ['plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation', 'ship.capability_release_risk'], ['runtime signal', 'failure mode', 'operator need'], ['logging/metrics/tracing need', 'diagnostic gap', 'operability note'], ['observability', 'runtime_state'], ['baseline-observability-engineering', 'project-norms', 'verification-design']),
+  professionalCapability('cap.release-engineering', 'release-engineering', ['tasks', 'test', 'goal-verify', 'ship'], ['tasks.capability_topology', 'test.capability_validation', 'goal_verify.capability_truth_alignment', 'ship.capability_release_risk'], ['release scope', 'CI state', 'rollback need'], ['release readiness note', 'deployment risk', 'ship blocker'], ['release', 'ci-build'], ['baseline-release-engineering', 'truth-alignment-risk', 'verification-design']),
+  professionalCapability('cap.ui-ux-product-design', 'ui-ux-product-design', ['spec', 'plan', 'tasks', 'do', 'test'], ['spec.capability_review', 'plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation'], ['user journey', 'interaction state', 'design constraint'], ['UX acceptance note', 'interaction gap', 'design evidence requirement'], ['ui-ux', 'accessibility'], ['baseline-ui-ux-product-design', 'project-norms', 'uncertainty-map'])
 ];
 
 const COMMAND_MAPPINGS: CapabilityCommandMapping[] = [
@@ -195,8 +198,8 @@ const COMMAND_MAPPINGS: CapabilityCommandMapping[] = [
   { command: 'verifies', requiredDomains: ['verification_design'], optionalDomains: ['context_curation'], forbiddenAuthority: ['validation_runner'], materialPolicy: 'route_when_triggered' },
   { command: 'test', requiredDomains: ['evidence_collection'], optionalDomains: ['verification_design'], forbiddenAuthority: [], materialPolicy: 'route_when_triggered' },
   { command: 'verify', requiredDomains: ['verification_design', 'evidence_collection'], optionalDomains: ['context_curation'], forbiddenAuthority: [], materialPolicy: 'route_when_triggered' },
-  { command: 'sync-back', requiredDomains: ['sync_back_risk_review'], optionalDomains: ['context_curation'], forbiddenAuthority: ['validation_runner'], materialPolicy: 'summary_only' },
-  { command: 'ship', requiredDomains: ['release_summary', 'sync_back_risk_review'], optionalDomains: ['context_curation'], forbiddenAuthority: ['validation_runner'], materialPolicy: 'summary_only' }
+  { command: 'goal-verify', requiredDomains: ['truth_alignment_review'], optionalDomains: ['context_curation'], forbiddenAuthority: ['validation_runner'], materialPolicy: 'summary_only' },
+  { command: 'ship', requiredDomains: ['release_summary', 'truth_alignment_review'], optionalDomains: ['context_curation'], forbiddenAuthority: ['validation_runner'], materialPolicy: 'summary_only' }
 ];
 
 export async function inspectAgentCapabilityCatalog(projectRoot: string): Promise<AgentCapabilityCatalog> {
@@ -224,11 +227,11 @@ function workflowCapability(id: string, domain: WorkflowCapabilityDomain, stages
   return capability(id, domain, 'workflow', stages, inputs, outputs, authority, riskTags, materialPackIds, sourceId);
 }
 
-function professionalCapability(id: string, domain: ProfessionalCapabilityDomain, stages: AgentCapabilityStage[], inputs: string[], outputs: string[], riskTags: string[], materialPackIds: string[]): AgentCapabilityCatalogEntry {
-  return capability(id, domain, 'professional', stages, inputs, outputs, 'advisory_only', riskTags, materialPackIds, 'sdd_professional_baseline');
+function professionalCapability(id: string, domain: ProfessionalCapabilityDomain, stages: AgentCapabilityStage[], lifecycleHooks: CapabilityLifecycleHook[], inputs: string[], outputs: string[], riskTags: string[], materialPackIds: string[]): AgentCapabilityCatalogEntry {
+  return capability(id, domain, 'professional', stages, inputs, outputs, 'advisory_only', riskTags, materialPackIds, 'sdd_professional_baseline', lifecycleHooks);
 }
 
-function capability(id: string, domain: AgentCapabilityDomain, domainGroup: AgentCapabilityDomainGroup, stages: AgentCapabilityStage[], inputs: string[], outputs: string[], authority: AgentCapabilityAuthority, riskTags: string[], materialPackIds: string[], sourceId: string): AgentCapabilityCatalogEntry {
+function capability(id: string, domain: AgentCapabilityDomain, domainGroup: AgentCapabilityDomainGroup, stages: AgentCapabilityStage[], inputs: string[], outputs: string[], authority: AgentCapabilityAuthority, riskTags: string[], materialPackIds: string[], sourceId: string, lifecycleHooks: CapabilityLifecycleHook[] = hooksForStages(stages)): AgentCapabilityCatalogEntry {
   return {
     version: AGENT_CAPABILITY_CATALOG_CONTRACT_VERSION,
     id,
@@ -240,6 +243,7 @@ function capability(id: string, domain: AgentCapabilityDomain, domainGroup: Agen
     authority,
     materialPolicy: capabilityMaterialPolicy(authority),
     evidenceExpectation: capabilityEvidenceExpectation(authority),
+    lifecycleHooks,
     routing: {
       riskTags,
       projectStackTags: projectStackTagsForDomain(domain),
@@ -250,7 +254,8 @@ function capability(id: string, domain: AgentCapabilityDomain, domainGroup: Agen
       sourceId,
       sourceVersion: '0.3.0',
       quarantineRequired: false
-    }
+    },
+    finalAuthority: authority === 'validation_runner' || authority === 'gate_evidence' ? 'sdd_gate' : 'sdd_contract'
   };
 }
 
@@ -265,6 +270,34 @@ function capabilityEvidenceExpectation(authority: AgentCapabilityAuthority): Age
   return 'candidate_evidence';
 }
 
+function hooksForStages(stages: AgentCapabilityStage[]): CapabilityLifecycleHook[] {
+  const hooks = stages.flatMap((stage) => {
+    if (stage === 'spec') {
+      return ['spec.capability_review' as const];
+    }
+    if (stage === 'plan') {
+      return ['plan.capability_strategy' as const];
+    }
+    if (stage === 'tasks' || stage === 'verifies' || stage === 'verify') {
+      return ['tasks.capability_topology' as const];
+    }
+    if (stage === 'do') {
+      return ['do.capability_execution' as const];
+    }
+    if (stage === 'test') {
+      return ['test.capability_validation' as const];
+    }
+    if (stage === 'goal-verify') {
+      return ['goal_verify.capability_truth_alignment' as const];
+    }
+    if (stage === 'ship') {
+      return ['ship.capability_release_risk' as const];
+    }
+    return [];
+  });
+  return uniqueSorted(hooks);
+}
+
 function projectStackTagsForDomain(domain: AgentCapabilityDomain): string[] {
   if (domain === 'frontend-engineering' || domain === 'ui-ux-product-design') {
     return ['frontend', 'browser', 'component', 'tsx', 'jsx', 'css'];
@@ -302,7 +335,7 @@ function materialPack(id: string, domains: AgentCapabilityDomain[], summary: str
     triggerKeywords,
     loadPolicy,
     sourceId,
-    sourceVersion: '0.4.1',
+    sourceVersion: '0.4.2',
     sourceKind,
     contextBudget,
     expectedOutputs,
@@ -322,12 +355,13 @@ function professionalMaterialPack(id: string, domain: ProfessionalCapabilityDoma
     'sdd_native_baseline',
     contextBudget,
     expectedOutputs,
-    ['lifecycle gate authority', 'stage completion decision', 'sync-back apply decision', 'ship readiness pass', 'host-specific skill projection']
+    ['lifecycle gate authority', 'stage completion decision', 'truth-alignment gate authority', 'ship readiness pass', 'host-specific skill projection']
   );
 }
 
 
 function validateCatalog(catalog: AgentCapabilityCatalog): string[] {
+  const requiredHooks: CapabilityLifecycleHook[] = ['spec.capability_review', 'plan.capability_strategy', 'tasks.capability_topology', 'do.capability_execution', 'test.capability_validation', 'goal_verify.capability_truth_alignment', 'ship.capability_release_risk'];
   const issues: string[] = [];
   const packById = new Map(catalog.materialPacks.map((pack) => [pack.id, pack]));
   const packIds = new Set(packById.keys());
@@ -370,6 +404,9 @@ function validateCatalog(catalog: AgentCapabilityCatalog): string[] {
     if (!capability.materialPolicy || !capability.evidenceExpectation) {
       issues.push(`${capability.id}: material policy and evidence expectation are required.`);
     }
+    if (capability.lifecycleHooks.length === 0) {
+      issues.push(`${capability.id}: lifecycle hooks are required.`);
+    }
     if (capability.routing.projectStackTags.length === 0) {
       issues.push(`${capability.id}: project stack tags are required.`);
     }
@@ -402,6 +439,12 @@ function validateCatalog(catalog: AgentCapabilityCatalog): string[] {
       issues.push(`required professional domain ${domain} has no SDD-native baseline pack.`);
     }
   }
+  const professionalHooks = new Set(catalog.capabilities.filter((entry) => entry.domainGroup === 'professional').flatMap((entry) => entry.lifecycleHooks));
+  for (const hook of requiredHooks) {
+    if (!professionalHooks.has(hook)) {
+      issues.push(`professional lifecycle hook ${hook} is missing.`);
+    }
+  }
   for (const mapping of catalog.commandMappings) {
     for (const domain of mapping.requiredDomains) {
       if (!domains.has(domain)) {
@@ -415,6 +458,10 @@ function validateCatalog(catalog: AgentCapabilityCatalog): string[] {
   return issues;
 }
 
+function uniqueSorted<T extends string>(values: T[]): T[] {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
 function isRequiredProfessionalDomain(domain: AgentCapabilityDomain): domain is ProfessionalCapabilityDomain {
   return REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS.includes(domain as ProfessionalCapabilityDomain);
 }

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

@@ -32,10 +32,10 @@ const BUILT_IN_AGENT_REGISTRY: AgentRegistryEntry[] = [
     role: 'Collect bounded local context and uncertainty without editing files.',
     allowedStages: ['spec', 'plan', 'do', 'doctor'],
     capabilities: ['read files', 'search symbols', 'summarize evidence', 'identify gaps'],
-    readBoundary: ['project files', 'spec/plan/task snippets', 'existing artifacts'],
-    writeBoundary: ['artifacts/scout-<task>.md only when explicitly requested'],
+    readBoundary: ['project files', 'spec/plan/task snippets', 'accepted stage evidence'],
+    writeBoundary: ['.sdd/runs/<branch>/<stage>/scout-vN.md only when explicitly requested'],
     toolAllowlist: ['read', 'grep', 'glob', 'semantic search'],
-    requiredArtifact: 'artifacts/scout-<task>.md',
+    requiredArtifact: '.sdd/runs/<branch>/<stage>/scout-vN.md',
     verificationExpectation: 'Findings are evidence-backed and scoped to the exploration question.',
     autonomyCeiling: 'read_only',
     stopCondition: 'Stop when evidence paths and remaining uncertainty are clear.'
@@ -49,7 +49,7 @@ const BUILT_IN_AGENT_REGISTRY: AgentRegistryEntry[] = [
     readBoundary: ['spec document', 'user request', 'related plan snippets'],
     writeBoundary: ['review artifact or proposed spec edits after approval'],
     toolAllowlist: ['read', 'grep'],
-    requiredArtifact: 'artifacts/spec-review-<task>.md',
+    requiredArtifact: '.sdd/runs/<branch>/spec/spec-review-vN.md',
     verificationExpectation: 'Spec gaps are explicit and do not silently advance to plan.',
     autonomyCeiling: 'review_only',
     stopCondition: 'Stop when spec is ready for plan or blocking gaps are listed.'
@@ -75,9 +75,9 @@ const BUILT_IN_AGENT_REGISTRY: AgentRegistryEntry[] = [
     allowedStages: ['do'],
     capabilities: ['edit files', 'run bounded validation', 'produce implementation evidence'],
     readBoundary: ['selected task', 'approved spec/plan', 'affected files'],
-    writeBoundary: ['declared affected files', 'artifacts/implement-<task>.md'],
-    toolAllowlist: ['read', 'edit', 'write scoped artifacts', 'validation command'],
-    requiredArtifact: 'artifacts/implement-<task>.md',
+    writeBoundary: ['declared affected files', '.sdd/runs/<branch>/do/implementation-vN.md'],
+    toolAllowlist: ['read', 'edit', 'write scoped evidence', 'validation command'],
+    requiredArtifact: '.sdd/runs/<branch>/do/implementation-vN.md',
     verificationExpectation: 'Changes stay inside boundary and are ready for independent review.',
     autonomyCeiling: 'foreground_write',
     stopCondition: 'Stop on boundary expansion, missing validation, or required human checkpoint.'
@@ -88,10 +88,10 @@ const BUILT_IN_AGENT_REGISTRY: AgentRegistryEntry[] = [
     role: 'Review diff and task evidence against boundary and acceptance.',
     allowedStages: ['do', 'verify'],
     capabilities: ['diff review', 'risk check', 'gap report'],
-    readBoundary: ['diff', 'task metadata', 'implementation artifact'],
-    writeBoundary: ['artifacts/review-<task>.md'],
+    readBoundary: ['diff', 'task metadata', 'implementation evidence'],
+    writeBoundary: ['.sdd/runs/<branch>/do/code-review-vN.md'],
     toolAllowlist: ['read', 'grep', 'git diff'],
-    requiredArtifact: 'artifacts/review-<task>.md',
+    requiredArtifact: '.sdd/runs/<branch>/do/code-review-vN.md',
     verificationExpectation: 'Review decision is traceable to task boundary and acceptance.',
     autonomyCeiling: 'review_only',
     stopCondition: 'Stop when approval, requested changes, or blocking gaps are explicit.'
@@ -103,9 +103,9 @@ const BUILT_IN_AGENT_REGISTRY: AgentRegistryEntry[] = [
     allowedStages: ['do'],
     capabilities: ['failure triage', 'minimal fix proposal', 'gap isolation'],
     readBoundary: ['validation output', 'changed files', 'task boundary'],
-    writeBoundary: ['artifacts/debug-<task>.md', 'minimal fix only after checkpoint'],
+    writeBoundary: ['.sdd/runs/<branch>/do/debug-vN.md', 'minimal fix only after checkpoint'],
     toolAllowlist: ['read', 'grep', 'validation command'],
-    requiredArtifact: 'artifacts/debug-<task>.md',
+    requiredArtifact: '.sdd/runs/<branch>/do/debug-vN.md',
     verificationExpectation: 'Failure cause and fix boundary are explicit.',
     autonomyCeiling: 'foreground_write',
     stopCondition: 'Stop after one bounded attempt or when cause is unclear.'
@@ -116,10 +116,10 @@ const BUILT_IN_AGENT_REGISTRY: AgentRegistryEntry[] = [
     role: 'Map acceptance criteria to review, diff, and command evidence.',
     allowedStages: ['verify'],
     capabilities: ['run declared validation', 'acceptance mapping', 'evidence sufficiency summary'],
-    readBoundary: ['task acceptance', 'review artifact', 'validation outputs'],
-    writeBoundary: ['artifacts/validation-<task>.md'],
+    readBoundary: ['task acceptance', 'review evidence', 'validation outputs'],
+    writeBoundary: ['.sdd/runs/<branch>/test/validation-vN.md'],
     toolAllowlist: ['read', 'validation command'],
-    requiredArtifact: 'artifacts/validation-<task>.md',
+    requiredArtifact: '.sdd/runs/<branch>/test/validation-vN.md',
     verificationExpectation: 'PASS requires acceptance evidence, not just command success.',
     autonomyCeiling: 'validation_only',
     stopCondition: 'Stop when acceptance evidence mapping and unresolved gaps are clear.'

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

@@ -92,7 +92,7 @@ export const BUILT_IN_HOST_ADAPTER_CONTRACT: BuiltInHostAdapterContract = {
   id: 'claude-code-host-adapter',
   host: 'Claude Code / future host adapter',
   responsibilities: ['project SDD router decisions to host subagents, skills, MCPs and shell tools', 'return host session/task id, status, output, artifacts and tool summary', 'record host output as provenance'],
-  forbiddenAuthority: ['task lifecycle truth', 'completion state', 'risk gate authority', 'sync-back authority', 'required artifact policy'],
+  forbiddenAuthority: ['task lifecycle truth', 'completion state', 'risk gate authority', 'truth-alignment authority', 'required artifact policy'],
   projections: ['short profile prompt projection', 'tool permission summary', 'model policy category', 'required evidence targets', 'host-neutral workflow intent projection'],
   workflowProjectionPolicy: 'Core emits host-neutral canonical CLI commands and workflow intent; host adapters may expose slash commands, skills, commands, settings, or permissions as projection metadata only.',
   workflowProjections: [

package/node_modules/@sdd-agent-platform/core/src/registries/capability-sources.ts

@@ -10,7 +10,7 @@ import type {
 const FORBIDDEN_RUNTIME_AUTHORITY = [
   'lifecycle gate authority',
   'stage completion decision',
-  'sync-back apply decision',
+  'truth-alignment approval',
   'ship readiness pass',
   'permission escalation'
 ];

package/node_modules/@sdd-agent-platform/core/src/registries/command-team-runtime.ts

@@ -5,7 +5,7 @@ import { readFile } from 'node:fs/promises';
 import { inspectAgentCapabilityCatalog, type AgentCapabilityAuthority, type AgentCapabilityDomain, type AgentCapabilityMaterialPack, type MaterialPackLoadPolicy } from './agent-capability-catalog.js';
 import { listRuntimeProjections, recordRuntimeProjection } from '../storage/runtime-store.js';
 
-export type CommandTeamRuntimeCommand = 'spec' | 'plan' | 'tasks' | 'verifies' | 'do' | 'test' | 'verify' | 'sync-back' | 'ship' | 'doctor-deep' | 'recover';
+export type CommandTeamRuntimeCommand = 'spec' | 'plan' | 'tasks' | 'verifies' | 'do' | 'test' | 'verify' | 'goal-verify' | 'ship' | 'doctor-deep' | 'recover';
 export type CommandTeamMode = 'single' | 'team-lite' | 'team-required' | 'blocked';
 export type CommandTeamActivation = 'auto' | 'force' | 'off';
 export type CommandRoleKind = 'scout' | 'planner' | 'implementer' | 'reviewer' | 'validator' | 'risk-reviewer' | 'summarizer' | 'operator';
@@ -80,8 +80,8 @@ const ROLES: CommandRoleProfile[] = [
   role('role.verification-designer', 'validator', ['verification_design'], 'gate_evidence', ['verification-design'], 'small', true, true),
   role('role.evidence-runner', 'operator', ['evidence_collection'], 'validation_runner', ['verification-design'], 'small', true, true),
   role('role.implementation-reviewer', 'reviewer', ['verification_design'], 'gate_evidence', ['verification-design'], 'small', true, true),
-  role('role.sync-risk-reviewer', 'risk-reviewer', ['sync_back_risk_review'], 'gate_evidence', ['sync-back-risk'], 'tiny', true, true),
-  role('role.release-summarizer', 'summarizer', ['release_summary'], 'advisory_only', ['sync-back-risk'], 'tiny', true, false),
+  role('role.truth-alignment-reviewer', 'risk-reviewer', ['truth_alignment_review'], 'gate_evidence', ['truth-alignment-risk'], 'tiny', true, true),
+  role('role.release-summarizer', 'summarizer', ['release_summary'], 'advisory_only', ['truth-alignment-risk'], 'tiny', true, false),
   role('role.context-curator', 'scout', ['context_curation'], 'advisory_only', ['project-norms', 'uncertainty-map', 'performance-risk'], 'tiny', true, false)
 ];
 
@@ -93,16 +93,16 @@ const COMMAND_PROFILES: CommandTeamRuntimeProfile[] = [
   profile('do', 'single', ['implementation_review', 'shared_state'], ['role.implementation-reviewer'], ['role.context-curator'], 'gate_decides', 'route_when_triggered', 'small'),
   profile('test', 'single', ['validation', 'runtime_evidence'], ['role.evidence-runner'], ['role.verification-designer'], 'gate_decides', 'route_when_triggered', 'small'),
   profile('verify', 'team-lite', ['acceptance', 'runtime_evidence'], ['role.verification-designer', 'role.evidence-runner'], ['role.context-curator'], 'gate_decides', 'route_when_triggered', 'small'),
-  profile('sync-back', 'team-lite', ['shared_state', 'semantic_update'], ['role.sync-risk-reviewer'], ['role.context-curator'], 'gate_decides', 'summary_only', 'tiny'),
-  profile('ship', 'team-lite', ['release', 'external_state'], ['role.release-summarizer', 'role.sync-risk-reviewer'], ['role.context-curator'], 'runner_decides', 'summary_only', 'tiny'),
-  profile('doctor-deep', 'team-lite', ['runtime_evidence', 'stale_evidence'], ['role.context-curator', 'role.sync-risk-reviewer'], ['role.release-summarizer'], 'runner_decides', 'summary_only', 'tiny'),
-  profile('recover', 'team-required', ['blocked', 'stale_evidence', 'shared_state'], ['role.context-curator', 'role.sync-risk-reviewer', 'role.verification-designer'], ['role.release-summarizer'], 'gate_decides', 'summary_only', 'small')
+  profile('goal-verify', 'team-lite', ['shared_state', 'semantic_update'], ['role.truth-alignment-reviewer'], ['role.context-curator'], 'gate_decides', 'summary_only', 'tiny'),
+  profile('ship', 'team-lite', ['release', 'external_state'], ['role.release-summarizer', 'role.truth-alignment-reviewer'], ['role.context-curator'], 'runner_decides', 'summary_only', 'tiny'),
+  profile('doctor-deep', 'team-lite', ['runtime_evidence', 'stale_evidence'], ['role.context-curator', 'role.truth-alignment-reviewer'], ['role.release-summarizer'], 'runner_decides', 'summary_only', 'tiny'),
+  profile('recover', 'team-required', ['blocked', 'stale_evidence', 'shared_state'], ['role.context-curator', 'role.truth-alignment-reviewer', 'role.verification-designer'], ['role.release-summarizer'], 'gate_decides', 'summary_only', 'small')
 ];
 
 const INDEPENDENCE_RULES: CommandRoleIndependenceRule[] = [
   independence('ind.verify.runner-designer', 'verify', 'role.evidence-runner', 'role.verification-designer', 'Verification design and executed evidence must remain distinguishable.'),
-  independence('ind.ship.summary-risk', 'ship', 'role.release-summarizer', 'role.sync-risk-reviewer', 'Release summary cannot replace shared-state risk review.'),
-  independence('ind.recover.context-risk', 'recover', 'role.context-curator', 'role.sync-risk-reviewer', 'Recovery context selection cannot approve its own shared-state changes.'),
+  independence('ind.ship.summary-risk', 'ship', 'role.release-summarizer', 'role.truth-alignment-reviewer', 'Release summary cannot replace truth-alignment risk review.'),
+  independence('ind.recover.context-risk', 'recover', 'role.context-curator', 'role.truth-alignment-reviewer', 'Recovery context selection cannot approve its own shared-state changes.'),
   independence('ind.test.runner-designer', 'test', 'role.evidence-runner', 'role.verification-designer', 'Validation command execution must not be treated as verification design when both roles are active.')
 ];
 
@@ -244,7 +244,7 @@ function validateInspection(inspection: CommandTeamRuntimeInspection, domains: S
   const issues: string[] = [];
   const roleIds = new Set(inspection.roles.map((roleProfile) => roleProfile.id));
   const commandIds = new Set<CommandTeamRuntimeCommand>();
-  const expectedCommands: CommandTeamRuntimeCommand[] = ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'verify', 'sync-back', 'ship', 'doctor-deep', 'recover'];
+  const expectedCommands: CommandTeamRuntimeCommand[] = ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'verify', 'goal-verify', 'ship', 'doctor-deep', 'recover'];
 
   for (const roleProfile of inspection.roles) {
     if (roleProfile.requiredDomains.length === 0) {

package/node_modules/@sdd-agent-platform/core/src/registries/eval-learning-context.ts

@@ -103,7 +103,7 @@ const HARNESS_LEARNING_SINKS: HarnessLearningSink[] = [
   { id: 'generated_entry_guidance', output: 'Managed command or skill wording update.', boundary: 'Must remain sdd-managed and refresh through update rather than user-file overwrite.' }
 ];
 
-const HARNESS_LEARNING_FORBIDDEN_OUTPUTS = ['self-modifying runtime', 'hidden background automation', 'unapproved sync-back apply', 'replacement of .sdd/project.yml/specs/runtime.sqlite/branch evidence as source of truth'];
+const HARNESS_LEARNING_FORBIDDEN_OUTPUTS = ['self-modifying runtime', 'hidden background automation', 'unapproved truth-alignment approval', 'replacement of .sdd/project.yml/specs/runtime.sqlite/branch evidence as source of truth'];
 
 const PROJECT_CONTEXT_PACK: ProjectContextPackContract = {
   version: PROJECT_CONTEXT_PACK_CONTRACT_VERSION,
@@ -117,7 +117,7 @@ const PROJECT_CONTEXT_PACK: ProjectContextPackContract = {
     '.sdd/project.yml for project configuration',
     'specs/<branch>/spec.md, plan.md, and tasks.md for semantic state',
     '.sdd/runtime.sqlite for runtime execution facts',
-    '.sdd/runs/<branchSlug>/evidence/artifacts/*.md for agent and validation evidence'
+    '.sdd/runs/<branch>/<stage>/*.md for agent-authored stage evidence'
   ],
   boundaries: [
     'Context pack may prime future sessions but cannot mark tasks complete.',
@@ -213,8 +213,8 @@ export async function validateProjectContextPackContract(projectRoot: string): P
   if (await shouldValidatePlatformProjectAssets(projectRoot) && !await exists(path.join(projectRoot, contract.entryPoint))) {
     issues.push(contractIssue('projectContextPack.entryPoint', `Context pack entry point is missing: ${contract.entryPoint}.`, 'Restore context/memory/MEMORY.md or update the context pack entry point.'));
   }
-  if (!contract.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/project.yml')) || !contract.runtimeSourcesOfTruth.some((source) => source.includes('specs/<branch>')) || !contract.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/runs'))) {
-    issues.push(contractIssue('projectContextPack.runtimeSourcesOfTruth', 'Context pack does not name the structured runtime sources of truth.', 'Declare .sdd/project.yml, specs/<branch>, and .sdd/runs as runtime sources of truth.'));
+  if (!contract.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/project.yml')) || !contract.runtimeSourcesOfTruth.some((source) => source.includes('specs/<branch>')) || !contract.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/runtime.sqlite')) || !contract.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/runs/<branch>/<stage>'))) {
+    issues.push(contractIssue('projectContextPack.runtimeSourcesOfTruth', 'Context pack does not name the structured runtime sources of truth.', 'Declare .sdd/project.yml, specs/<branch>, .sdd/runtime.sqlite, and .sdd/runs/<branch>/<stage> stage evidence as runtime sources of truth.'));
   }
   if (!contract.boundaries.some((boundary) => boundary.includes('cannot mark tasks complete'))) {
     issues.push(contractIssue('projectContextPack.boundaries', 'Context pack boundary does not prevent runtime state mutation.', 'Declare that context memory cannot mark tasks complete or replace runtime evidence.'));

package/node_modules/@sdd-agent-platform/core/src/registries/query-status.ts

@@ -54,9 +54,9 @@ const QUERY_STATUS_SURFACES: QueryStatusSurface[] = [
     id: 'run_inspect',
     command: 'sdd run inspect <run_id>',
     responsibility: 'Inspect one run as execution evidence.',
-    includes: ['run state', 'recent events', 'artifacts', 'artifact ingestions', 'validation', 'sync-back proposal', 'task-run evidence'],
+    includes: ['run state', 'recent events', 'artifacts', 'artifact ingestions', 'validation', 'truth-alignment state', 'task-run evidence'],
     excludes: ['project-wide health audit', 'branch route recommendation'],
-    nextActionRule: 'Point to evidence inspection, verify, or sync-back based on run state.'
+    nextActionRule: 'Point to evidence inspection, test, goal-verify, or ship based on run state.'
   },
   {
     id: 'debug',

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

@@ -44,7 +44,7 @@ test('Phase 5.2 workflow gates and agent registry expose inspectable contracts',
     assert.equal(agents.agents.some((agent) => agent.id === 'validator'), true);
     assert.ok(doWorkflow);
     assert.equal(doWorkflow.allowedAgents.includes('implementer'), true);
-    assert.equal(doWorkflow.requiredArtifacts.includes('artifacts/validation-<task>.md'), true);
+    assert.equal(doWorkflow.requiredArtifacts.includes('.sdd/runs/<branch>/do/do-manager-vN.md'), true);
     assert.ok(implementer);
     assert.equal(implementer.autonomyCeiling, 'foreground_write');
     assert.equal(implementer.writeBoundary.includes('declared affected files'), true);
@@ -123,7 +123,9 @@ test('Phase 5.5 eval, learning, and context pack contracts validate against ERP
   assert.equal(contextPack.entryPoint, 'context/memory/MEMORY.md');
   assert.equal(contextPack.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/project.yml')), true);
   assert.equal(contextPack.runtimeSourcesOfTruth.some((source) => source.includes('specs/<branch>')), true);
-  assert.equal(contextPack.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/runs')), true);
+  assert.equal(contextPack.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/runtime.sqlite')), true);
+  assert.equal(contextPack.runtimeSourcesOfTruth.some((source) => source.includes('.sdd/runs/<branch>/<stage>')), true);
+  assert.equal(contextPack.runtimeSourcesOfTruth.some((source) => source.includes('runs/<branch>/<stage>') && !source.includes('.sdd/runs/<branch>/<stage>')), false);
   assert.equal(contextValidation.valid, true);
 });
 
@@ -172,6 +174,16 @@ test('Phase 7.6 agent capability catalog routes domains and material packs witho
     const verifiesMapping = catalog.commandMappings.find((mapping) => mapping.command === 'verifies');
     const contextCapability = catalog.capabilities.find((capability) => capability.domain === 'context_curation');
 
+    const lifecycleHooks = new Set(catalog.capabilities.filter((capability) => capability.domainGroup === 'professional').flatMap((capability) => capability.lifecycleHooks));
+    const requiredLifecycleHooks = [
+      'spec.capability_review',
+      'plan.capability_strategy',
+      'tasks.capability_topology',
+      'do.capability_execution',
+      'test.capability_validation',
+      'goal_verify.capability_truth_alignment',
+      'ship.capability_release_risk'
+    ];
     assert.equal(catalog.version, 'phase-7.6-agent-capability-catalog-v1');
     assert.equal(validation.valid, true);
     assert.equal(catalog.capabilities.length, 19);
@@ -198,8 +210,12 @@ test('Phase 7.6 agent capability catalog routes domains and material packs witho
       assert.equal(pack?.loadPolicy, 'route_when_triggered');
       assert.equal(pack?.forbiddenUses.includes('host-specific skill projection'), true);
     }
+    for (const hook of requiredLifecycleHooks) {
+      assert.equal(lifecycleHooks.has(hook), true);
+    }
     assert.equal(catalog.capabilities.every((capability) => capability.materialPolicy.length > 0 && capability.evidenceExpectation.length > 0), true);
     assert.equal(catalog.capabilities.every((capability) => capability.routing.projectStackTags.length > 0), true);
+    assert.equal(catalog.capabilities.every((capability) => capability.lifecycleHooks.length > 0 && (capability.finalAuthority === 'sdd_contract' || capability.finalAuthority === 'sdd_gate')), true);
     assert.equal(backendCapability?.routing.projectStackTags.includes('api'), true);
     assert.equal(frontendCapability?.routing.projectStackTags.includes('tsx'), true);
     assert.equal(databaseCapability?.routing.projectStackTags.includes('sql'), true);

package/node_modules/@sdd-agent-platform/core/src/registries/tool-capabilities.ts

@@ -34,7 +34,7 @@ const BUILT_IN_TOOL_CAPABILITIES: ToolCapability[] = [
     defaultAvailable: true,
     allowedStages: ['do', 'verify', 'doctor'],
     requiredEvidence: ['sdd-result artifact', 'run event log', 'doctor report'],
-    forbiddenUses: ['delete run evidence', 'auto apply sync-back', 'mark acceptance without validator evidence']
+    forbiddenUses: ['delete run evidence', 'claim truth-alignment approval', 'mark acceptance without validator evidence']
   },
   {
     id: 'browser-ui-check',
@@ -87,9 +87,9 @@ const BUILT_IN_TOOL_CAPABILITIES: ToolCapability[] = [
     summary: 'Read and update local SDD runtime state, semantic docs, artifacts, and generated entries through explicit commands.',
     sideEffect: 'command_execution',
     defaultAvailable: true,
-    allowedStages: ['status', 'do', 'verify', 'sync-back', 'doctor'],
+    allowedStages: ['status', 'do', 'test', 'goal-verify', 'ship', 'doctor'],
     requiredEvidence: ['command output', 'state/event/artifact path when runtime changes'],
-    forbiddenUses: ['unapproved complex sync-back apply', 'automatic commit or push', 'background write orchestration']
+    forbiddenUses: ['unapproved truth-alignment approval', 'automatic commit or push', 'background write orchestration']
   },
   {
     id: 'validation-command',

package/node_modules/@sdd-agent-platform/core/src/registries/tool-plugins.ts

@@ -36,7 +36,7 @@ const BUILT_IN_TOOL_PLUGIN_CONTRACTS: ToolPluginContract[] = [
     loadMode: 'static_manifest',
     checksum: null,
     requiredEvidence: ['sdd-result artifact', 'run event log', 'doctor report'],
-    forbiddenUses: ['dynamic plugin execution', 'delete run evidence', 'auto apply sync-back', 'background write orchestration']
+    forbiddenUses: ['dynamic plugin execution', 'delete run evidence', 'claim truth-alignment approval', 'background write orchestration']
   },
   {
     id: 'browser-ui-check-adapter',
@@ -96,7 +96,7 @@ const BUILT_IN_TOOL_PLUGIN_CONTRACTS: ToolPluginContract[] = [
     loadMode: 'static_manifest',
     checksum: null,
     requiredEvidence: ['command output', 'state/event/artifact path when runtime changes'],
-    forbiddenUses: ['dynamic plugin execution', 'unapproved complex sync-back apply', 'automatic commit or push', 'background write orchestration']
+    forbiddenUses: ['dynamic plugin execution', 'unapproved truth-alignment approval', 'automatic commit or push', 'background write orchestration']
   },
   {
     id: 'validation-command-runner',