sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -1,30 +1,253 @@
 import { CAPABILITY_SOURCE_CATALOG_VERSION } from '../contracts.js';
+import type {
+  CapabilitySourceAllowedEvidenceType,
+  CapabilitySourceCatalogEntry,
+  CapabilitySourceKind,
+  CapabilitySourceQuarantineStatus,
+  CapabilityReuseDecision
+} from '../router/agent-runtime.js';
 
-type CapabilityReuseDecision = 'reuse_direct' | 'adapt_via_host_adapter' | 'borrow_mechanism' | 'avoid';
-type CapabilitySourceKind = 'native_host' | 'mcp_tool' | 'open_source_material' | 'mechanism_reference' | 'future_adapter' | 'project_material';
+const FORBIDDEN_RUNTIME_AUTHORITY = [
+  'lifecycle gate authority',
+  'stage completion decision',
+  'truth-alignment approval',
+  'ship readiness pass',
+  'permission escalation'
+];
 
-interface BuiltInCapabilitySourceCatalogEntry {
-  version: typeof CAPABILITY_SOURCE_CATALOG_VERSION;
+interface CapabilitySourceInput {
   id: string;
   name: string;
   kind: CapabilitySourceKind;
   sourceRef: string;
   reuseDecision: CapabilityReuseDecision;
   quarantineRequired: boolean;
+  quarantineStatus: CapabilitySourceQuarantineStatus;
+  permissionModel: string[];
+  provenanceRequirements: string[];
+  hostCompatibility: string[];
+  allowedEvidenceTypes: CapabilitySourceAllowedEvidenceType[];
+  forbiddenAuthority?: string[];
   allowedUse: string;
   attribution: string;
   rationale: string;
 }
 
-export const BUILT_IN_CAPABILITY_SOURCES: BuiltInCapabilitySourceCatalogEntry[] = [
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'claude_code_native', name: 'Claude Code native capabilities', kind: 'native_host', sourceRef: 'Claude Code subagents/skills/MCP/hooks/settings/background tasks', reuseDecision: 'reuse_direct', quarantineRequired: false, allowedUse: 'host-native execution and provenance capture', attribution: 'Claude Code host runtime', rationale: 'Reuse execution mechanics instead of rebuilding agent/skill/MCP runtime.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'context7_mcp', name: 'Context7 MCP', kind: 'mcp_tool', sourceRef: 'Context7 documentation MCP', reuseDecision: 'reuse_direct', quarantineRequired: false, allowedUse: 'current library/API documentation lookup with source evidence', attribution: 'Context7 MCP', rationale: 'Mature docs lookup should be declared as capability, not rebuilt.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'playwright_mcp', name: 'Playwright browser capability', kind: 'mcp_tool', sourceRef: 'Playwright MCP/CLI', reuseDecision: 'reuse_direct', quarantineRequired: false, allowedUse: 'browser/UI validation evidence', attribution: 'Playwright', rationale: 'Browser verification should be ingested as evidence rather than replaced by prompts.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'opencode_patterns', name: 'OpenCode mechanism patterns', kind: 'mechanism_reference', sourceRef: 'OpenCode / Oh My OpenCode', reuseDecision: 'borrow_mechanism', quarantineRequired: false, allowedUse: 'adapter, model policy, permission and session discipline references', attribution: 'OpenCode ecosystem', rationale: 'Borrow host-neutral mechanisms without coupling SDD core to OpenCode APIs.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'ohmy_team_mode', name: 'Oh My team-mode pattern', kind: 'mechanism_reference', sourceRef: 'Oh My OpenCode team-mode', reuseDecision: 'borrow_mechanism', quarantineRequired: false, allowedUse: 'adaptive chief/member/team-message/delegation-wave contract shape', attribution: 'Oh My OpenCode', rationale: 'Team runtime remains host capability; SDD records policy and evidence.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'roo_cline_permissions', name: 'Roo/Cline tool permission envelope', kind: 'mechanism_reference', sourceRef: 'Roo Code / Cline modes and approvals', reuseDecision: 'borrow_mechanism', quarantineRequired: false, allowedUse: 'tool group, approval and runtime validation policy reference', attribution: 'Roo Code / Cline', rationale: 'Permission semantics should be structured, not natural-language prompt rules.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'cc_sdd_completion_gate', name: 'cc-sdd dispatch and completion gates', kind: 'mechanism_reference', sourceRef: 'cc-sdd', reuseDecision: 'borrow_mechanism', quarantineRequired: false, allowedUse: 'bounded delegation and completion gate reference', attribution: 'cc-sdd', rationale: 'Useful dispatch pattern, but SDD task graph and evidence remain authoritative.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'agency_agents_material', name: 'Agency agents material library', kind: 'open_source_material', sourceRef: 'msitarzewski/agency-agents', reuseDecision: 'adapt_via_host_adapter', quarantineRequired: true, allowedUse: 'domain taxonomy, guardrail and deliverable metadata after quarantine', attribution: 'agency-agents', rationale: 'Large prompt packs are material sources only and must be mapped before routing use.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'wshobson_manifest', name: 'wshobson/BuildWithClaude manifest patterns', kind: 'mechanism_reference', sourceRef: 'wshobson agents / BuildWithClaude', reuseDecision: 'borrow_mechanism', quarantineRequired: true, allowedUse: 'marketplace manifest and file ownership reference after inspection', attribution: 'wshobson / BuildWithClaude', rationale: 'Borrow manifest/file ownership mechanics without copying agents.' },
-  { version: CAPABILITY_SOURCE_CATALOG_VERSION, id: 'crewai_autogen_langgraph', name: 'CrewAI/AutoGen/LangGraph workflow frameworks', kind: 'future_adapter', sourceRef: 'CrewAI / AutoGen / LangGraph', reuseDecision: 'avoid', quarantineRequired: false, allowedUse: 'future optional adapter only after Phase 6 contracts stabilize', attribution: 'CrewAI / AutoGen / LangGraph', rationale: 'Avoid adding a workflow OS or scheduler to Phase 6 core.' }
+function source(input: CapabilitySourceInput): CapabilitySourceCatalogEntry {
+  return {
+    version: CAPABILITY_SOURCE_CATALOG_VERSION,
+    forbiddenAuthority: input.forbiddenAuthority ?? FORBIDDEN_RUNTIME_AUTHORITY,
+    ...input
+  };
+}
+
+export const BUILT_IN_CAPABILITY_SOURCES: CapabilitySourceCatalogEntry[] = [
+  source({
+    id: 'claude_code_native',
+    name: 'Claude Code native capabilities',
+    kind: 'native_host',
+    sourceRef: 'Claude Code subagents/skills/MCP/hooks/settings/background tasks',
+    reuseDecision: 'reuse_direct',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['host allow/ask/deny permissions', 'skill allowed-tools preapproval', 'subagent tool isolation', 'MCP server trust boundary'],
+    provenanceRequirements: ['managed entry path or host surface', 'host session/task id when delegated', 'tool summary or artifact reference'],
+    hostCompatibility: ['claude-code:supported'],
+    allowedEvidenceTypes: ['execution_record', 'command_output', 'external_reference'],
+    allowedUse: 'host-native execution, permission projection, and provenance capture',
+    attribution: 'Claude Code host runtime',
+    rationale: 'Reuse execution mechanics while SDD retains lifecycle, evidence, and completion authority.'
+  }),
+  source({
+    id: 'context7_mcp',
+    name: 'Context7 MCP',
+    kind: 'mcp_tool',
+    sourceRef: 'Context7 documentation MCP',
+    reuseDecision: 'reuse_direct',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['MCP tool call with host approval policy', 'read-only external documentation lookup'],
+    provenanceRequirements: ['MCP server id', 'library id or source URL', 'retrieval timestamp or command evidence'],
+    hostCompatibility: ['mcp:supported', 'claude-code:supported'],
+    allowedEvidenceTypes: ['external_reference'],
+    allowedUse: 'current library/API documentation lookup with source evidence',
+    attribution: 'Context7 MCP',
+    rationale: 'Mature docs lookup should be declared as capability, not rebuilt.'
+  }),
+  source({
+    id: 'playwright_mcp',
+    name: 'Playwright browser capability',
+    kind: 'mcp_tool',
+    sourceRef: 'Playwright MCP/CLI',
+    reuseDecision: 'reuse_direct',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['browser automation with host approval policy', 'project-scoped local/browser access'],
+    provenanceRequirements: ['browser snapshot or trace path', 'command output', 'target URL or local route'],
+    hostCompatibility: ['mcp:supported', 'cli:supported', 'claude-code:supported'],
+    allowedEvidenceTypes: ['browser_snapshot', 'command_output'],
+    allowedUse: 'browser/UI validation evidence mapped into SDD artifacts',
+    attribution: 'Playwright',
+    rationale: 'Browser verification should be ingested as evidence rather than replaced by prompts.'
+  }),
+  source({
+    id: 'codex_host_future',
+    name: 'Codex host adapter placeholder',
+    kind: 'future_adapter',
+    sourceRef: 'Codex CLI/agent host behavior requires project validation before routing',
+    reuseDecision: 'avoid',
+    quarantineRequired: true,
+    quarantineStatus: 'denied',
+    permissionModel: ['unsupported until Codex sandbox, approval, and MCP behavior are verified'],
+    provenanceRequirements: ['future host session id', 'future approval/sandbox record', 'future artifact mapping'],
+    hostCompatibility: ['codex:unsupported'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'unsupported future host adapter research only',
+    attribution: 'Codex public docs and issue review',
+    rationale: 'Current evidence is insufficient for stable active adapter fields; keep Codex out of routing until verified.'
+  }),
+  source({
+    id: 'opencode_patterns',
+    name: 'OpenCode mechanism patterns',
+    kind: 'mechanism_reference',
+    sourceRef: 'OpenCode / Oh My OpenCode',
+    reuseDecision: 'borrow_mechanism',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['permission-shape reference only', 'allow/ask/deny normalized by SDD before use'],
+    provenanceRequirements: ['referenced OpenCode docs or source path', 'SDD adapter mapping decision'],
+    hostCompatibility: ['opencode:future_adapter'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'adapter, model policy, permission and session discipline references',
+    attribution: 'OpenCode ecosystem',
+    rationale: 'Borrow host-neutral mechanisms without coupling SDD core to OpenCode APIs.'
+  }),
+  source({
+    id: 'ohmy_team_mode',
+    name: 'Oh My team-mode pattern',
+    kind: 'mechanism_reference',
+    sourceRef: 'Oh My OpenCode team-mode',
+    reuseDecision: 'borrow_mechanism',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['mechanism reference only', 'SDD-owned delegation waves and artifact requirements'],
+    provenanceRequirements: ['referenced source material', 'SDD team-mode policy id'],
+    hostCompatibility: ['opencode:future_adapter', 'host-neutral:supported'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'adaptive chief/member/team-message/delegation-wave contract shape',
+    attribution: 'Oh My OpenCode',
+    rationale: 'Team runtime remains host capability; SDD records policy and evidence.'
+  }),
+  source({
+    id: 'figma_design_future',
+    name: 'Figma design tooling placeholder',
+    kind: 'future_adapter',
+    sourceRef: 'Figma Dev Mode/MCP design context tooling',
+    reuseDecision: 'adapt_via_host_adapter',
+    quarantineRequired: true,
+    quarantineStatus: 'required',
+    permissionModel: ['read-only design context by default', 'write/generation actions unsupported', 'account/seat/tool limits must be checked'],
+    provenanceRequirements: ['Figma file or node reference', 'tool/server id', 'timestamped design context artifact'],
+    hostCompatibility: ['figma:future_adapter', 'mcp:future_adapter'],
+    allowedEvidenceTypes: ['design_context', 'external_reference'],
+    allowedUse: 'design context, tokens, variables, screenshots, and Code Connect mapping as candidate evidence',
+    attribution: 'Figma Dev Mode/MCP documentation',
+    rationale: 'Design tooling may inform UI/UX work, but write actions and readiness authority stay unsupported until adapter validation.'
+  }),
+  source({
+    id: 'ui_ux_pro_max_external',
+    name: 'ui-ux-pro-max external skill material',
+    kind: 'open_source_material',
+    sourceRef: 'ui-ux-pro-max external skill or user-global material',
+    reuseDecision: 'adapt_via_host_adapter',
+    quarantineRequired: true,
+    quarantineStatus: 'quarantined',
+    permissionModel: ['external skill material requires source review', 'no direct prompt import', 'no design-tool write authority'],
+    provenanceRequirements: ['material source path or registry id', 'license/source attribution', 'quarantine scan result'],
+    hostCompatibility: ['claude-code:future_adapter', 'host-neutral:future_adapter'],
+    allowedEvidenceTypes: ['candidate_evidence', 'design_context'],
+    allowedUse: 'UI/UX critique, heuristic review, and design deliverable metadata after quarantine',
+    attribution: 'ui-ux-pro-max external material',
+    rationale: 'Named external UI/UX skills are useful sources, but must be routed as mapped material rather than copied into baseline packs.'
+  }),
+  source({
+    id: 'roo_cline_permissions',
+    name: 'Roo/Cline tool permission envelope',
+    kind: 'mechanism_reference',
+    sourceRef: 'Roo Code / Cline modes and approvals',
+    reuseDecision: 'borrow_mechanism',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['tool group and approval-policy reference only', 'SDD normalizes permissions before host projection'],
+    provenanceRequirements: ['referenced permission docs or source path', 'SDD permission policy id'],
+    hostCompatibility: ['host-neutral:supported'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'tool group, approval and runtime validation policy reference',
+    attribution: 'Roo Code / Cline',
+    rationale: 'Permission semantics should be structured, not natural-language prompt rules.'
+  }),
+  source({
+    id: 'cc_sdd_completion_gate',
+    name: 'cc-sdd dispatch and completion gates',
+    kind: 'mechanism_reference',
+    sourceRef: 'cc-sdd',
+    reuseDecision: 'borrow_mechanism',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['mechanism reference only', 'SDD task graph remains authoritative'],
+    provenanceRequirements: ['referenced dispatch/completion source', 'SDD evidence mapping decision'],
+    hostCompatibility: ['host-neutral:supported'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'bounded delegation and completion gate reference',
+    attribution: 'cc-sdd',
+    rationale: 'Useful dispatch pattern, but SDD task graph and evidence remain authoritative.'
+  }),
+  source({
+    id: 'agency_agents_material',
+    name: 'Agency agents material library',
+    kind: 'open_source_material',
+    sourceRef: 'msitarzewski/agency-agents',
+    reuseDecision: 'adapt_via_host_adapter',
+    quarantineRequired: true,
+    quarantineStatus: 'quarantined',
+    permissionModel: ['external prompt pack quarantine', 'metadata extraction only before approval', 'no direct execution'],
+    provenanceRequirements: ['source repository/ref', 'license/source attribution', 'secret/dangerous-command scan result'],
+    hostCompatibility: ['host-neutral:future_adapter'],
+    allowedEvidenceTypes: ['candidate_evidence', 'external_reference'],
+    allowedUse: 'domain taxonomy, guardrail and deliverable metadata after quarantine',
+    attribution: 'agency-agents',
+    rationale: 'Large prompt packs are material sources only and must be mapped before routing use.'
+  }),
+  source({
+    id: 'wshobson_manifest',
+    name: 'wshobson/BuildWithClaude manifest patterns',
+    kind: 'mechanism_reference',
+    sourceRef: 'wshobson agents / BuildWithClaude',
+    reuseDecision: 'borrow_mechanism',
+    quarantineRequired: true,
+    quarantineStatus: 'required',
+    permissionModel: ['manifest mechanism reference after inspection', 'no copied agent body before quarantine'],
+    provenanceRequirements: ['source repository/ref', 'manifest ownership mapping', 'license/source attribution'],
+    hostCompatibility: ['claude-code:future_adapter', 'host-neutral:future_adapter'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'marketplace manifest and file ownership reference after inspection',
+    attribution: 'wshobson / BuildWithClaude',
+    rationale: 'Borrow manifest/file ownership mechanics without copying agents.'
+  }),
+  source({
+    id: 'crewai_autogen_langgraph',
+    name: 'CrewAI/AutoGen/LangGraph workflow frameworks',
+    kind: 'future_adapter',
+    sourceRef: 'CrewAI / AutoGen / LangGraph',
+    reuseDecision: 'avoid',
+    quarantineRequired: false,
+    quarantineStatus: 'not_required',
+    permissionModel: ['unsupported workflow-framework adapter'],
+    provenanceRequirements: ['future adapter analysis before any runtime use'],
+    hostCompatibility: ['workflow-framework:unsupported'],
+    allowedEvidenceTypes: ['none'],
+    allowedUse: 'future optional adapter only after Phase 6 contracts stabilize',
+    attribution: 'CrewAI / AutoGen / LangGraph',
+    rationale: 'Avoid adding a workflow OS or scheduler to Phase 6 core.'
+  })
 ];

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

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { initProject } from '../config/init-project.js';
 import { doctor } from '../doctor/doctor.js';
 import { inspectAgentRegistryEntry, listAgentRegistry } from './agent-registry.js';
-import { inspectAgentCapabilityCatalog, validateAgentCapabilityCatalog } from './agent-capability-catalog.js';
+import { inspectAgentCapabilityCatalog, REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS, validateAgentCapabilityCatalog } from './agent-capability-catalog.js';
 import { decideCommandTeamRuntime, inspectCommandTeamRuntime, validateCommandTeamRuntime } from './command-team-runtime.js';
 import { buildContextBuildPackage } from '../context/build-package.js';
 import {
@@ -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,14 +174,53 @@ 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, 8);
+    assert.equal(catalog.capabilities.length, 19);
+    assert.equal(catalog.materialPacks.length, 16);
+    assert.equal(catalog.capabilities.filter((capability) => capability.domainGroup === 'professional').length, REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS.length);
     assert.equal(catalog.materialPacks.every((pack) => pack.contextBudget !== 'medium'), true);
+    assert.equal(catalog.materialPacks.every((pack) => pack.expectedOutputs.length > 0 && pack.forbiddenUses.length > 0), true);
     assert.equal(specMapping?.requiredDomains.includes('norm_discovery'), true);
     assert.equal(specMapping?.requiredDomains.includes('uncertainty_resolution'), true);
     assert.equal(verifiesMapping?.requiredDomains.includes('verification_design'), true);
     assert.equal(contextCapability?.routing.materialPackIds.includes('performance-risk'), true);
+    const backendCapability = catalog.capabilities.find((capability) => capability.domain === 'backend-engineering');
+    const frontendCapability = catalog.capabilities.find((capability) => capability.domain === 'frontend-engineering');
+    const databaseCapability = catalog.capabilities.find((capability) => capability.domain === 'db-data-engineering');
+    const evidenceCapability = catalog.capabilities.find((capability) => capability.id === 'cap.evidence-collection');
+
+    for (const domain of REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS) {
+      const capability = catalog.capabilities.find((entry) => entry.domain === domain);
+      const pack = catalog.materialPacks.find((entry) => entry.sourceKind === 'sdd_native_baseline' && entry.domains.includes(domain));
+      assert.equal(capability?.domainGroup, 'professional');
+      assert.equal(capability?.authority, 'advisory_only');
+      assert.equal(capability?.routing.materialPackIds.includes(pack?.id ?? ''), true);
+      assert.equal(pack?.sourceId, 'sdd_professional_baseline');
+      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);
+    assert.equal(evidenceCapability?.materialPolicy, 'runtime_evidence_required');
+    assert.equal(evidenceCapability?.evidenceExpectation, 'accepted_runtime_evidence');
     assert.equal(catalog.commandMappings.some((mapping) => mapping.materialPolicy === 'never_inline'), false);
   } finally {
     await rm(root, { recursive: true, force: 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',

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

@@ -62,15 +62,15 @@ const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
       stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
     },
     output: {
-      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      artifactReference: '.sdd/runs/<branch>/<stage>/<agent>-<task_id>.md',
       terminalStatus: ['COMPLETED', 'FAILED', 'TIMED_OUT', 'CANCELLED'],
       exitStatuses: ['completed', 'failed', 'timed_out', 'cancelled', 'blocked'],
       requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_timeout', 'delegation_cancelled']
     },
     sideEffect: 'command_execution',
-    permissionPrompt: 'Run a Claude Code/subagent task for one queued delegation and persist only declared run events/artifact references.',
-    requiredEvidence: ['queue item id', 'delegation state transition event', 'sdd-result artifact reference'],
-    forbiddenUses: ['bypass Claude Code permission prompts', 'execute undeclared wave scheduling', 'write outside .sdd/runs or declared artifacts', 'reopen terminal delegation ids']
+    permissionPrompt: 'Run a Claude Code/subagent task for one queued delegation and persist only declared run events/stage evidence references.',
+    requiredEvidence: ['queue item id', 'delegation state transition event', 'stage evidence reference'],
+    forbiddenUses: ['bypass Claude Code permission prompts', 'execute undeclared wave scheduling', 'write outside declared .sdd/runs/<branch>/<stage> evidence or approved task scope', 'reopen terminal delegation ids']
   },
   {
     id: 'manual-handoff-worker',
@@ -87,15 +87,15 @@ const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
       stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
     },
     output: {
-      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      artifactReference: '.sdd/runs/<branch>/<stage>/<agent>-<task_id>.md',
       terminalStatus: ['COMPLETED', 'FAILED', 'CANCELLED'],
       exitStatuses: ['completed', 'failed', 'cancelled', 'blocked'],
       requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_cancelled']
     },
     sideEffect: 'read_only',
     permissionPrompt: 'Prepare a manual delegation handoff without starting a background process.',
-    requiredEvidence: ['queue item id', 'manual handoff instructions', 'expected artifact reference'],
-    forbiddenUses: ['start background worker', 'claim queue item', 'mark delegation completed without artifact evidence']
+    requiredEvidence: ['queue item id', 'manual handoff instructions', 'expected stage evidence reference'],
+    forbiddenUses: ['start background worker', 'claim queue item', 'mark delegation completed without stage evidence']
   },
   {
     id: 'sdd-cli-task-worker',
@@ -112,15 +112,15 @@ const BUILT_IN_WORKER_ADAPTER_CONTRACTS: WorkerAdapterContract[] = [
       stateMachineVersion: DELEGATION_STATE_MACHINE_VERSION
     },
     output: {
-      artifactReference: 'artifacts/<agent>-<task_id>.md',
+      artifactReference: '.sdd/runs/<branch>/<stage>/<agent>-<task_id>.md',
       terminalStatus: ['COMPLETED', 'FAILED', 'TIMED_OUT', 'CANCELLED'],
       exitStatuses: ['completed', 'failed', 'timed_out', 'cancelled', 'blocked'],
       requiredEvents: ['delegation_started', 'delegation_completed', 'delegation_failed', 'delegation_timeout', 'delegation_cancelled']
     },
     sideEffect: 'local_write',
-    permissionPrompt: 'Run a bounded SDD CLI task adapter and write only declared artifact/run evidence.',
-    requiredEvidence: ['queue item id', 'command output', 'sdd-result artifact reference'],
-    forbiddenUses: ['unapproved complex sync-back apply', 'dynamic plugin execution', 'background wave execution', 'write undeclared artifacts']
+    permissionPrompt: 'Run a bounded SDD CLI task adapter and write only declared stage evidence/runtime metadata.',
+    requiredEvidence: ['queue item id', 'command output', 'sdd-result stage evidence reference'],
+    forbiddenUses: ['unapproved truth-alignment approval', 'dynamic plugin execution', 'background wave execution', 'write undeclared stage evidence']
   }
 ];
 

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

@@ -51,10 +51,10 @@ const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
     command: 'sdd instructions tasks --json',
     requiredInputs: ['approved spec', 'approved plan', 'task boundary candidates'],
     allowedAgents: ['planner', 'reviewer'],
-    requiredArtifacts: ['specs/<branch>/tasks.md'],
-    gateConditions: ['each task has boundary', 'affected files declared when knowable', 'validation declared'],
+    requiredArtifacts: ['specs/<branch>/tasks.md', '.sdd/runs/<branch>/tasks/*.md', 'specs/<branch>/verify.md', '.sdd/runs/<branch>/verifies/*.md'],
+    gateConditions: ['each task has boundary', 'affected files declared when knowable', 'validation declared', 'verifies closes only after tasks handoff'],
     gapClosureBehavior: 'Run sdd tasks gaps and fix blocking task metadata before implementation.',
-    nextAction: 'Create executable sdd-task blocks, then run sdd tasks gaps --branch <branch>.'
+    nextAction: 'Close tasks, then close verifies through the /sdd:tasks bundle when runtime handoff targets verifies.'
   },
   {
     version: WORKFLOW_GATE_CONTRACT_VERSION,
@@ -62,21 +62,21 @@ const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
     command: 'sdd do task <task_id>',
     requiredInputs: ['selected task', 'boundary', 'acceptance', 'declared validation'],
     allowedAgents: ['scout', 'implementer', 'reviewer', 'debugger', 'validator'],
-    requiredArtifacts: ['artifacts/implement-<task>.md', 'artifacts/review-<task>.md', 'artifacts/validation-<task>.md'],
-    gateConditions: ['single selected task', 'no blocking task gaps', 'artifact template available'],
-    gapClosureBehavior: 'Block on missing boundary, missing validation, invalid artifact, or expanded scope.',
-    nextAction: 'Run inside the selected task boundary and record sdd-result artifacts before test.'
+    requiredArtifacts: ['.sdd/runs/<branch>/do/implementation-vN.md', '.sdd/runs/<branch>/do/code-review-vN.md', '.sdd/runs/<branch>/do/do-manager-vN.md'],
+    gateConditions: ['single selected task', 'no blocking task gaps', 'reviewed implementation evidence', 'manager closure request'],
+    gapClosureBehavior: 'Block on missing boundary, missing validation, invalid stage evidence, or expanded scope.',
+    nextAction: 'Run inside the selected task boundary and record .sdd/runs/<branch>/do/*.md evidence before test.'
   },
   {
     version: WORKFLOW_GATE_CONTRACT_VERSION,
     id: 'test',
-    command: 'sdd test task <task_id> [--branch <branch>] [--run <run_id>]',
-    requiredInputs: ['task id', 'validation command ledger', 'validation evidence'],
+    command: 'sdd test <validation_unit_id-or-validation_text>',
+    requiredInputs: ['verify.md validation unit boundary', 'validation command ledger', 'validation evidence'],
     allowedAgents: ['validator', 'reviewer'],
-    requiredArtifacts: ['artifacts/validation-<task>.md', 'sync-back proposal when PASS'],
-    gateConditions: ['acceptance mapped to evidence', 'validation gaps explicit', 'sync-back policy known'],
+    requiredArtifacts: ['.sdd/runs/<branch>/test/*.md', '.sdd/runs/<branch>/goal-verify/*.md', 'truthAlignment projection when goal-verify closes'],
+    gateConditions: ['acceptance mapped to evidence', 'validation gaps explicit', 'workflow gate policy known', 'goal-verify closes before ship'],
     gapClosureBehavior: 'Return PASS, FAIL, or BLOCKED when command execution or acceptance evidence is incomplete.',
-    nextAction: 'Inspect sync-back proposal after PASS and follow apply_policy.'
+    nextAction: 'Close test evidence, then close goal-verify before ship readiness.'
   },
   {
     version: WORKFLOW_GATE_CONTRACT_VERSION,