sdd-agent-platform 0.3.0 → 0.4.0

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

@@ -0,0 +1,146 @@
+import { TOOL_PERMISSION_SPEC_VERSION } from '../contracts.js';
+import type { LifecycleAutonomyCeiling } from '../lifecycle/decision-gate.js';
+import type { SddTask, SddTaskGap } from '../sdd-docs/task-parser.js';
+import type {
+  AgentProfileId,
+  AgentRouterCategory,
+  AgentRouterRejectedProfile,
+  AgentRuntimeAdapterMapping,
+  AgentRuntimeRoutingRule,
+  ModelPolicyContract,
+  RuntimeRegistryEntrySource,
+  ToolPermissionSpec
+} from './agent-runtime.js';
+import { BUILT_IN_MODEL_POLICIES, registrySourceFor, type AgentSkillRuntimeRegistry } from './runtime-registry.js';
+import { findBuiltInProfile, findRegisteredProfile, resolveAgentProfileToken } from './profile-resolution.js';
+import { hasExternalUnknownRisk, hasSecurityRisk, isHighRiskValues } from './risk-policy.js';
+
+export function routeCategory(task: SddTask, blockingGap: SddTaskGap | undefined, allowedProfiles: AgentProfileId[] = [], matchedRules: AgentRuntimeRoutingRule[] = []): AgentRouterCategory {
+  if (blockingGap) {
+    return 'blocked';
+  }
+  if (hasSecurityRisk(task.risk)) {
+    return 'security_research';
+  }
+  if (hasExternalUnknownRisk(task.risk)) {
+    return 'external_research';
+  }
+  if (task.status === 'completed') {
+    return 'validation';
+  }
+  const ruleCategory = matchedRules.find((rule) => rule.category)?.category;
+  if (ruleCategory) {
+    return ruleCategory;
+  }
+  if (allowedProfiles.every((profile) => profile === 'planner' || profile === 'architect' || profile === 'researcher')) {
+    return 'planning';
+  }
+  if (allowedProfiles.includes('reviewer') && !allowedProfiles.includes('implementer')) {
+    return 'implementation_review';
+  }
+  return 'implementation';
+}
+
+export function selectRequiredSkillCapabilities(task: SddTask, profile: AgentProfileId, registry: AgentSkillRuntimeRegistry, matchedRules: AgentRuntimeRoutingRule[]): string[] {
+  const capabilities = new Set<string>(['host.search.grep_glob']);
+  const profileContract = findRegisteredProfile(profile, registry);
+  for (const capabilityId of profileContract?.hostCapabilityRequirements ?? []) {
+    capabilities.add(capabilityId);
+  }
+  for (const rule of matchedRules) {
+    for (const capabilityId of rule.requireCapabilities) {
+      capabilities.add(capabilityId);
+    }
+  }
+  if (profile === 'researcher' || profile === 'planner' || profile === 'architect' || hasExternalUnknownRisk(task.risk)) {
+    capabilities.add('claude.subagent.researcher');
+    capabilities.add('context7.docs');
+  }
+  if (profile === 'implementer') {
+    capabilities.add('claude.subagent.implementer');
+    capabilities.add('host.edit.hashline');
+    capabilities.add('host.cli.shell');
+  }
+  if (profile === 'reviewer') {
+    capabilities.add('host.cli.shell');
+  }
+  if (profile === 'validator') {
+    capabilities.add('host.cli.shell');
+    if (task.validation.some((item) => /browser|ui|frontend|playwright|页面|前端/i.test(item))) {
+      capabilities.add('playwright.browser_validation');
+    }
+  }
+  if (profile === 'security' || hasSecurityRisk(task.risk)) {
+    capabilities.add('pattern.ohmy.security_research');
+  }
+  if (profile === 'domain_expert') {
+    capabilities.add('external.agency_agents.material');
+  }
+  return [...capabilities];
+}
+
+export function routeRegistrySources(registry: AgentSkillRuntimeRegistry, profile: AgentProfileId | null, capabilityIds: string[]): RuntimeRegistryEntrySource[] {
+  const selected: RuntimeRegistryEntrySource[] = [];
+  const seen = new Set<string>();
+  const pushSource = (source: RuntimeRegistryEntrySource | null): void => {
+    if (!source) {
+      return;
+    }
+    const key = `${source.kind}:${source.id}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      selected.push(source);
+    }
+  };
+  if (profile) {
+    pushSource(registrySourceFor(registry, 'profile', profile));
+  }
+  for (const capabilityId of capabilityIds) {
+    const capabilitySource = registrySourceFor(registry, 'skill_capability', capabilityId);
+    pushSource(capabilitySource);
+    if (capabilitySource?.sourceId) {
+      pushSource(registrySourceFor(registry, 'capability_source', capabilitySource.sourceId));
+    }
+  }
+  return selected;
+}
+
+export function quarantineWarningsForSources(sources: RuntimeRegistryEntrySource[]): string[] {
+  return sources.filter((source) => source.quarantineRequired).map((source) => `${source.kind}:${source.id} originates from quarantined material and remains declarative metadata only.`);
+}
+
+export function adapterMappingForProfile(registry: AgentSkillRuntimeRegistry, profile: AgentProfileId): AgentRuntimeAdapterMapping | null {
+  return registry.adapterMappings.find((mapping) => resolveAgentProfileToken(mapping.profile, registry).profile === profile) ?? null;
+}
+
+export function buildToolPermissionSpec(task: SddTask, profile: AgentProfileId, autonomyCeiling: LifecycleAutonomyCeiling, registry?: AgentSkillRuntimeRegistry): ToolPermissionSpec {
+  const highRisk = isHighRiskValues(task.risk);
+  const readonlyProfiles: AgentProfileId[] = ['planner', 'architect', 'researcher', 'reviewer', 'security', 'domain_expert'];
+  const profileContract = registry ? findRegisteredProfile(profile, registry) : null;
+  const toolGroups = profileContract && !findBuiltInProfile(profile) ? [...profileContract.toolScope] : readonlyProfiles.includes(profile) ? ['read', 'search', 'docs'] : profile === 'validator' ? ['read', 'test', 'browser'] : ['read', 'edit', 'test'];
+  return {
+    version: TOOL_PERMISSION_SPEC_VERSION,
+    profile,
+    risk: [...task.risk],
+    toolGroups,
+    fileScope: task.affectedFiles.length > 0 ? [...task.affectedFiles] : ['declared task boundary', 'artifacts/<task>.md'],
+    policy: highRisk || autonomyCeiling === 'full_sdd_with_checkpoint' || autonomyCeiling === 'research_before_implementation' ? 'ask' : 'allow',
+    approvalPolicy: highRisk ? 'human checkpoint required before write or external side effect' : 'host approval policy applies',
+    runtimeValidationRequired: highRisk || profile === 'implementer' || profile === 'validator',
+    deniedTools: profile === 'security' ? ['destructive_exploit', 'dos', 'credential_exfiltration', 'detection_evasion'] : ['destructive_git', 'unscoped_external_write'],
+    hostPermissionProjection: `profile=${profile}; autonomy=${autonomyCeiling}; policy=${highRisk ? 'ask' : 'host-default'}`
+  };
+}
+
+export function modelPolicyForProfile(profile: AgentProfileId | null, registry?: AgentSkillRuntimeRegistry): ModelPolicyContract {
+  const profileContract = profile && registry ? findRegisteredProfile(profile, registry) : null;
+  const policyId = profileContract?.modelPolicyId ?? (profile === 'security' ? 'security_review' : profile === 'planner' || profile === 'architect' || profile === 'reviewer' || profile === 'researcher' || profile === 'orchestrator' ? 'reasoning' : 'balanced');
+  return BUILT_IN_MODEL_POLICIES.find((policy) => policy.id === policyId) ?? BUILT_IN_MODEL_POLICIES[0];
+}
+
+export function buildRejectedProfiles(allowedProfiles: AgentProfileId[], blockedReason: string | null, registry: AgentSkillRuntimeRegistry): AgentRouterRejectedProfile[] {
+  const allowed = new Set(allowedProfiles);
+  return registry.profiles
+    .filter((profile) => !allowed.has(profile.id))
+    .map((profile) => ({ profile: profile.id, reason: blockedReason ?? 'Profile is outside task metadata allowed_agents/agent_fit, routing rules, or router risk category.' }));
+}

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

@@ -0,0 +1,281 @@
+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 {
+  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 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.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(agencySource);
+    assert.equal(agencySource.quarantineRequired, 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'] })}`);
+
+    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'] })}`);
+
+    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.`);
+    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'));
+
+    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, /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('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 status is pending/);
+    assert.match(blocked.nextAction, /Complete and sync-back DEP1 before routing DEP2/);
+
+    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 });
+  }
+});

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}$`;
+}