sdd-agent-platform 0.3.0 → 0.4.1

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

@@ -0,0 +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}.
+`;
+}

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

@@ -0,0 +1,3 @@
+export * from './runtime-inspection.js';
+export * from './runtime-validation.js';
+export * from './routing.js';

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

@@ -0,0 +1,73 @@
+import type { SddTask } from '../sdd-docs/task-parser.js';
+import type { AgentRuntimeRoutingRule } from './agent-runtime.js';
+import type { AgentSkillRuntimeRegistry } from './runtime-registry.js';
+
+export function matchRoutingRules(task: SddTask, registry: AgentSkillRuntimeRegistry): AgentRuntimeRoutingRule[] {
+  return registry.routingRules.filter((rule) => taskMatchesRoutingRule(task, rule));
+}
+
+function taskMatchesRoutingRule(task: SddTask, rule: AgentRuntimeRoutingRule): boolean {
+  const text = taskSearchText(task);
+  const keywordMatched = rule.when.keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+  const fileMatched = rule.when.affectedFileGlobs.some((glob) => task.affectedFiles.some((filePath) => globMatchesPath(glob, filePath)));
+  return keywordMatched || fileMatched;
+}
+
+function taskSearchText(task: SddTask): string {
+  const metadataValues: string[] = [];
+  for (const value of Object.values(task.rawMetadata)) {
+    if (Array.isArray(value)) {
+      metadataValues.push(...value);
+    } else {
+      metadataValues.push(value);
+    }
+  }
+  return [
+    task.id,
+    task.title ?? '',
+    task.boundary ?? '',
+    task.implementationNotes ?? '',
+    ...task.risk,
+    ...task.validation,
+    ...task.acceptance,
+    ...task.acceptanceRefs,
+    ...task.planRefs,
+    ...task.fileOwnership,
+    ...task.agentFit,
+    ...task.allowedAgents,
+    ...task.requiredArtifacts,
+    ...metadataValues
+  ].join('\n').toLowerCase();
+}
+
+function globMatchesPath(glob: string, filePath: string): boolean {
+  return new RegExp(globToRegExpPattern(glob.replace(/\\/g, '/'))).test(filePath.replace(/\\/g, '/'));
+}
+
+function globToRegExpPattern(glob: string): string {
+  let pattern = '^';
+  for (let index = 0; index < glob.length; index += 1) {
+    const char = glob[index];
+    const next = glob[index + 1];
+    if (char === '*' && next === '*') {
+      if (glob[index + 2] === '/') {
+        pattern += '(?:.*/)?';
+        index += 2;
+      } else {
+        pattern += '.*';
+        index += 1;
+      }
+      continue;
+    }
+    if (char === '*') {
+      pattern += '[^/]*';
+      continue;
+    }
+    if (char === '?') {
+      pattern += '[^/]';
+      continue;
+    }
+    pattern += /[.+^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
+  }
+  return `${pattern}$`;
+}