sdd-agent-platform 0.3.0 → 0.4.1

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

@@ -0,0 +1,142 @@
+import {
+  AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION,
+  EVIDENCE_INGESTION_CONTRACT_VERSION,
+  HOST_ADAPTER_CONTRACT_VERSION
+} from '../contracts.js';
+
+type LifecycleAutonomyCeiling =
+  | 'direct_execution_allowed'
+  | 'compact_boundary_only'
+  | 'full_sdd_with_checkpoint'
+  | 'research_before_implementation';
+
+type BuiltInAgentProfileId = 'planner' | 'architect' | 'implementer' | 'reviewer' | 'validator' | 'researcher' | 'orchestrator' | 'security' | 'domain_expert';
+type AgentProfileId = BuiltInAgentProfileId | string;
+
+interface BuiltInAgentProfileContract {
+  version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
+  id: AgentProfileId;
+  stageScope: string[];
+  riskCeiling: LifecycleAutonomyCeiling;
+  defaultAutonomy: LifecycleAutonomyCeiling;
+  requiredArtifacts: string[];
+  toolScope: string[];
+  modelPolicyId: string;
+  hostCapabilityRequirements: string[];
+  boundaries: string[];
+}
+
+interface BuiltInModelPolicyContract {
+  id: string;
+  category: string;
+  fallbackPolicy: string;
+  hostProjection: string;
+}
+
+interface BuiltInHostAdapterContract {
+  version: typeof HOST_ADAPTER_CONTRACT_VERSION;
+  id: string;
+  host: string;
+  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 {
+  version: typeof EVIDENCE_INGESTION_CONTRACT_VERSION;
+  sourceOutputs: string[];
+  evidenceTargets: string[];
+  canonicalTruth: string;
+  forbiddenTruthSources: string[];
+}
+
+interface BuiltInDelegationWavePolicy {
+  id: string;
+  waveKind: 'hyperplan' | 'security_research' | 'implementation_review' | 'validation';
+  memberProfiles: AgentProfileId[];
+  requiredArtifacts: string[];
+  fileOwnershipRequired: boolean;
+  mergeGate: string;
+}
+
+export const BUILT_IN_AGENT_PROFILES: BuiltInAgentProfileContract[] = [
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'planner', stageScope: ['spec', 'plan', 'tasks'], riskCeiling: 'research_before_implementation', defaultAutonomy: 'compact_boundary_only', requiredArtifacts: ['plan artifact'], toolScope: ['read', 'search'], modelPolicyId: 'reasoning', hostCapabilityRequirements: ['claude.subagent.researcher'], boundaries: ['does not edit implementation files', 'stops on unresolved scope or risk gaps'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'architect', stageScope: ['plan', 'review'], riskCeiling: 'full_sdd_with_checkpoint', defaultAutonomy: 'compact_boundary_only', requiredArtifacts: ['architecture or plan-risk artifact'], toolScope: ['read', 'search', 'diagram'], modelPolicyId: 'reasoning', hostCapabilityRequirements: ['host.search.grep_glob'], boundaries: ['does not own completion state', 'cannot downgrade lifecycle gates'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'implementer', stageScope: ['do'], riskCeiling: 'compact_boundary_only', defaultAutonomy: 'direct_execution_allowed', requiredArtifacts: ['implementation artifact', 'command evidence when runnable'], toolScope: ['read', 'edit', 'test'], modelPolicyId: 'balanced', hostCapabilityRequirements: ['claude.subagent.implementer', 'host.edit.hashline'], boundaries: ['edits only declared task scope', 'stops on required artifact or checkpoint gaps'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'reviewer', stageScope: ['review', 'verify'], riskCeiling: 'full_sdd_with_checkpoint', defaultAutonomy: 'compact_boundary_only', requiredArtifacts: ['review artifact'], toolScope: ['read', 'diff', 'search'], modelPolicyId: 'reasoning', hostCapabilityRequirements: ['host.search.grep_glob'], boundaries: ['does not replace validation evidence', 'reports gaps instead of marking completion'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'validator', stageScope: ['verify'], riskCeiling: 'full_sdd_with_checkpoint', defaultAutonomy: 'compact_boundary_only', requiredArtifacts: ['validation artifact'], toolScope: ['read', 'test', 'browser'], modelPolicyId: 'balanced', hostCapabilityRequirements: ['host.cli.shell'], boundaries: ['maps acceptance to evidence', 'does not treat command success as canonical completion'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'researcher', stageScope: ['spec', 'plan', 'tasks', 'review'], riskCeiling: 'research_before_implementation', defaultAutonomy: 'research_before_implementation', requiredArtifacts: ['research summary or source attribution'], toolScope: ['read', 'search', 'docs'], modelPolicyId: 'reasoning', hostCapabilityRequirements: ['claude.subagent.researcher', 'context7.docs'], boundaries: ['read-only by default', 'external sources require attribution'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'orchestrator', stageScope: ['spec', 'plan', 'tasks', 'do', 'review', 'verify'], riskCeiling: 'full_sdd_with_checkpoint', defaultAutonomy: 'compact_boundary_only', requiredArtifacts: ['router decision', 'execution record'], toolScope: ['route', 'delegate', 'record'], modelPolicyId: 'reasoning', hostCapabilityRequirements: ['claude_code.host_adapter'], boundaries: ['coordinates but does not bypass risk gates', 'host sessions are provenance not truth'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'security', stageScope: ['plan', 'review', 'verify'], riskCeiling: 'research_before_implementation', defaultAutonomy: 'research_before_implementation', requiredArtifacts: ['security findings artifact'], toolScope: ['read', 'search', 'non_destructive_poc'], modelPolicyId: 'security_review', hostCapabilityRequirements: ['pattern.ohmy.security_research'], boundaries: ['authorized defensive scope only', 'no destructive exploitation or evasion'] },
+  { version: AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION, id: 'domain_expert', stageScope: ['spec', 'plan', 'review'], riskCeiling: 'research_before_implementation', defaultAutonomy: 'research_before_implementation', requiredArtifacts: ['domain evidence or mapping artifact'], toolScope: ['read', 'docs', 'source_material'], modelPolicyId: 'reasoning', hostCapabilityRequirements: ['external.agency_agents.material'], boundaries: ['external prompt packs stay quarantined until scanned', 'uses metadata extraction not bulk prompt import'] }
+];
+
+export const BUILT_IN_MODEL_POLICIES: BuiltInModelPolicyContract[] = [
+  { id: 'balanced', category: 'default', fallbackPolicy: 'use host default fallback', hostProjection: 'Project the SDD profile and risk ceiling; host selects configured model.' },
+  { id: 'reasoning', category: 'planning_review', fallbackPolicy: 'prefer stronger reasoning model, fall back to host default', hostProjection: 'Use for planning, architecture, review, routing and synthesis tasks.' },
+  { id: 'security_review', category: 'security', fallbackPolicy: 'prefer security-capable review model, block if host policy forbids security research', hostProjection: 'Authorized defensive security review only; non-destructive evidence required.' }
+];
+
+export const BUILT_IN_HOST_ADAPTER_CONTRACT: BuiltInHostAdapterContract = {
+  version: HOST_ADAPTER_CONTRACT_VERSION,
+  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'],
+  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 = {
+  version: EVIDENCE_INGESTION_CONTRACT_VERSION,
+  sourceOutputs: ['subagent summary', 'command output', 'browser snapshot', 'MCP result', 'team message', 'blocked host execution'],
+  evidenceTargets: ['sdd-result-v1', 'AgentExecutionRecord', 'TeamSessionRecord', 'TeamMessageRecord', 'implementation artifact', 'review artifact', 'validation artifact', 'security findings artifact'],
+  canonicalTruth: 'SDD artifacts, run state/events, verify and doctor decide completion state.',
+  forbiddenTruthSources: ['host session status alone', 'tmux pane state', 'external prompt summary alone', 'MCP output without SDD evidence mapping']
+};
+
+export const BUILT_IN_DELEGATION_WAVES: BuiltInDelegationWavePolicy[] = [
+  { id: 'hyperplan', waveKind: 'hyperplan', memberProfiles: ['architect', 'reviewer', 'security', 'validator', 'researcher'], requiredArtifacts: ['plan-risk artifact'], fileOwnershipRequired: false, mergeGate: 'implementation blocks while hard plan gaps remain' },
+  { id: 'security_research', waveKind: 'security_research', memberProfiles: ['security', 'security', 'researcher', 'reviewer', 'validator'], requiredArtifacts: ['security findings artifact', 'remediation recommendation'], fileOwnershipRequired: false, mergeGate: 'authorized non-destructive findings are severity-calibrated before implementation' },
+  { id: 'implementation_review', waveKind: 'implementation_review', memberProfiles: ['reviewer', 'architect', 'security'], requiredArtifacts: ['review artifact'], fileOwnershipRequired: true, mergeGate: 'file ownership conflicts and review gaps block merge' },
+  { id: 'validation', waveKind: 'validation', memberProfiles: ['validator', 'reviewer'], requiredArtifacts: ['validation artifact'], fileOwnershipRequired: false, mergeGate: 'acceptance evidence is required before verify PASS' }
+];

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

@@ -0,0 +1,253 @@
+import { CAPABILITY_SOURCE_CATALOG_VERSION } from '../contracts.js';
+import type {
+  CapabilitySourceAllowedEvidenceType,
+  CapabilitySourceCatalogEntry,
+  CapabilitySourceKind,
+  CapabilitySourceQuarantineStatus,
+  CapabilityReuseDecision
+} from '../router/agent-runtime.js';
+
+const FORBIDDEN_RUNTIME_AUTHORITY = [
+  'lifecycle gate authority',
+  'stage completion decision',
+  'sync-back apply decision',
+  'ship readiness pass',
+  'permission escalation'
+];
+
+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;
+}
+
+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.'
+  })
+];