sdd-agent-platform 0.4.0 → 0.4.1

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

@@ -40,6 +40,16 @@ interface BuiltInHostAdapterContract {
   responsibilities: string[];
   forbiddenAuthority: string[];
   projections: string[];
+  workflowProjectionPolicy: string;
+  workflowProjections: Array<{
+    host: 'claude_code' | 'codex' | 'opencode';
+    support: 'active' | 'future' | 'unsupported';
+    commandSurface: string[];
+    skillSurface: string[];
+    permissionSurface: string[];
+    evidenceReturn: string[];
+    unsupportedReason: string | null;
+  }>;
 }
 
 interface BuiltInEvidenceIngestionContract {
@@ -83,7 +93,37 @@ export const BUILT_IN_HOST_ADAPTER_CONTRACT: BuiltInHostAdapterContract = {
   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'],
-  projections: ['short profile prompt projection', 'tool permission summary', 'model policy category', 'required evidence targets']
+  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: [
+    {
+      host: 'claude_code',
+      support: 'active',
+      commandSurface: ['slash commands', 'skills', 'settings/hooks/statusline'],
+      skillSurface: ['Agent Skills SKILL.md', 'allowed-tools', 'context and hook metadata'],
+      permissionSurface: ['permission modes', 'tool permission prompts', 'settings scopes'],
+      evidenceReturn: ['host session id', 'tool summary', 'artifact references', 'command output'],
+      unsupportedReason: null
+    },
+    {
+      host: 'codex',
+      support: 'future',
+      commandSurface: ['config.toml profiles', 'AGENTS.md', 'built-in slash surfaces'],
+      skillSurface: ['AGENTS.md instruction surface only until custom command/skill semantics are verified'],
+      permissionSurface: ['approval_policy', 'sandbox_mode'],
+      evidenceReturn: ['telemetry/tool-decision events where available', 'CLI output'],
+      unsupportedReason: 'Custom workflow command/skill projection is not marked active without stronger Codex documentation evidence.'
+    },
+    {
+      host: 'opencode',
+      support: 'active',
+      commandSurface: ['opencode.json/jsonc', '.opencode/commands', 'slash commands'],
+      skillSurface: ['.opencode/agents', '.opencode/skills', 'global/project skill directories'],
+      permissionSurface: ['allow/ask/deny permissions'],
+      evidenceReturn: ['json output', 'session export', 'tool output', 'artifact references'],
+      unsupportedReason: null
+    }
+  ]
 };
 
 export const BUILT_IN_EVIDENCE_INGESTION_CONTRACT: BuiltInEvidenceIngestionContract = {

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',
+  'sync-back apply decision',
+  '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/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 {
@@ -174,12 +174,37 @@ test('Phase 7.6 agent capability catalog routes domains and material packs witho
 
     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);
+    }
+    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(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/workflow-gates.ts

@@ -70,13 +70,13 @@ const BUILT_IN_WORKFLOW_GATES: WorkflowGateContract[] = [
   {
     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 task <task_id> | sdd test batch <batch_id> | sdd test wave',
+    requiredInputs: ['task, batch, or wave 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: ['artifacts/validation-<task>.md', 'workflow gate decision when PASS'],
+    gateConditions: ['acceptance mapped to evidence', 'validation gaps explicit', 'workflow gate policy known'],
     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: 'Proceed to decision card if policy requires one, otherwise ship dry-run after PASS.'
   },
   {
     version: WORKFLOW_GATE_CONTRACT_VERSION,

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

@@ -9,8 +9,10 @@ import type {
   AgentRuntimeAdapterMapping,
   AgentRuntimeRoutingRule,
   CapabilityReuseDecision,
+  CapabilitySourceAllowedEvidenceType,
   CapabilitySourceCatalogEntry,
   CapabilitySourceKind,
+  CapabilitySourceQuarantineStatus,
   ProjectAgentRuntimeConfig,
   SkillCapabilityContract,
   SkillCapabilityEvidenceType,
@@ -80,18 +82,27 @@ function parseAgentRuntimeSkillCapabilities(lines: string[]): SkillCapabilityCon
 }
 
 function parseAgentRuntimeCapabilitySources(lines: string[]): CapabilitySourceCatalogEntry[] {
-  return parseYamlObjectList(lines).map((object) => ({
-    version: CAPABILITY_SOURCE_CATALOG_VERSION,
-    id: object.scalars.id ?? '',
-    name: object.scalars.name ?? object.scalars.id ?? '',
-    kind: capabilitySourceKindField(object.scalars.kind),
-    sourceRef: object.scalars.source_ref ?? '',
-    reuseDecision: reuseDecisionField(object.scalars.reuse_decision),
-    quarantineRequired: booleanValue(object.scalars.quarantine_required, true),
-    allowedUse: object.scalars.allowed_use ?? '',
-    attribution: object.scalars.attribution ?? '',
-    rationale: object.scalars.rationale ?? ''
-  }));
+  return parseYamlObjectList(lines).map((object) => {
+    const quarantineRequired = booleanValue(object.scalars.quarantine_required, true);
+    return {
+      version: CAPABILITY_SOURCE_CATALOG_VERSION,
+      id: object.scalars.id ?? '',
+      name: object.scalars.name ?? object.scalars.id ?? '',
+      kind: capabilitySourceKindField(object.scalars.kind),
+      sourceRef: object.scalars.source_ref ?? '',
+      reuseDecision: reuseDecisionField(object.scalars.reuse_decision),
+      quarantineRequired,
+      quarantineStatus: capabilitySourceQuarantineStatusField(object.scalars.quarantine_status, quarantineRequired ? 'required' : 'not_required'),
+      permissionModel: listField(object, 'permission_model', []),
+      provenanceRequirements: listField(object, 'provenance_requirements', []),
+      hostCompatibility: listField(object, 'host_compatibility', []),
+      allowedEvidenceTypes: listField(object, 'allowed_evidence_types', []).map(capabilitySourceAllowedEvidenceTypeField),
+      forbiddenAuthority: listField(object, 'forbidden_authority', []),
+      allowedUse: object.scalars.allowed_use ?? '',
+      attribution: object.scalars.attribution ?? '',
+      rationale: object.scalars.rationale ?? ''
+    };
+  });
 }
 
 function parseAgentRuntimeAliases(lines: string[]): Record<string, string> {
@@ -268,6 +279,14 @@ function capabilitySourceKindField(value: string | undefined): CapabilitySourceK
   return value === 'native_host' || value === 'mcp_tool' || value === 'open_source_material' || value === 'mechanism_reference' || value === 'future_adapter' || value === 'project_material' ? value : 'project_material';
 }
 
+function capabilitySourceQuarantineStatusField(value: string | undefined, fallback: CapabilitySourceQuarantineStatus): CapabilitySourceQuarantineStatus {
+  return value === 'not_required' || value === 'required' || value === 'quarantined' || value === 'denied' ? value : fallback;
+}
+
+function capabilitySourceAllowedEvidenceTypeField(value: string): CapabilitySourceAllowedEvidenceType {
+  return value === 'none' || value === 'candidate_evidence' || value === 'command_output' || value === 'browser_snapshot' || value === 'design_context' || value === 'execution_record' || value === 'external_reference' ? value : 'candidate_evidence';
+}
+
 function agentRouterCategoryField(value: string | undefined): AgentRouterCategory | null {
   return value === 'planning' || value === 'implementation' || value === 'implementation_review' || value === 'validation' || value === 'security_research' || value === 'external_research' || value === 'blocked' ? value : null;
 }

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

@@ -15,6 +15,7 @@ import type { ArtifactResultIngestionStatus } from '../artifacts/ingestion.js';
 import type { SddResultStatus } from '../artifacts/sdd-result.js';
 import type { RouteCacheMetadata, RuntimeProfileSpan, TeamModeActivation } from './route-cache.js';
 import type { ApprovalPolicy, LifecycleRiskProfile, LifecycleWorkflowGate } from '../risk.js';
+import type { AgentCapabilityAuthority, AgentCapabilityDomain, AgentCapabilityMaterialPack, MaterialPackLoadPolicy } from '../registries/agent-capability-catalog.js';
 
 export type BuiltInAgentProfileId = 'planner' | 'architect' | 'implementer' | 'reviewer' | 'validator' | 'researcher' | 'orchestrator' | 'security' | 'domain_expert';
 export type AgentProfileId = BuiltInAgentProfileId | string;
@@ -22,7 +23,9 @@ export type CapabilityReuseDecision = 'reuse_direct' | 'adapt_via_host_adapter'
 export type SkillCapabilityKind = 'skill' | 'mcp' | 'cli_tool' | 'host_tool' | 'project_agent' | 'external_pattern';
 export type SkillCapabilitySource = 'project' | 'user_global' | 'claude_code' | 'mcp' | 'open_source' | 'host';
 export type SkillCapabilityEvidenceType = 'none' | 'command_output' | 'test_result' | 'browser_snapshot' | 'artifact' | 'external_source' | 'execution_record';
-export type CapabilitySourceKind = 'native_host' | 'mcp_tool' | 'open_source_material' | 'mechanism_reference' | 'future_adapter' | 'project_material';
+export type CapabilitySourceKind = 'native_host' | 'mcp_tool' | 'cli_tool' | 'user_global_material' | 'open_source_material' | 'mechanism_reference' | 'future_adapter' | 'project_material';
+export type CapabilitySourceQuarantineStatus = 'not_required' | 'required' | 'quarantined' | 'denied';
+export type CapabilitySourceAllowedEvidenceType = 'none' | 'candidate_evidence' | 'command_output' | 'browser_snapshot' | 'design_context' | 'execution_record' | 'external_reference';
 export type ExternalPackImportStatus = 'approved' | 'quarantined' | 'denied';
 export type ExternalPackCheckStatus = 'pass' | 'warn' | 'fail' | 'not_run';
 export type ToolPermissionPolicy = 'allow' | 'ask' | 'deny';
@@ -33,6 +36,8 @@ export type TeamModeCostClass = 'none' | 'low' | 'medium' | 'high';
 export type TeamModeCostRoute = 'not_applicable' | 'downgraded' | 'no_downgrade' | 'blocked';
 export type AgentExecutionRecordStatus = 'claimed' | 'completed' | 'failed' | 'blocked' | 'skipped';
 export type TeamSessionRecordStatus = 'created' | 'completed' | 'blocked' | 'disabled';
+export type WorkflowHostAdapterId = 'claude_code' | 'codex' | 'opencode';
+export type WorkflowHostAdapterSupport = 'active' | 'future' | 'unsupported';
 
 export interface AgentProfileContract {
   version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
@@ -70,6 +75,12 @@ export interface CapabilitySourceCatalogEntry {
   sourceRef: string;
   reuseDecision: CapabilityReuseDecision;
   quarantineRequired: boolean;
+  quarantineStatus: CapabilitySourceQuarantineStatus;
+  permissionModel: string[];
+  provenanceRequirements: string[];
+  hostCompatibility: string[];
+  allowedEvidenceTypes: CapabilitySourceAllowedEvidenceType[];
+  forbiddenAuthority: string[];
   allowedUse: string;
   attribution: string;
   rationale: string;
@@ -157,6 +168,16 @@ export interface ToolPermissionSpec {
   hostPermissionProjection: string;
 }
 
+export interface HostWorkflowProjectionContract {
+  host: WorkflowHostAdapterId;
+  support: WorkflowHostAdapterSupport;
+  commandSurface: string[];
+  skillSurface: string[];
+  permissionSurface: string[];
+  evidenceReturn: string[];
+  unsupportedReason: string | null;
+}
+
 export interface HostAdapterContract {
   version: typeof HOST_ADAPTER_CONTRACT_VERSION;
   id: string;
@@ -164,6 +185,8 @@ export interface HostAdapterContract {
   responsibilities: string[];
   forbiddenAuthority: string[];
   projections: string[];
+  workflowProjectionPolicy: string;
+  workflowProjections: HostWorkflowProjectionContract[];
 }
 
 export interface DelegationWavePolicy {
@@ -263,6 +286,47 @@ export interface AgentRouterRejectedProfile {
   reason: string;
 }
 
+export interface AgentCapabilitySelectedDomain {
+  domain: AgentCapabilityDomain;
+  capabilityId: string;
+  authority: AgentCapabilityAuthority;
+  reason: string;
+}
+
+export interface AgentCapabilitySelectedMaterialPack {
+  id: string;
+  domains: AgentCapabilityDomain[];
+  loadPolicy: MaterialPackLoadPolicy;
+  contextBudget: AgentCapabilityMaterialPack['contextBudget'];
+  sourceKind: AgentCapabilityMaterialPack['sourceKind'];
+  expectedOutputs: string[];
+  reason: string;
+}
+
+export interface AgentCapabilityRejectedSource {
+  sourceId: string;
+  quarantineStatus: CapabilitySourceQuarantineStatus;
+  reuseDecision: CapabilityReuseDecision;
+  allowedEvidenceTypes: CapabilitySourceAllowedEvidenceType[];
+  reason: string;
+}
+
+export interface AgentCapabilityConsideredSource extends AgentCapabilityRejectedSource {
+  kind: CapabilitySourceKind;
+  consideredUse: string;
+}
+
+
+export interface AgentCapabilityRouteDecision {
+  authority: 'advisory_only';
+  selectedDomains: AgentCapabilitySelectedDomain[];
+  selectedPacks: AgentCapabilitySelectedMaterialPack[];
+  rejectedExternalSources: AgentCapabilityRejectedSource[];
+  consideredExternalSources: AgentCapabilityConsideredSource[];
+  evidenceRequirements: string[];
+  permissionCeiling: LifecycleAutonomyCeiling;
+}
+
 export interface AgentRouterDecision {
   version: typeof AGENT_ROUTER_CONTRACT_VERSION;
   taskId: string;
@@ -286,6 +350,7 @@ export interface AgentRouterDecision {
   requiredArtifacts: string[];
   blockedReason: string | null;
   nextAction: string;
+  capabilityDecision: AgentCapabilityRouteDecision;
   registrySources?: RuntimeRegistryEntrySource[];
   resolvedAliases?: AgentRuntimeAliasResolution[];
   routingRuleHits?: string[];