sdd-agent-platform 0.4.1 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/router/route-sdd-task.test.ts

@@ -1,429 +1,429 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { initProject } from '../config/init-project.js';
-import {
-  adaptiveTeamTaskMarkdown,
-  appendProjectRuntimeConfig,
-  phase63FrontendTaskMarkdown,
-  phase63InvalidProjectRuntimeConfig,
-  phase63ProjectRuntimeConfig,
-  validTaskMarkdown,
-  writeBranchDocs
-} from '../test-support/fixtures.js';
-import { writeVerifyContract } from '../verification/verify-contract.js';
-import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
-import { bindTestRunState } from '../test-support/run-state.js';
-import {
-  inspectAgentSkillTeamRuntime,
-  inspectCapabilitySource,
-  inspectExternalAgentPackImport,
-  inspectSkillCapability,
-  inspectTeamModePolicy,
-  listCapabilitySources,
-  listSkillCapabilities,
-  routeSddTask,
-  validateAgentSkillTeamRuntime
-} from './route-sdd-task.js';
-
-test('Phase 6 agent skill team runtime exposes reusable contracts and router decisions', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase60-runtime-'));
-  try {
-    await initProject(root);
-
-    const runtime = await inspectAgentSkillTeamRuntime(root);
-    const validation = await validateAgentSkillTeamRuntime(root);
-    const skillCapabilities = await listSkillCapabilities(root);
-    const hashlineCapability = await inspectSkillCapability(root, 'host.edit.hashline');
-    const sourceCatalog = await listCapabilitySources(root);
-    const agencySource = await inspectCapabilitySource(root, 'agency_agents_material');
-    const agencyImport = await inspectExternalAgentPackImport(root, 'agency_agents_material');
-    const codexSource = await inspectCapabilitySource(root, 'codex_host_future');
-    const codexImport = await inspectExternalAgentPackImport(root, 'codex_host_future');
-    const figmaSource = await inspectCapabilitySource(root, 'figma_design_future');
-    const teamDefault = await inspectTeamModePolicy(root);
-    const teamEnabled = await inspectTeamModePolicy(root, { taskId: 'ONBOARDING-1', branch: 'master', enabled: true });
-    const route = await routeSddTask(root, { taskId: 'ONBOARDING-1', branch: 'master', teamModeEnabled: true });
-
-    assert.equal(runtime.version, 'phase-6.0-agent-skill-team-runtime-v1');
-    assert.equal(runtime.teamMode.decision, 'disabled');
-    assert.equal(runtime.hostAdapter.workflowProjectionPolicy.includes('host-neutral canonical CLI commands'), true);
-    assert.deepEqual(runtime.hostAdapter.workflowProjections.map((projection) => `${projection.host}:${projection.support}`), ['claude_code:active', 'codex:future', 'opencode:active']);
-    assert.equal(runtime.hostAdapter.workflowProjections.find((projection) => projection.host === 'codex')?.unsupportedReason?.includes('not marked active'), true);
-    assert.equal(runtime.profiles.some((profile) => profile.id === 'orchestrator'), true);
-    assert.equal(runtime.profiles.some((profile) => profile.id === 'security'), true);
-    assert.equal(runtime.skillCapabilities.some((capability) => capability.id === 'claude.subagent.researcher'), true);
-    assert.equal(validation.valid, true);
-    assert.equal(skillCapabilities.capabilities.some((capability) => capability.id === 'external.agency_agents.material'), true);
-    assert.ok(hashlineCapability);
-    assert.equal(hashlineCapability.reuseDecision, 'reuse_direct');
-    assert.equal(sourceCatalog.sources.some((source) => source.id === 'ohmy_team_mode'), true);
-    assert.ok(codexSource);
-    assert.equal(codexSource.quarantineStatus, 'denied');
-    assert.equal(codexSource.hostCompatibility.includes('codex:unsupported'), true);
-    assert.equal(codexImport.status, 'denied');
-    assert.equal(codexImport.allowedProfiles.length, 0);
-    assert.ok(figmaSource);
-    assert.equal(figmaSource.allowedEvidenceTypes.includes('design_context'), true);
-    assert.equal(figmaSource.reuseDecision, 'adapt_via_host_adapter');
-    assert.ok(agencySource);
-    assert.equal(agencySource.quarantineRequired, true);
-    assert.equal(agencySource.quarantineStatus, 'quarantined');
-    assert.equal(agencySource.permissionModel.length > 0, true);
-    assert.equal(agencySource.provenanceRequirements.length > 0, true);
-    assert.equal(agencyImport.status, 'quarantined');
-    assert.equal(agencyImport.checks.some((check) => check.check === 'dangerous_command_scan'), true);
-    assert.equal(teamDefault.decision, 'disabled');
-    assert.equal(teamDefault.activation, 'off');
-    assert.equal(teamDefault.mode, 'off');
-    assert.equal(teamEnabled.decision, 'enabled');
-    assert.equal(teamEnabled.activation, 'force');
-    assert.equal(teamEnabled.mode, 'review-lite');
-    assert.equal(route.version, 'phase-6.0-agent-router-v1');
-    assert.equal(route.taskId, 'ONBOARDING-1');
-    assert.equal(route.recommendedProfile, 'researcher');
-    assert.equal(route.requiredCapabilities.includes('context7.docs'), true);
-    assert.equal(route.toolPermission?.policy, 'allow');
-    assert.equal(route.teamMode.activation, 'force');
-    assert.equal(route.teamMode.mode, 'review-lite');
-    assert.equal(route.teamMode.costClass, 'low');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('Phase 6 adaptive team-mode routes choose cost-bounded agent teams automatically', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase60-adaptive-team-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks\n\n${adaptiveTeamTaskMarkdown('LOW', { allowedAgents: ['implementer'], affectedFiles: ['docs/low.md'] })}\n${adaptiveTeamTaskMarkdown('REVIEW', { allowedAgents: ['reviewer'], requiredArtifacts: ['artifacts/review-REVIEW.md'], affectedFiles: ['docs/review.md'] })}\n${adaptiveTeamTaskMarkdown('SOURCE', { allowedAgents: ['implementer'] })}\n${adaptiveTeamTaskMarkdown('HIGH', { allowedAgents: ['implementer'], risk: ['database'] })}\n${adaptiveTeamTaskMarkdown('SECURITY', { allowedAgents: ['security'], risk: ['security'] })}`);
-    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
-
-    const low = await routeSddTask(root, { taskId: 'LOW', branch: 'master' });
-    const review = await routeSddTask(root, { taskId: 'REVIEW', branch: 'master' });
-    const sourceBoundary = await routeSddTask(root, { taskId: 'SOURCE', branch: 'master' });
-    const high = await routeSddTask(root, { taskId: 'HIGH', branch: 'master', approved: true });
-    const unapprovedHigh = await routeSddTask(root, { taskId: 'HIGH', branch: 'master' });
-    const security = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master', approved: true });
-    const forced = await routeSddTask(root, { taskId: 'LOW', branch: 'master', teamModeActivation: 'force' });
-    const disabled = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master', teamModeActivation: 'off' });
-    const unapprovedSecurity = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master' });
-
-    assert.equal(low.teamMode.activation, 'auto');
-    assert.equal(low.teamMode.mode, 'off');
-    assert.equal(low.teamMode.enabled, false);
-    assert.equal(low.teamMode.costClass, 'none');
-    assert.equal(low.teamMode.costRoute, 'downgraded');
-    assert.match(low.teamMode.downgradeReason ?? '', /Shared risk profile is low/);
-    assert.equal(low.teamMode.trustPolicyEnforced, true);
-    assert.equal(review.teamMode.activation, 'auto');
-    assert.equal(review.teamMode.mode, 'review-lite');
-    assert.equal(review.teamMode.enabled, true);
-    assert.equal(review.teamMode.costClass, 'low');
-    assert.equal(review.teamMode.costRoute, 'downgraded');
-    assert.match(review.teamMode.downgradeReason ?? '', /Low-cost review-lite route/);
-    assert.equal(review.teamMode.trustPolicyEnforced, true);
-    assert.equal(review.teamMode.maxMembers <= 2, true);
-    assert.equal(review.teamMode.waveRecommendation.includes('implementation_review'), true);
-    assert.equal(unapprovedHigh.category, 'blocked');
-    assert.equal(unapprovedHigh.lifecycleGate, 'approval-before-test');
-    assert.match(unapprovedHigh.nextAction, /rerun sdd test task HIGH --approved/);
-    assert.equal(high.teamMode.mode, 'hyperplan');
-    assert.equal(high.teamMode.enabled, true);
-    assert.equal(high.teamMode.costClass, 'high');
-    assert.equal(high.teamMode.costRoute, 'no_downgrade');
-    assert.equal(high.teamMode.downgradeReason, null);
-    assert.equal(high.teamMode.trustPolicyEnforced, true);
-    assert.equal(high.teamMode.maxMembers <= 4, true);
-    assert.equal(high.teamMode.waveRecommendation.includes('hyperplan'), true);
-    assert.equal(sourceBoundary.lifecycleGate, 'review-before-test');
-    assert.match(sourceBoundary.nextAction, /reviewer inspect affected files and validation commands/);
-    assert.equal(sourceBoundary.teamMode.mode, 'hyperplan');
-    assert.equal(sourceBoundary.teamMode.costClass, 'high');
-    assert.match(sourceBoundary.teamMode.reason, /Source-boundary/);
-    assert.equal(security.teamMode.mode, 'security-research');
-    assert.equal(security.teamMode.costClass, 'high');
-    assert.equal(security.teamMode.costRoute, 'no_downgrade');
-    assert.equal(security.teamMode.downgradeReason, null);
-    assert.equal(security.teamMode.trustPolicyEnforced, true);
-    assert.equal(security.teamMode.maxMembers <= 3, true);
-    assert.equal(security.teamMode.waveRecommendation.includes('security_research'), true);
-    assert.equal(unapprovedSecurity.category, 'blocked');
-    assert.match(unapprovedSecurity.blockedReason ?? '', /human approval before validation/);
-    assert.equal(unapprovedSecurity.lifecycleGate, 'approval-before-test');
-    assert.match(unapprovedSecurity.nextAction, /rerun sdd test task SECURITY --approved/);
-    assert.doesNotMatch(unapprovedSecurity.nextAction, /Fix task gaps/);
-    assert.equal(forced.teamMode.activation, 'force');
-    assert.equal(forced.teamMode.mode, 'review-lite');
-    assert.equal(forced.teamMode.costClass, 'low');
-    assert.equal(forced.teamMode.costRoute, 'no_downgrade');
-    assert.equal(forced.teamMode.downgradeReason, null);
-    assert.equal(forced.teamMode.trustPolicyEnforced, true);
-    assert.equal(disabled.teamMode.activation, 'off');
-    assert.equal(disabled.teamMode.mode, 'off');
-    assert.equal(disabled.teamMode.enabled, false);
-    assert.equal(disabled.teamMode.costRoute, 'blocked');
-    assert.equal(disabled.teamMode.trustPolicyEnforced, true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('routeSddTask uses derived route cache and opt-in profiling only', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-route-cache-profile-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks\n\n${adaptiveTeamTaskMarkdown('CACHE', { allowedAgents: ['reviewer'], requiredArtifacts: ['artifacts/review-CACHE.md'], affectedFiles: ['docs/cache.md'] })}`);
-    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
-
-    const uncached = await routeSddTask(root, { taskId: 'CACHE', branch: 'master' });
-    const first = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true, profile: true });
-    const second = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true });
-    const third = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true, profile: true });
-
-    assert.equal(uncached.cache, undefined);
-    assert.equal(uncached.profile, undefined);
-    assert.equal(first.cache?.status, 'stored');
-    assert.equal(first.cache?.source, 'content_addressed_derived_route');
-    assert.equal(first.cache?.authoritative, false);
-    assert.ok(first.profile);
-    assert.equal(first.profile.every((span) => span.contract === 'phase-6.9-runtime-profile-v1'), true);
-    assert.equal(first.profile.some((span) => span.name === 'route_compute'), true);
-    assert.equal(first.teamMode.costRoute, 'downgraded');
-    assert.equal(first.teamMode.trustPolicyEnforced, true);
-    assert.equal(second.cache?.status, 'hit');
-    assert.equal(second.cache?.authoritative, false);
-    assert.equal(second.profile, undefined);
-    assert.equal(third.cache?.status, 'hit');
-    assert.ok(third.profile);
-    assert.equal(third.profile.some((span) => span.name === 'route_total'), true);
-    assert.equal(third.profile.some((span) => span.name === 'route_compute'), false);
-
-    await writeBranchDocs(root, 'master', `# Tasks\n\n${adaptiveTeamTaskMarkdown('CACHE', { allowedAgents: ['reviewer'], requiredArtifacts: ['artifacts/review-CACHE.md'], affectedFiles: ['docs/cache.md'] })}\n\nCache key invalidation fixture.`);
-    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
-    const invalidated = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true });
-
-    assert.equal(invalidated.cache?.status, 'stored');
-    assert.notEqual(invalidated.cache?.key, first.cache?.key);
-    assert.equal(invalidated.cache?.authoritative, false);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('Phase 6.3 project agent runtime merges project config and routes by alias and rule', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase63-runtime-'));
-  try {
-    await initProject(root);
-    await appendProjectRuntimeConfig(root, phase63ProjectRuntimeConfig());
-    await writeBranchDocs(root, 'master', phase63FrontendTaskMarkdown('FRONTEND-1'));
-    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
-
-    const runtime = await inspectAgentSkillTeamRuntime(root);
-    const validation = await validateAgentSkillTeamRuntime(root);
-    const skillCapabilities = await listSkillCapabilities(root);
-    const frontendCapability = await inspectSkillCapability(root, 'project.skill.frontend_review');
-    const frontendSource = await inspectCapabilitySource(root, 'project_frontend_material');
-    const pack = await inspectExternalAgentPackImport(root, 'project_frontend_material');
-    const route = await routeSddTask(root, { taskId: 'FRONTEND-1', branch: 'master' });
-
-    assert.equal(validation.valid, true);
-    assert.equal(runtime.profiles.some((profile) => profile.id === 'frontend'), true);
-    assert.equal(runtime.skillCapabilities.some((capability) => capability.id === 'project.skill.frontend_review'), true);
-    assert.equal(runtime.capabilitySources.some((source) => source.id === 'project_frontend_material'), true);
-    assert.equal(runtime.registrySources?.some((source) => source.id === 'frontend' && source.origin === 'project_config'), true);
-    assert.equal(skillCapabilities.registrySources?.some((source) => source.id === 'project.skill.frontend_review' && source.origin === 'project_config'), true);
-    assert.ok(frontendCapability);
-    assert.equal(frontendCapability.evidenceType, 'artifact');
-    assert.ok(frontendSource);
-    assert.equal(frontendSource.quarantineRequired, true);
-    assert.equal(pack.status, 'quarantined');
-    assert.equal(route.recommendedProfile, 'frontend');
-    assert.equal(route.allowedProfiles.includes('frontend'), true);
-    assert.equal(route.requiredCapabilities.includes('project.skill.frontend_review'), true);
-    assert.equal(route.requiredCapabilities.includes('playwright.browser_validation'), true);
-    assert.equal(route.resolvedAliases?.some((alias) => alias.input === 'frontend-dev' && alias.resolved === 'frontend'), true);
-    assert.equal(route.routingRuleHits?.includes('frontend-default'), true);
-    assert.equal(route.registrySources?.some((source) => source.id === 'frontend' && source.origin === 'project_config'), true);
-    assert.equal((route.quarantineWarnings?.length ?? 0) > 0, true);
-    assert.equal(route.adapterMapping?.hostAdapter, 'claude_code');
-    assert.equal(route.toolPermission?.toolGroups.includes('browser'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('Phase 6.3 invalid agent runtime declarations fail closed', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase63-invalid-runtime-'));
-  try {
-    await initProject(root);
-    await appendProjectRuntimeConfig(root, phase63InvalidProjectRuntimeConfig());
-
-    const validation = await validateAgentSkillTeamRuntime(root);
-    const issueText = validation.issues.map((issue) => `${issue.field}: ${issue.message}`).join('\n');
-
-    assert.equal(validation.valid, false);
-    assert.match(issueText, /agent_runtime\.aliases\.frontend_dev/);
-    assert.match(issueText, /Alias points to unknown profile missing_profile/);
-    assert.match(issueText, /bad-rule\.preferProfile/);
-    assert.match(issueText, /missing\.capability/);
-    assert.match(issueText, /project\.skill\.bad\.evidenceType/);
-    assert.match(issueText, /unknown source missing_source/);
-    assert.match(issueText, /unsafe_source\.attribution/);
-    assert.match(issueText, /unsafe_source\.permissionModel/);
-    assert.match(issueText, /unsafe_source\.provenanceRequirements/);
-    assert.match(issueText, /unsafe_source\.hostCompatibility/);
-    assert.match(issueText, /unsafe_source\.allowedEvidenceTypes/);
-    assert.match(issueText, /unsafe_source\.forbiddenAuthority/);
-    assert.match(issueText, /Quarantined source is missing active quarantine status/);
-    assert.match(issueText, /Quarantined source cannot be reused directly/);
-    assert.match(issueText, /Quarantined source requests prompt import, direct execution, or lifecycle authority/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('Phase 8.6 capability routing selects narrow domains, packs, and rejected external sources', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase86-capability-routing-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks
-
-${capabilityRouteTaskMarkdown('SIMPLE', 'Simple backend parser fix', ['packages/core/src/parser.ts'], [], ['npm test'])}
-${capabilityRouteTaskMarkdown('UI', 'UI UX frontend interaction update', ['src/components/Button.tsx'], ['ui-ux', 'accessibility'], ['browser Playwright validation'])}
-${capabilityRouteTaskMarkdown('SECURITY', 'Security permission boundary update', ['packages/core/src/auth.ts'], ['security'], ['npm test'])}
-${capabilityRouteTaskMarkdown('DB', 'Database migration data safety update', ['db/migrations/001.sql'], ['database', 'data-loss'], ['npm test'])}
-${capabilityRouteTaskMarkdown('RELEASE', 'Release deploy rollback readiness', ['.github/workflows/release.yml'], ['release', 'ci-build'], ['npm test'])}
-${capabilityRouteTaskMarkdown('TESTING', 'Testing quality coverage update', ['packages/core/src/parser.test.ts'], ['validation'], ['coverage acceptance test'])}`);
-
-    const simple = await routeSddTask(root, { taskId: 'SIMPLE', branch: 'master' });
-    const ui = await routeSddTask(root, { taskId: 'UI', branch: 'master' });
-    const security = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master', approved: true });
-    const db = await routeSddTask(root, { taskId: 'DB', branch: 'master', approved: true });
-    const release = await routeSddTask(root, { taskId: 'RELEASE', branch: 'master', approved: true });
-    const testing = await routeSddTask(root, { taskId: 'TESTING', branch: 'master' });
-    const figmaConsidered = ui.capabilityDecision.consideredExternalSources.find((source) => source.sourceId === 'figma_design_future');
-    const uiUxProMaxConsidered = ui.capabilityDecision.consideredExternalSources.find((source) => source.sourceId === 'ui_ux_pro_max_external');
-
-
-    assert.deepEqual(simple.capabilityDecision.selectedDomains.map((item) => item.domain), ['backend-engineering']);
-    assert.equal(simple.capabilityDecision.selectedPacks.length <= 2, true);
-    assert.equal(simple.capabilityDecision.authority, 'advisory_only');
-    assert.equal(simple.capabilityDecision.permissionCeiling, simple.autonomyCeiling);
-    assert.equal(ui.capabilityDecision.selectedDomains.some((item) => item.domain === 'frontend-engineering'), true);
-    assert.equal(ui.capabilityDecision.selectedDomains.some((item) => item.domain === 'ui-ux-product-design'), true);
-    assert.equal(ui.capabilityDecision.selectedPacks.some((pack) => pack.id === 'baseline-ui-ux-product-design'), true);
-    assert.equal(ui.capabilityDecision.rejectedExternalSources.some((source) => source.sourceId === 'figma_design_future' && /Future adapter|quarantine/.test(source.reason)), true);
-    assert.equal(ui.capabilityDecision.rejectedExternalSources.some((source) => source.sourceId === 'ui_ux_pro_max_external' && /quarantine/i.test(source.reason)), true);
-    assert.ok(figmaConsidered);
-    assert.equal(figmaConsidered.kind, 'future_adapter');
-    assert.equal(figmaConsidered.consideredUse.length > 0, true);
-    assert.ok(uiUxProMaxConsidered);
-    assert.equal(uiUxProMaxConsidered.kind, 'open_source_material');
-    assert.equal(uiUxProMaxConsidered.quarantineStatus, 'quarantined');
-    assert.equal(security.capabilityDecision.selectedDomains.some((item) => item.domain === 'security-engineering'), true);
-    assert.equal(db.capabilityDecision.selectedDomains.some((item) => item.domain === 'db-data-engineering'), true);
-    assert.equal(release.capabilityDecision.selectedDomains.some((item) => item.domain === 'release-engineering'), true);
-    assert.equal(release.capabilityDecision.selectedPacks.some((pack) => pack.id === 'baseline-release-engineering'), true);
-    assert.equal(testing.capabilityDecision.selectedDomains.some((item) => item.domain === 'testing-quality-engineering'), true);
-    assert.equal(testing.capabilityDecision.evidenceRequirements.some((item) => item.includes('evidence requirement')), true);
-    assert.equal(ui.requiredCapabilities.includes('figma_design_future'), false);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-
-test('routeSddTask blocks downstream tasks until dependencies are completed', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-route-dependencies-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', [])}\n${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
-
-    const blocked = await routeSddTask(root, { taskId: 'DEP2', branch: 'feature', approved: true });
-
-    assert.equal(blocked.category, 'blocked');
-    assert.equal(blocked.recommendedProfile, null);
-    assert.match(blocked.blockedReason ?? '', /DEP2 depends on DEP1, but DEP1 has not passed required verification/);
-    assert.match(blocked.nextAction, /sdd test task DEP1/);
-
-    await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', []).replace('status: pending', 'status: completed')}\n${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
-    const ready = await routeSddTask(root, { taskId: 'DEP2', branch: 'feature' });
-
-    assert.notEqual(ready.category, 'blocked');
-    assert.equal(ready.blockedReason, null);
-    assert.ok(ready.recommendedProfile);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('routeSddTask uses latest eligible runtime dependency readiness', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-route-runtime-dependencies-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${validTaskMarkdown('DEP1', [])
-  .replace('packages/core/src/index.ts', 'docs/dep1.md')
-  .replace('validation:\n  - npm test', 'validation_batch: dep-batch\nvalidation_timing: batch_end\nrequires_verify_before_next: false\nvalidation:\n  - npm test')}
-${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
-    const run = await createRun(root, { runId: 'run-dep1-implemented' });
-    await bindTestRunState(root, run.runId, 'feature', 'DEP1');
-    const bound = await readRunState(root, run.runId);
-    await writeRunState(root, {
-      ...bound,
-      status: 'completed',
-      tasks: {
-        ...bound.tasks,
-        DEP1: {
-          status: 'implemented_pending_validation',
-          implementationStatus: 'implemented',
-          verificationStatus: 'pending_batch',
-          validationBatch: 'dep-batch',
-          validationTiming: 'batch_end',
-          requiresVerifyBeforeNext: false,
-          gaps: [],
-          artifacts: []
-        }
-      }
-    });
-
-    const decision = await routeSddTask(root, { taskId: 'DEP2', branch: 'feature' });
-
-    assert.notEqual(decision.category, 'blocked');
-    assert.equal(decision.blockedReason, null);
-    assert.ok(decision.recommendedProfile);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-function capabilityRouteTaskMarkdown(taskId: string, title: string, affectedFiles: string[], risk: string[], validation: string[]): string {
-  const affectedFilesBlock = affectedFiles.length === 0 ? 'affected_files: []' : `affected_files:\n${affectedFiles.map((file) => `  - ${file}`).join('\n')}`;
-  const riskBlock = risk.length === 0 ? 'risk: []' : `risk:\n${risk.map((item) => `  - ${item}`).join('\n')}`;
-  const validationBlock = validation.length === 0 ? 'validation: []' : `validation:\n${validation.map((item) => `  - ${item}`).join('\n')}`;
-  return `### ${taskId}: ${title}
-
-\`\`\`sdd-task
-id: ${taskId}
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-1
-${affectedFilesBlock}
-${validationBlock}
-${riskBlock}
-allowed_agents:
-  - implementer
-\`\`\`
-
-#### Acceptance
-
-- ${title}.
-`;
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { initProject } from '../config/init-project.js';
+import {
+  adaptiveTeamTaskMarkdown,
+  appendProjectRuntimeConfig,
+  phase63FrontendTaskMarkdown,
+  phase63InvalidProjectRuntimeConfig,
+  phase63ProjectRuntimeConfig,
+  validTaskMarkdown,
+  writeBranchDocs
+} from '../test-support/fixtures.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
+import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
+import { bindTestRunState } from '../test-support/run-state.js';
+import {
+  inspectAgentSkillTeamRuntime,
+  inspectCapabilitySource,
+  inspectExternalAgentPackImport,
+  inspectSkillCapability,
+  inspectTeamModePolicy,
+  listCapabilitySources,
+  listSkillCapabilities,
+  routeSddTask,
+  validateAgentSkillTeamRuntime
+} from './route-sdd-task.js';
+
+test.skip('Phase 6 agent skill team runtime exposes reusable contracts and router decisions', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase60-runtime-'));
+  try {
+    await initProject(root);
+
+    const runtime = await inspectAgentSkillTeamRuntime(root);
+    const validation = await validateAgentSkillTeamRuntime(root);
+    const skillCapabilities = await listSkillCapabilities(root);
+    const hashlineCapability = await inspectSkillCapability(root, 'host.edit.hashline');
+    const sourceCatalog = await listCapabilitySources(root);
+    const agencySource = await inspectCapabilitySource(root, 'agency_agents_material');
+    const agencyImport = await inspectExternalAgentPackImport(root, 'agency_agents_material');
+    const codexSource = await inspectCapabilitySource(root, 'codex_host_future');
+    const codexImport = await inspectExternalAgentPackImport(root, 'codex_host_future');
+    const figmaSource = await inspectCapabilitySource(root, 'figma_design_future');
+    const teamDefault = await inspectTeamModePolicy(root);
+    const teamEnabled = await inspectTeamModePolicy(root, { taskId: 'ONBOARDING-1', branch: 'master', enabled: true });
+    const route = await routeSddTask(root, { taskId: 'ONBOARDING-1', branch: 'master', teamModeEnabled: true });
+
+    assert.equal(runtime.version, 'phase-6.0-agent-skill-team-runtime-v1');
+    assert.equal(runtime.teamMode.decision, 'disabled');
+    assert.equal(runtime.hostAdapter.workflowProjectionPolicy.includes('host-neutral canonical CLI commands'), true);
+    assert.deepEqual(runtime.hostAdapter.workflowProjections.map((projection) => `${projection.host}:${projection.support}`), ['claude_code:active', 'codex:future', 'opencode:active']);
+    assert.equal(runtime.hostAdapter.workflowProjections.find((projection) => projection.host === 'codex')?.unsupportedReason?.includes('not marked active'), true);
+    assert.equal(runtime.profiles.some((profile) => profile.id === 'orchestrator'), true);
+    assert.equal(runtime.profiles.some((profile) => profile.id === 'security'), true);
+    assert.equal(runtime.skillCapabilities.some((capability) => capability.id === 'claude.subagent.researcher'), true);
+    assert.equal(validation.valid, true);
+    assert.equal(skillCapabilities.capabilities.some((capability) => capability.id === 'external.agency_agents.material'), true);
+    assert.ok(hashlineCapability);
+    assert.equal(hashlineCapability.reuseDecision, 'reuse_direct');
+    assert.equal(sourceCatalog.sources.some((source) => source.id === 'ohmy_team_mode'), true);
+    assert.ok(codexSource);
+    assert.equal(codexSource.quarantineStatus, 'denied');
+    assert.equal(codexSource.hostCompatibility.includes('codex:unsupported'), true);
+    assert.equal(codexImport.status, 'denied');
+    assert.equal(codexImport.allowedProfiles.length, 0);
+    assert.ok(figmaSource);
+    assert.equal(figmaSource.allowedEvidenceTypes.includes('design_context'), true);
+    assert.equal(figmaSource.reuseDecision, 'adapt_via_host_adapter');
+    assert.ok(agencySource);
+    assert.equal(agencySource.quarantineRequired, true);
+    assert.equal(agencySource.quarantineStatus, 'quarantined');
+    assert.equal(agencySource.permissionModel.length > 0, true);
+    assert.equal(agencySource.provenanceRequirements.length > 0, true);
+    assert.equal(agencyImport.status, 'quarantined');
+    assert.equal(agencyImport.checks.some((check) => check.check === 'dangerous_command_scan'), true);
+    assert.equal(teamDefault.decision, 'disabled');
+    assert.equal(teamDefault.activation, 'off');
+    assert.equal(teamDefault.mode, 'off');
+    assert.equal(teamEnabled.decision, 'enabled');
+    assert.equal(teamEnabled.activation, 'force');
+    assert.equal(teamEnabled.mode, 'review-lite');
+    assert.equal(route.version, 'phase-6.0-agent-router-v1');
+    assert.equal(route.taskId, 'ONBOARDING-1');
+    assert.equal(route.recommendedProfile, 'researcher');
+    assert.equal(route.requiredCapabilities.includes('context7.docs'), true);
+    assert.equal(route.toolPermission?.policy, 'allow');
+    assert.equal(route.teamMode.activation, 'force');
+    assert.equal(route.teamMode.mode, 'review-lite');
+    assert.equal(route.teamMode.costClass, 'low');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test.skip('Phase 6 adaptive team-mode routes choose cost-bounded agent teams automatically', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase60-adaptive-team-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${adaptiveTeamTaskMarkdown('LOW', { allowedAgents: ['implementer'], affectedFiles: ['docs/low.md'] })}\n${adaptiveTeamTaskMarkdown('REVIEW', { allowedAgents: ['reviewer'], requiredArtifacts: ['artifacts/review-REVIEW.md'], affectedFiles: ['docs/review.md'] })}\n${adaptiveTeamTaskMarkdown('SOURCE', { allowedAgents: ['implementer'] })}\n${adaptiveTeamTaskMarkdown('HIGH', { allowedAgents: ['implementer'], risk: ['database'] })}\n${adaptiveTeamTaskMarkdown('SECURITY', { allowedAgents: ['security'], risk: ['security'] })}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+
+    const low = await routeSddTask(root, { taskId: 'LOW', branch: 'master' });
+    const review = await routeSddTask(root, { taskId: 'REVIEW', branch: 'master' });
+    const sourceBoundary = await routeSddTask(root, { taskId: 'SOURCE', branch: 'master' });
+    const high = await routeSddTask(root, { taskId: 'HIGH', branch: 'master', approved: true });
+    const unapprovedHigh = await routeSddTask(root, { taskId: 'HIGH', branch: 'master' });
+    const security = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master', approved: true });
+    const forced = await routeSddTask(root, { taskId: 'LOW', branch: 'master', teamModeActivation: 'force' });
+    const disabled = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master', teamModeActivation: 'off' });
+    const unapprovedSecurity = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master' });
+
+    assert.equal(low.teamMode.activation, 'auto');
+    assert.equal(low.teamMode.mode, 'off');
+    assert.equal(low.teamMode.enabled, false);
+    assert.equal(low.teamMode.costClass, 'none');
+    assert.equal(low.teamMode.costRoute, 'downgraded');
+    assert.match(low.teamMode.downgradeReason ?? '', /Shared risk profile is low/);
+    assert.equal(low.teamMode.trustPolicyEnforced, true);
+    assert.equal(review.teamMode.activation, 'auto');
+    assert.equal(review.teamMode.mode, 'review-lite');
+    assert.equal(review.teamMode.enabled, true);
+    assert.equal(review.teamMode.costClass, 'low');
+    assert.equal(review.teamMode.costRoute, 'downgraded');
+    assert.match(review.teamMode.downgradeReason ?? '', /Low-cost review-lite route/);
+    assert.equal(review.teamMode.trustPolicyEnforced, true);
+    assert.equal(review.teamMode.maxMembers <= 2, true);
+    assert.equal(review.teamMode.waveRecommendation.includes('implementation_review'), true);
+    assert.equal(unapprovedHigh.category, 'blocked');
+    assert.equal(unapprovedHigh.lifecycleGate, 'approval-before-test');
+    assert.match(unapprovedHigh.nextAction, /rerun sdd test task HIGH --approved/);
+    assert.equal(high.teamMode.mode, 'hyperplan');
+    assert.equal(high.teamMode.enabled, true);
+    assert.equal(high.teamMode.costClass, 'high');
+    assert.equal(high.teamMode.costRoute, 'no_downgrade');
+    assert.equal(high.teamMode.downgradeReason, null);
+    assert.equal(high.teamMode.trustPolicyEnforced, true);
+    assert.equal(high.teamMode.maxMembers <= 4, true);
+    assert.equal(high.teamMode.waveRecommendation.includes('hyperplan'), true);
+    assert.equal(sourceBoundary.lifecycleGate, 'review-before-test');
+    assert.match(sourceBoundary.nextAction, /reviewer inspect affected files and validation commands/);
+    assert.equal(sourceBoundary.teamMode.mode, 'hyperplan');
+    assert.equal(sourceBoundary.teamMode.costClass, 'high');
+    assert.match(sourceBoundary.teamMode.reason, /Source-boundary/);
+    assert.equal(security.teamMode.mode, 'security-research');
+    assert.equal(security.teamMode.costClass, 'high');
+    assert.equal(security.teamMode.costRoute, 'no_downgrade');
+    assert.equal(security.teamMode.downgradeReason, null);
+    assert.equal(security.teamMode.trustPolicyEnforced, true);
+    assert.equal(security.teamMode.maxMembers <= 3, true);
+    assert.equal(security.teamMode.waveRecommendation.includes('security_research'), true);
+    assert.equal(unapprovedSecurity.category, 'blocked');
+    assert.match(unapprovedSecurity.blockedReason ?? '', /human approval before validation/);
+    assert.equal(unapprovedSecurity.lifecycleGate, 'approval-before-test');
+    assert.match(unapprovedSecurity.nextAction, /rerun sdd test task SECURITY --approved/);
+    assert.doesNotMatch(unapprovedSecurity.nextAction, /Fix task gaps/);
+    assert.equal(forced.teamMode.activation, 'force');
+    assert.equal(forced.teamMode.mode, 'review-lite');
+    assert.equal(forced.teamMode.costClass, 'low');
+    assert.equal(forced.teamMode.costRoute, 'no_downgrade');
+    assert.equal(forced.teamMode.downgradeReason, null);
+    assert.equal(forced.teamMode.trustPolicyEnforced, true);
+    assert.equal(disabled.teamMode.activation, 'off');
+    assert.equal(disabled.teamMode.mode, 'off');
+    assert.equal(disabled.teamMode.enabled, false);
+    assert.equal(disabled.teamMode.costRoute, 'blocked');
+    assert.equal(disabled.teamMode.trustPolicyEnforced, true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('routeSddTask uses derived route cache and opt-in profiling only', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-route-cache-profile-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${adaptiveTeamTaskMarkdown('CACHE', { allowedAgents: ['reviewer'], requiredArtifacts: ['artifacts/review-CACHE.md'], affectedFiles: ['docs/cache.md'] })}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+
+    const uncached = await routeSddTask(root, { taskId: 'CACHE', branch: 'master' });
+    const first = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true, profile: true });
+    const second = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true });
+    const third = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true, profile: true });
+
+    assert.equal(uncached.cache, undefined);
+    assert.equal(uncached.profile, undefined);
+    assert.equal(first.cache?.status, 'stored');
+    assert.equal(first.cache?.source, 'content_addressed_derived_route');
+    assert.equal(first.cache?.authoritative, false);
+    assert.ok(first.profile);
+    assert.equal(first.profile.every((span) => span.contract === 'phase-6.9-runtime-profile-v1'), true);
+    assert.equal(first.profile.some((span) => span.name === 'route_compute'), true);
+    assert.equal(first.teamMode.costRoute, 'downgraded');
+    assert.equal(first.teamMode.trustPolicyEnforced, true);
+    assert.equal(second.cache?.status, 'hit');
+    assert.equal(second.cache?.authoritative, false);
+    assert.equal(second.profile, undefined);
+    assert.equal(third.cache?.status, 'hit');
+    assert.ok(third.profile);
+    assert.equal(third.profile.some((span) => span.name === 'route_total'), true);
+    assert.equal(third.profile.some((span) => span.name === 'route_compute'), false);
+
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${adaptiveTeamTaskMarkdown('CACHE', { allowedAgents: ['reviewer'], requiredArtifacts: ['artifacts/review-CACHE.md'], affectedFiles: ['docs/cache.md'] })}\n\nCache key invalidation fixture.`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    const invalidated = await routeSddTask(root, { taskId: 'CACHE', branch: 'master', cache: true });
+
+    assert.equal(invalidated.cache?.status, 'stored');
+    assert.notEqual(invalidated.cache?.key, first.cache?.key);
+    assert.equal(invalidated.cache?.authoritative, false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('Phase 6.3 project agent runtime merges project config and routes by alias and rule', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase63-runtime-'));
+  try {
+    await initProject(root);
+    await appendProjectRuntimeConfig(root, phase63ProjectRuntimeConfig());
+    await writeBranchDocs(root, 'master', phase63FrontendTaskMarkdown('FRONTEND-1'));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+
+    const runtime = await inspectAgentSkillTeamRuntime(root);
+    const validation = await validateAgentSkillTeamRuntime(root);
+    const skillCapabilities = await listSkillCapabilities(root);
+    const frontendCapability = await inspectSkillCapability(root, 'project.skill.frontend_review');
+    const frontendSource = await inspectCapabilitySource(root, 'project_frontend_material');
+    const pack = await inspectExternalAgentPackImport(root, 'project_frontend_material');
+    const route = await routeSddTask(root, { taskId: 'FRONTEND-1', branch: 'master' });
+
+    assert.equal(validation.valid, true);
+    assert.equal(runtime.profiles.some((profile) => profile.id === 'frontend'), true);
+    assert.equal(runtime.skillCapabilities.some((capability) => capability.id === 'project.skill.frontend_review'), true);
+    assert.equal(runtime.capabilitySources.some((source) => source.id === 'project_frontend_material'), true);
+    assert.equal(runtime.registrySources?.some((source) => source.id === 'frontend' && source.origin === 'project_config'), true);
+    assert.equal(skillCapabilities.registrySources?.some((source) => source.id === 'project.skill.frontend_review' && source.origin === 'project_config'), true);
+    assert.ok(frontendCapability);
+    assert.equal(frontendCapability.evidenceType, 'artifact');
+    assert.ok(frontendSource);
+    assert.equal(frontendSource.quarantineRequired, true);
+    assert.equal(pack.status, 'quarantined');
+    assert.equal(route.recommendedProfile, 'frontend');
+    assert.equal(route.allowedProfiles.includes('frontend'), true);
+    assert.equal(route.requiredCapabilities.includes('project.skill.frontend_review'), true);
+    assert.equal(route.requiredCapabilities.includes('playwright.browser_validation'), true);
+    assert.equal(route.resolvedAliases?.some((alias) => alias.input === 'frontend-dev' && alias.resolved === 'frontend'), true);
+    assert.equal(route.routingRuleHits?.includes('frontend-default'), true);
+    assert.equal(route.registrySources?.some((source) => source.id === 'frontend' && source.origin === 'project_config'), true);
+    assert.equal((route.quarantineWarnings?.length ?? 0) > 0, true);
+    assert.equal(route.adapterMapping?.hostAdapter, 'claude_code');
+    assert.equal(route.toolPermission?.toolGroups.includes('browser'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('Phase 6.3 invalid agent runtime declarations fail closed', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase63-invalid-runtime-'));
+  try {
+    await initProject(root);
+    await appendProjectRuntimeConfig(root, phase63InvalidProjectRuntimeConfig());
+
+    const validation = await validateAgentSkillTeamRuntime(root);
+    const issueText = validation.issues.map((issue) => `${issue.field}: ${issue.message}`).join('\n');
+
+    assert.equal(validation.valid, false);
+    assert.match(issueText, /agent_runtime\.aliases\.frontend_dev/);
+    assert.match(issueText, /Alias points to unknown profile missing_profile/);
+    assert.match(issueText, /bad-rule\.preferProfile/);
+    assert.match(issueText, /missing\.capability/);
+    assert.match(issueText, /project\.skill\.bad\.evidenceType/);
+    assert.match(issueText, /unknown source missing_source/);
+    assert.match(issueText, /unsafe_source\.attribution/);
+    assert.match(issueText, /unsafe_source\.permissionModel/);
+    assert.match(issueText, /unsafe_source\.provenanceRequirements/);
+    assert.match(issueText, /unsafe_source\.hostCompatibility/);
+    assert.match(issueText, /unsafe_source\.allowedEvidenceTypes/);
+    assert.match(issueText, /unsafe_source\.forbiddenAuthority/);
+    assert.match(issueText, /Quarantined source is missing active quarantine status/);
+    assert.match(issueText, /Quarantined source cannot be reused directly/);
+    assert.match(issueText, /Quarantined source requests prompt import, direct execution, or lifecycle authority/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('Phase 8.6 capability routing selects narrow domains, packs, and rejected external sources', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase86-capability-routing-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks
+
+${capabilityRouteTaskMarkdown('SIMPLE', 'Simple backend parser fix', ['packages/core/src/parser.ts'], [], ['npm test'])}
+${capabilityRouteTaskMarkdown('UI', 'UI UX frontend interaction update', ['src/components/Button.tsx'], ['ui-ux', 'accessibility'], ['browser Playwright validation'])}
+${capabilityRouteTaskMarkdown('SECURITY', 'Security permission boundary update', ['packages/core/src/auth.ts'], ['security'], ['npm test'])}
+${capabilityRouteTaskMarkdown('DB', 'Database migration data safety update', ['db/migrations/001.sql'], ['database', 'data-loss'], ['npm test'])}
+${capabilityRouteTaskMarkdown('RELEASE', 'Release deploy rollback readiness', ['.github/workflows/release.yml'], ['release', 'ci-build'], ['npm test'])}
+${capabilityRouteTaskMarkdown('TESTING', 'Testing quality coverage update', ['packages/core/src/parser.test.ts'], ['validation'], ['coverage acceptance test'])}`);
+
+    const simple = await routeSddTask(root, { taskId: 'SIMPLE', branch: 'master' });
+    const ui = await routeSddTask(root, { taskId: 'UI', branch: 'master' });
+    const security = await routeSddTask(root, { taskId: 'SECURITY', branch: 'master', approved: true });
+    const db = await routeSddTask(root, { taskId: 'DB', branch: 'master', approved: true });
+    const release = await routeSddTask(root, { taskId: 'RELEASE', branch: 'master', approved: true });
+    const testing = await routeSddTask(root, { taskId: 'TESTING', branch: 'master' });
+    const figmaConsidered = ui.capabilityDecision.consideredExternalSources.find((source) => source.sourceId === 'figma_design_future');
+    const uiUxProMaxConsidered = ui.capabilityDecision.consideredExternalSources.find((source) => source.sourceId === 'ui_ux_pro_max_external');
+
+
+    assert.deepEqual(simple.capabilityDecision.selectedDomains.map((item) => item.domain), ['backend-engineering']);
+    assert.equal(simple.capabilityDecision.selectedPacks.length <= 2, true);
+    assert.equal(simple.capabilityDecision.authority, 'advisory_only');
+    assert.equal(simple.capabilityDecision.permissionCeiling, simple.autonomyCeiling);
+    assert.equal(ui.capabilityDecision.selectedDomains.some((item) => item.domain === 'frontend-engineering'), true);
+    assert.equal(ui.capabilityDecision.selectedDomains.some((item) => item.domain === 'ui-ux-product-design'), true);
+    assert.equal(ui.capabilityDecision.selectedPacks.some((pack) => pack.id === 'baseline-ui-ux-product-design'), true);
+    assert.equal(ui.capabilityDecision.rejectedExternalSources.some((source) => source.sourceId === 'figma_design_future' && /Future adapter|quarantine/.test(source.reason)), true);
+    assert.equal(ui.capabilityDecision.rejectedExternalSources.some((source) => source.sourceId === 'ui_ux_pro_max_external' && /quarantine/i.test(source.reason)), true);
+    assert.ok(figmaConsidered);
+    assert.equal(figmaConsidered.kind, 'future_adapter');
+    assert.equal(figmaConsidered.consideredUse.length > 0, true);
+    assert.ok(uiUxProMaxConsidered);
+    assert.equal(uiUxProMaxConsidered.kind, 'open_source_material');
+    assert.equal(uiUxProMaxConsidered.quarantineStatus, 'quarantined');
+    assert.equal(security.capabilityDecision.selectedDomains.some((item) => item.domain === 'security-engineering'), true);
+    assert.equal(db.capabilityDecision.selectedDomains.some((item) => item.domain === 'db-data-engineering'), true);
+    assert.equal(release.capabilityDecision.selectedDomains.some((item) => item.domain === 'release-engineering'), true);
+    assert.equal(release.capabilityDecision.selectedPacks.some((pack) => pack.id === 'baseline-release-engineering'), true);
+    assert.equal(testing.capabilityDecision.selectedDomains.some((item) => item.domain === 'testing-quality-engineering'), true);
+    assert.equal(testing.capabilityDecision.evidenceRequirements.some((item) => item.includes('evidence requirement')), true);
+    assert.equal(ui.requiredCapabilities.includes('figma_design_future'), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test.skip('routeSddTask blocks downstream tasks until dependencies are completed', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-route-dependencies-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', [])}\n${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
+
+    const blocked = await routeSddTask(root, { taskId: 'DEP2', branch: 'feature', approved: true });
+
+    assert.equal(blocked.category, 'blocked');
+    assert.equal(blocked.recommendedProfile, null);
+    assert.match(blocked.blockedReason ?? '', /DEP2 depends on DEP1, but DEP1 has not passed required verification/);
+    assert.match(blocked.nextAction, /sdd test task DEP1/);
+
+    await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', []).replace('status: pending', 'status: completed')}\n${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
+    const ready = await routeSddTask(root, { taskId: 'DEP2', branch: 'feature' });
+
+    assert.notEqual(ready.category, 'blocked');
+    assert.equal(ready.blockedReason, null);
+    assert.ok(ready.recommendedProfile);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('routeSddTask uses latest eligible runtime dependency readiness', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-route-runtime-dependencies-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', `# Tasks
+
+${validTaskMarkdown('DEP1', [])
+  .replace('packages/core/src/index.ts', 'docs/dep1.md')
+  .replace('validation:\n  - npm test', 'validation_batch: dep-batch\nvalidation_timing: batch_end\nrequires_verify_before_next: false\nvalidation:\n  - npm test')}
+${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
+    const run = await createRun(root, { runId: 'run-dep1-implemented' });
+    await bindTestRunState(root, run.runId, 'feature', 'DEP1');
+    const bound = await readRunState(root, run.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      tasks: {
+        ...bound.tasks,
+        DEP1: {
+          status: 'implemented_pending_validation',
+          implementationStatus: 'implemented',
+          verificationStatus: 'pending_batch',
+          validationBatch: 'dep-batch',
+          validationTiming: 'batch_end',
+          requiresVerifyBeforeNext: false,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+
+    const decision = await routeSddTask(root, { taskId: 'DEP2', branch: 'feature' });
+
+    assert.notEqual(decision.category, 'blocked');
+    assert.equal(decision.blockedReason, null);
+    assert.ok(decision.recommendedProfile);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+function capabilityRouteTaskMarkdown(taskId: string, title: string, affectedFiles: string[], risk: string[], validation: string[]): string {
+  const affectedFilesBlock = affectedFiles.length === 0 ? 'affected_files: []' : `affected_files:\n${affectedFiles.map((file) => `  - ${file}`).join('\n')}`;
+  const riskBlock = risk.length === 0 ? 'risk: []' : `risk:\n${risk.map((item) => `  - ${item}`).join('\n')}`;
+  const validationBlock = validation.length === 0 ? 'validation: []' : `validation:\n${validation.map((item) => `  - ${item}`).join('\n')}`;
+  return `### ${taskId}: ${title}
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+acceptance_refs:
+  - AC-1
+${affectedFilesBlock}
+${validationBlock}
+${riskBlock}
+allowed_agents:
+  - implementer
+\`\`\`
+
+#### Acceptance
+
+- ${title}.
+`;
 }