sdd-agent-platform 0.4.1 → 0.5.0

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

@@ -0,0 +1,273 @@
+import type { RuntimeRef, SddStage } from '../contracts.js';
+import { readLifecycleRiskDecisionProjection } from '../risk/kernel.js';
+import { resolveSddContext } from '../sdd-docs/context.js';
+import { parseSddBranch, type SddTask, type SddTaskModel } from '../sdd-docs/task-parser.js';
+import { STAGE_ROUTE_BINDING_PRODUCER_VERSION, STAGE_ROUTE_BINDING_PROJECTION_TYPE, runtimeProjectionStableHash } from '../runtime-projection-p0.js';
+import { recordRuntimeProjectionEnvelope, type RuntimeProjectionEnvelopeWriteResult } from '../storage/runtime-store.js';
+
+export const STAGE_ROUTE_BINDING_CONTRACT_VERSION = 'sdd-stage-route-binding-v1' as const;
+
+export type StageRouteEntry = 'sdd:plan' | 'sdd:tasks' | 'sdd:execute' | 'sdd:ship';
+export type SddCommandBundle = 'plan' | 'tasks' | 'execute' | 'ship';
+export type StageRouteBindingStatus = 'bound' | 'ambiguous' | 'not_found' | 'stale_upstream' | 'boundary_expanding' | 'blocked';
+export type StageRouteTargetKind = 'task' | 'stage' | 'gate' | 'evidence_set' | 'ship_scope';
+export type StageRouteBindingNextAction = 'enter_stage' | 'run_internal_stage' | 'ask_clarification' | 'route_to_lifecycle_decision' | 'runtime_repair_required' | 'blocked';
+
+export interface StageRouteBinding {
+  contract: typeof STAGE_ROUTE_BINDING_CONTRACT_VERSION;
+  branch: string;
+  entry: StageRouteEntry;
+  bundle: SddCommandBundle;
+  targetRuntimeStage: SddStage;
+  userText: string;
+  status: StageRouteBindingStatus;
+  targetKind: StageRouteTargetKind | null;
+  targetId: string | null;
+  matchedRefs: RuntimeRef[];
+  activeLifecycleDecisionRef: string | null;
+  nextAction: StageRouteBindingNextAction;
+  reasons: string[];
+}
+
+interface TaskMatchCandidate {
+  task: SddTask;
+  score: number;
+}
+
+export async function bindStageRoute(projectRoot: string, input: { entry: StageRouteEntry; branch?: string; userText?: string }): Promise<StageRouteBinding> {
+  const context = await resolveSddContext(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined });
+  const model = await parseSddBranch(projectRoot, context.partition);
+  return bindStageRouteForModel(projectRoot, {
+    branch: context.partition,
+    model,
+    entry: input.entry,
+    userText: input.userText ?? ''
+  });
+}
+
+export async function bindStageRouteForModel(projectRoot: string, input: { branch: string; model: SddTaskModel; entry: StageRouteEntry; userText?: string }): Promise<StageRouteBinding> {
+  const userText = (input.userText ?? '').trim();
+  const activeLifecycleDecisionRef = (await readLifecycleRiskDecisionProjection(projectRoot, { branch: input.branch }))?.id ?? null;
+  if (input.entry === 'sdd:execute') {
+    return bindExecuteTask(input.branch, input.model, userText, activeLifecycleDecisionRef);
+  }
+  return bindBundleStage(input.branch, input.entry, userText, activeLifecycleDecisionRef);
+}
+
+export function stageRouteBindingScopeKey(binding: Pick<StageRouteBinding, 'branch' | 'entry' | 'userText'>): string {
+  return [binding.branch, binding.entry, runtimeProjectionStableHash(binding.userText || '<empty>').slice(0, 16)].join(':');
+}
+
+export async function recordStageRouteBindingProjection(projectRoot: string, binding: StageRouteBinding): Promise<RuntimeProjectionEnvelopeWriteResult<StageRouteBinding>> {
+  return recordRuntimeProjectionEnvelope(projectRoot, {
+    projectionType: STAGE_ROUTE_BINDING_PROJECTION_TYPE,
+    scopeKey: stageRouteBindingScopeKey(binding),
+    inputHash: runtimeProjectionStableHash(binding),
+    producer: 'phase9.18-stage-route-binding-runtime',
+    producerVersion: STAGE_ROUTE_BINDING_PRODUCER_VERSION,
+    payload: binding
+  });
+}
+
+function bindExecuteTask(branch: string, model: SddTaskModel, userText: string, activeLifecycleDecisionRef: string | null): StageRouteBinding {
+  const staleReason = executeStageStaleReason(model);
+  if (staleReason) {
+    return binding({
+      branch,
+      entry: 'sdd:execute',
+      targetRuntimeStage: 'execute',
+      userText,
+      status: 'stale_upstream',
+      targetKind: 'task',
+      targetId: null,
+      matchedRefs: [],
+      activeLifecycleDecisionRef,
+      nextAction: 'runtime_repair_required',
+      reasons: [staleReason]
+    });
+  }
+
+  const matches = matchTasks(model.tasks, userText);
+  if (matches.length === 0) {
+    const looksLikeId = looksLikeTaskId(userText);
+    return binding({
+      branch,
+      entry: 'sdd:execute',
+      targetRuntimeStage: 'execute',
+      userText,
+      status: looksLikeId ? 'not_found' : 'boundary_expanding',
+      targetKind: 'task',
+      targetId: null,
+      matchedRefs: [],
+      activeLifecycleDecisionRef,
+      nextAction: looksLikeId ? 'ask_clarification' : 'route_to_lifecycle_decision',
+      reasons: looksLikeId
+        ? [`Task ${userText || '<empty>'} was not found in the accepted task set.`]
+        : [`No accepted task boundary matched "${userText}"; run /sdd or /sdd:spec if this is new scope, risk, or acceptance.`]
+    });
+  }
+
+  const topScore = matches[0].score;
+  const tied = matches.filter((candidate) => candidate.score === topScore);
+  if (tied.length > 1) {
+    return binding({
+      branch,
+      entry: 'sdd:execute',
+      targetRuntimeStage: 'execute',
+      userText,
+      status: 'ambiguous',
+      targetKind: 'task',
+      targetId: null,
+      matchedRefs: tied.map((candidate) => taskRuntimeRef(candidate.task)),
+      activeLifecycleDecisionRef,
+      nextAction: 'ask_clarification',
+      reasons: [`Ambiguous task text "${userText}" matched ${tied.map((candidate) => candidate.task.id).join(', ')}; specify a task id or more precise title.`]
+    });
+  }
+
+  const task = matches[0].task;
+  return binding({
+    branch,
+    entry: 'sdd:execute',
+    targetRuntimeStage: 'execute',
+    userText,
+    status: 'bound',
+    targetKind: 'task',
+    targetId: task.id,
+    matchedRefs: [taskRuntimeRef(task)],
+    activeLifecycleDecisionRef,
+    nextAction: 'enter_stage',
+    reasons: [`Bound "${userText}" to task ${task.id}.`]
+  });
+}
+
+function bindBundleStage(branch: string, entry: Exclude<StageRouteEntry, 'sdd:execute'>, userText: string, activeLifecycleDecisionRef: string | null): StageRouteBinding {
+  const targetRuntimeStage = bundleTargetRuntimeStage(entry);
+  return binding({
+    branch,
+    entry,
+    targetRuntimeStage,
+    userText,
+    status: 'bound',
+    targetKind: entry === 'sdd:ship' ? 'ship_scope' : 'stage',
+    targetId: targetRuntimeStage,
+    matchedRefs: [{ kind: entry === 'sdd:ship' ? 'projection' : 'command', ref: `${entry}:${targetRuntimeStage}` }],
+    activeLifecycleDecisionRef,
+    nextAction: 'enter_stage',
+    reasons: [`Bound ${entry} to runtime stage ${targetRuntimeStage}.`]
+  });
+}
+
+function binding(input: Omit<StageRouteBinding, 'contract' | 'bundle'>): StageRouteBinding {
+  return {
+    contract: STAGE_ROUTE_BINDING_CONTRACT_VERSION,
+    bundle: bundleForEntry(input.entry),
+    ...input
+  };
+}
+
+function bundleForEntry(entry: StageRouteEntry): SddCommandBundle {
+  if (entry === 'sdd:plan') return 'plan';
+  if (entry === 'sdd:tasks') return 'tasks';
+  if (entry === 'sdd:execute') return 'execute';
+  return 'ship';
+}
+
+function bundleTargetRuntimeStage(entry: Exclude<StageRouteEntry, 'sdd:execute'>): SddStage {
+  if (entry === 'sdd:plan') return 'plan';
+  if (entry === 'sdd:tasks') return 'tasks';
+  return 'ship';
+}
+
+function executeStageStaleReason(model: SddTaskModel): string | null {
+  if (model.documents.tasksStale) {
+    return 'Tasks document is stale; return to the tasks stage before execute-stage binding.';
+  }
+  return null;
+}
+
+function matchTasks(tasks: SddTask[], userText: string): TaskMatchCandidate[] {
+  const query = normalizeSearchText(userText);
+  if (!query) {
+    return [];
+  }
+  return tasks
+    .map((task) => ({ task, score: scoreTask(task, userText, query) }))
+    .filter((candidate) => candidate.score >= 40)
+    .sort((left, right) => right.score - left.score || left.task.id.localeCompare(right.task.id));
+}
+
+function scoreTask(task: SddTask, rawQuery: string, normalizedQuery: string): number {
+  const normalizedId = normalizeSearchText(task.id);
+  if (normalizedId === normalizedQuery) {
+    return 1000;
+  }
+  if (normalizedId.includes(normalizedQuery) && normalizedQuery.length >= 2) {
+    return 700;
+  }
+
+  let score = 0;
+  score = Math.max(score, scoreTextField(task.title ?? '', rawQuery, normalizedQuery, 600, 360, 80));
+  score = Math.max(score, scoreTextField(task.acceptance.join(' '), rawQuery, normalizedQuery, 260, 180, 35));
+  score = Math.max(score, scoreTextField(task.boundary ?? '', rawQuery, normalizedQuery, 180, 120, 24));
+  score = Math.max(score, scoreTextField(task.affectedFiles.join(' '), rawQuery, normalizedQuery, 120, 80, 12));
+  return score;
+}
+
+function scoreTextField(value: string, rawQuery: string, normalizedQuery: string, exactScore: number, containsScore: number, tokenWeight: number): number {
+  const normalizedValue = normalizeSearchText(value);
+  if (!normalizedValue) {
+    return 0;
+  }
+  if (normalizedValue === normalizedQuery) {
+    return exactScore;
+  }
+  if ((normalizedValue.includes(normalizedQuery) || normalizedQuery.includes(normalizedValue)) && Math.min(normalizedValue.length, normalizedQuery.length) >= 2) {
+    return containsScore;
+  }
+  const queryTokens = searchTokens(rawQuery);
+  const valueTokens = searchTokens(value);
+  let overlap = 0;
+  for (const token of queryTokens) {
+    if (valueTokens.has(token)) {
+      overlap += 1;
+    }
+  }
+  return overlap * tokenWeight;
+}
+
+function normalizeSearchText(value: string): string {
+  return value.toLocaleLowerCase().normalize('NFKC').replace(/[\s\p{P}\p{S}_-]+/gu, '');
+}
+
+const LOW_SIGNAL_SEARCH_TOKENS = new Set(['system', 'systems', 'feature', 'features', '功能', '系统', '模块', '服务', '任务', '实现', '完成', '边界']);
+
+function searchTokens(value: string): Set<string> {
+  const tokens = new Set<string>();
+  const normalized = value.toLocaleLowerCase().normalize('NFKC');
+  for (const match of normalized.matchAll(/[a-z0-9]+/g)) {
+    addSearchToken(tokens, match[0]);
+  }
+  for (const match of normalized.matchAll(/\p{Script=Han}+/gu)) {
+    const text = match[0];
+    addSearchToken(tokens, text);
+    for (let index = 0; index < text.length - 1; index += 1) {
+      addSearchToken(tokens, text.slice(index, index + 2));
+    }
+  }
+  return tokens;
+}
+
+function addSearchToken(tokens: Set<string>, token: string): void {
+  if (token.length >= 2 && !LOW_SIGNAL_SEARCH_TOKENS.has(token)) {
+    tokens.add(token);
+  }
+}
+
+function looksLikeTaskId(value: string): boolean {
+  return /^[a-z][a-z0-9._-]*-?\d+$/i.test(value.trim());
+}
+
+function taskRuntimeRef(task: SddTask): RuntimeRef {
+  return { kind: 'task', ref: `task:${task.id}` };
+}

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

@@ -1,170 +1,170 @@
-import { TEAM_MODE_POLICY_VERSION } from '../contracts.js';
-import type { LifecycleAutonomyCeiling } from '../lifecycle/decision-gate.js';
-import type { TeamModeActivation } from './route-cache.js';
-import { BUILT_IN_DELEGATION_WAVES } from './runtime-registry.js';
-import type {
-  AgentProfileId,
-  AgentRouterCategory,
-  DelegationWavePolicy,
-  TeamModeCostClass,
-  TeamModeCostRoute,
-  TeamModeDecisionStatus,
-  TeamModePolicy,
-  TeamModeSelection
-} from './agent-runtime.js';
-import type { SddTask } from '../sdd-docs/task-parser.js';
-import { buildTaskRiskProfile } from '../task-risk-profile.js';
-import { taskAutonomyCeiling } from './risk-policy.js';
-
-export function resolveTeamModeActivation(options: { teamModeEnabled?: boolean; teamModeActivation?: TeamModeActivation }, defaultActivation: TeamModeActivation): TeamModeActivation {
-  if (options.teamModeActivation) {
-    return options.teamModeActivation;
-  }
-  if (options.teamModeEnabled === true) {
-    return 'force';
-  }
-  if (options.teamModeEnabled === false) {
-    return 'off';
-  }
-  return defaultActivation;
-}
-
-function baseTeamModePolicy(input: {
-  activation: TeamModeActivation;
-  mode: TeamModeSelection;
-  enabled: boolean;
-  decision: TeamModeDecisionStatus;
-  costClass: TeamModeCostClass;
-  reason: string;
-  costRoute?: TeamModeCostRoute;
-  downgradeReason?: string | null;
-  trustPolicyEnforced?: boolean;
-  allowedWaves?: DelegationWavePolicy[];
-  memberProfiles?: AgentProfileId[];
-  maxMembers?: number;
-  blockedReason?: string | null;
-}): TeamModePolicy {
-  const allowedWaves = input.allowedWaves ?? [];
-  const memberProfiles = (input.memberProfiles ?? [...new Set(allowedWaves.flatMap((wave) => wave.memberProfiles))]).slice(0, input.maxMembers ?? 0);
-  return {
-    version: TEAM_MODE_POLICY_VERSION,
-    enabled: input.enabled,
-    decision: input.decision,
-    mode: input.mode,
-    activation: input.activation,
-    costClass: input.costClass,
-    reason: input.reason,
-    costRoute: input.costRoute ?? 'not_applicable',
-    downgradeReason: input.downgradeReason ?? null,
-    trustPolicyEnforced: input.trustPolicyEnforced ?? true,
-    chiefProfile: 'orchestrator',
-    memberProfiles,
-    allowedWaves,
-    maxMembers: input.maxMembers ?? memberProfiles.length,
-    requireArtifacts: true,
-    blockedReason: input.blockedReason ?? null,
-    waveRecommendation: allowedWaves.map((wave) => wave.id)
-  };
-}
-
-function selectTeamWaves(ids: Array<DelegationWavePolicy['id']>): DelegationWavePolicy[] {
-  return ids.map((id) => BUILT_IN_DELEGATION_WAVES.find((wave) => wave.id === id)).filter((wave): wave is DelegationWavePolicy => Boolean(wave));
-}
-
-
-export function buildTeamModePolicy(options: { activation: TeamModeActivation; task?: SddTask | null; category?: AgentRouterCategory; risk?: string[]; autonomyCeiling?: LifecycleAutonomyCeiling; blockedReason?: string | null }): TeamModePolicy {
-  const activation = options.activation;
-  if (options.blockedReason) {
-    return baseTeamModePolicy({
-      activation,
-      mode: 'off',
-      enabled: false,
-      decision: 'blocked',
-      costClass: 'none',
-      reason: options.blockedReason,
-      blockedReason: options.blockedReason,
-      costRoute: 'blocked',
-      trustPolicyEnforced: true
-    });
-  }
-  if (activation === 'off') {
-    return baseTeamModePolicy({
-      activation,
-      mode: 'off',
-      enabled: false,
-      decision: 'disabled',
-      costClass: 'none',
-      reason: 'Team-mode automation disabled for this route.',
-      costRoute: 'not_applicable',
-      trustPolicyEnforced: true
-    });
-  }
-
-  const task = options.task ?? null;
-  const profile = buildTaskRiskProfile(task ? { ...task, risk: options.risk ?? task.risk } : null);
-  const category = options.category ?? 'planning';
-  const autonomyCeiling = options.autonomyCeiling ?? (task ? taskAutonomyCeiling(task) : 'direct_execution_allowed');
-  const highRisk = profile.riskLevel === 'high' || autonomyCeiling === 'full_sdd_with_checkpoint' || autonomyCeiling === 'research_before_implementation';
-  const reviewNeeded = category === 'implementation_review' || category === 'validation' || profile.teamRecommendation === 'review-lite';
-
-  if (profile.securitySensitive || category === 'security_research') {
-    return baseTeamModePolicy({
-      activation,
-      mode: 'security-research',
-      enabled: true,
-      decision: 'enabled',
-      costClass: 'high',
-      reason: 'Security-sensitive task automatically requires bounded security-research team evidence.',
-      costRoute: 'no_downgrade',
-      trustPolicyEnforced: true,
-      allowedWaves: selectTeamWaves(['security_research', 'validation']),
-      memberProfiles: ['security', 'reviewer', 'validator'],
-      maxMembers: 3
-    });
-  }
-
-  if (highRisk || category === 'external_research') {
-    return baseTeamModePolicy({
-      activation,
-      mode: 'hyperplan',
-      enabled: true,
-      decision: 'enabled',
-      costClass: highRisk ? 'high' : 'medium',
-      reason: profile.sourceBoundary ? 'Source-boundary or high-risk task requires adversarial planning/review evidence.' : 'High-risk or research-before-implementation task automatically requires adversarial planning/review evidence.',
-      costRoute: 'no_downgrade',
-      trustPolicyEnforced: true,
-      allowedWaves: selectTeamWaves(['hyperplan', 'implementation_review', 'validation']),
-      memberProfiles: ['architect', 'reviewer', 'security', 'validator'],
-      maxMembers: 4
-    });
-  }
-
-  if (reviewNeeded || activation === 'force') {
-    return baseTeamModePolicy({
-      activation,
-      mode: 'review-lite',
-      enabled: true,
-      decision: 'enabled',
-      costClass: 'low',
-      reason: activation === 'force' ? 'Team-mode was forced, so router selects the lowest-cost review-lite team.' : 'Task metadata indicates review or validation evidence is useful, so router selects review-lite.',
-      costRoute: activation === 'force' ? 'no_downgrade' : 'downgraded',
-      downgradeReason: activation === 'force' ? null : 'Low-cost review-lite route keeps reviewer/validator artifacts and policy-backed verify mandatory.',
-      trustPolicyEnforced: true,
-      allowedWaves: selectTeamWaves(['implementation_review', 'validation']),
-      memberProfiles: ['reviewer', 'validator'],
-      maxMembers: 2
-    });
-  }
-
-  return baseTeamModePolicy({
-    activation,
-    mode: 'off',
-    enabled: false,
-    decision: 'disabled',
-    costClass: 'none',
-    reason: 'No shared task risk profile signals require an agent team.',
-    costRoute: 'downgraded',
-    downgradeReason: 'Shared risk profile is low; artifact trust policy and policy-backed verify remain mandatory.',
-    trustPolicyEnforced: true
-  });
-}
+import { TEAM_MODE_POLICY_VERSION } from '../contracts.js';
+import type { LifecycleAutonomyCeiling } from '../lifecycle/decision-gate.js';
+import type { TeamModeActivation } from './route-cache.js';
+import { BUILT_IN_DELEGATION_WAVES } from './runtime-registry.js';
+import type {
+  AgentProfileId,
+  AgentRouterCategory,
+  DelegationWavePolicy,
+  TeamModeCostClass,
+  TeamModeCostRoute,
+  TeamModeDecisionStatus,
+  TeamModePolicy,
+  TeamModeSelection
+} from './agent-runtime.js';
+import type { SddTask } from '../sdd-docs/task-parser.js';
+import { buildTaskRiskProfile } from '../task-risk-profile.js';
+import { taskAutonomyCeiling } from './risk-policy.js';
+
+export function resolveTeamModeActivation(options: { teamModeEnabled?: boolean; teamModeActivation?: TeamModeActivation }, defaultActivation: TeamModeActivation): TeamModeActivation {
+  if (options.teamModeActivation) {
+    return options.teamModeActivation;
+  }
+  if (options.teamModeEnabled === true) {
+    return 'force';
+  }
+  if (options.teamModeEnabled === false) {
+    return 'off';
+  }
+  return defaultActivation;
+}
+
+function baseTeamModePolicy(input: {
+  activation: TeamModeActivation;
+  mode: TeamModeSelection;
+  enabled: boolean;
+  decision: TeamModeDecisionStatus;
+  costClass: TeamModeCostClass;
+  reason: string;
+  costRoute?: TeamModeCostRoute;
+  downgradeReason?: string | null;
+  trustPolicyEnforced?: boolean;
+  allowedWaves?: DelegationWavePolicy[];
+  memberProfiles?: AgentProfileId[];
+  maxMembers?: number;
+  blockedReason?: string | null;
+}): TeamModePolicy {
+  const allowedWaves = input.allowedWaves ?? [];
+  const memberProfiles = (input.memberProfiles ?? [...new Set(allowedWaves.flatMap((wave) => wave.memberProfiles))]).slice(0, input.maxMembers ?? 0);
+  return {
+    version: TEAM_MODE_POLICY_VERSION,
+    enabled: input.enabled,
+    decision: input.decision,
+    mode: input.mode,
+    activation: input.activation,
+    costClass: input.costClass,
+    reason: input.reason,
+    costRoute: input.costRoute ?? 'not_applicable',
+    downgradeReason: input.downgradeReason ?? null,
+    trustPolicyEnforced: input.trustPolicyEnforced ?? true,
+    chiefProfile: 'orchestrator',
+    memberProfiles,
+    allowedWaves,
+    maxMembers: input.maxMembers ?? memberProfiles.length,
+    requireArtifacts: true,
+    blockedReason: input.blockedReason ?? null,
+    waveRecommendation: allowedWaves.map((wave) => wave.id)
+  };
+}
+
+function selectTeamWaves(ids: Array<DelegationWavePolicy['id']>): DelegationWavePolicy[] {
+  return ids.map((id) => BUILT_IN_DELEGATION_WAVES.find((wave) => wave.id === id)).filter((wave): wave is DelegationWavePolicy => Boolean(wave));
+}
+
+
+export function buildTeamModePolicy(options: { activation: TeamModeActivation; task?: SddTask | null; category?: AgentRouterCategory; risk?: string[]; autonomyCeiling?: LifecycleAutonomyCeiling; blockedReason?: string | null }): TeamModePolicy {
+  const activation = options.activation;
+  if (options.blockedReason) {
+    return baseTeamModePolicy({
+      activation,
+      mode: 'off',
+      enabled: false,
+      decision: 'blocked',
+      costClass: 'none',
+      reason: options.blockedReason,
+      blockedReason: options.blockedReason,
+      costRoute: 'blocked',
+      trustPolicyEnforced: true
+    });
+  }
+  if (activation === 'off') {
+    return baseTeamModePolicy({
+      activation,
+      mode: 'off',
+      enabled: false,
+      decision: 'disabled',
+      costClass: 'none',
+      reason: 'Team-mode automation disabled for this route.',
+      costRoute: 'not_applicable',
+      trustPolicyEnforced: true
+    });
+  }
+
+  const task = options.task ?? null;
+  const profile = buildTaskRiskProfile(task ? { ...task, risk: options.risk ?? task.risk } : null);
+  const category = options.category ?? 'planning';
+  const autonomyCeiling = options.autonomyCeiling ?? (task ? taskAutonomyCeiling(task) : 'direct_execution_allowed');
+  const highRisk = profile.riskLevel === 'high' || autonomyCeiling === 'full_sdd_with_checkpoint' || autonomyCeiling === 'research_before_implementation';
+  const reviewNeeded = category === 'implementation_review' || category === 'validation' || profile.teamRecommendation === 'review-lite';
+
+  if (profile.securitySensitive || category === 'security_research') {
+    return baseTeamModePolicy({
+      activation,
+      mode: 'security-research',
+      enabled: true,
+      decision: 'enabled',
+      costClass: 'high',
+      reason: 'Security-sensitive task automatically requires bounded security-research team evidence.',
+      costRoute: 'no_downgrade',
+      trustPolicyEnforced: true,
+      allowedWaves: selectTeamWaves(['security_research', 'validation']),
+      memberProfiles: ['security', 'reviewer', 'validator'],
+      maxMembers: 3
+    });
+  }
+
+  if (highRisk || category === 'external_research') {
+    return baseTeamModePolicy({
+      activation,
+      mode: 'hyperplan',
+      enabled: true,
+      decision: 'enabled',
+      costClass: highRisk ? 'high' : 'medium',
+      reason: profile.sourceBoundary ? 'Source-boundary or high-risk task requires adversarial planning/review evidence.' : 'High-risk or research-before-implementation task automatically requires adversarial planning/review evidence.',
+      costRoute: 'no_downgrade',
+      trustPolicyEnforced: true,
+      allowedWaves: selectTeamWaves(['hyperplan', 'implementation_review', 'validation']),
+      memberProfiles: ['architect', 'reviewer', 'security', 'validator'],
+      maxMembers: 4
+    });
+  }
+
+  if (reviewNeeded || activation === 'force') {
+    return baseTeamModePolicy({
+      activation,
+      mode: 'review-lite',
+      enabled: true,
+      decision: 'enabled',
+      costClass: 'low',
+      reason: activation === 'force' ? 'Team-mode was forced, so router selects the lowest-cost review-lite team.' : 'Task metadata indicates review or validation evidence is useful, so router selects review-lite.',
+      costRoute: activation === 'force' ? 'no_downgrade' : 'downgraded',
+      downgradeReason: activation === 'force' ? null : 'Low-cost review-lite route keeps reviewer/validator artifacts and policy-backed verify mandatory.',
+      trustPolicyEnforced: true,
+      allowedWaves: selectTeamWaves(['implementation_review', 'validation']),
+      memberProfiles: ['reviewer', 'validator'],
+      maxMembers: 2
+    });
+  }
+
+  return baseTeamModePolicy({
+    activation,
+    mode: 'off',
+    enabled: false,
+    decision: 'disabled',
+    costClass: 'none',
+    reason: 'No shared task risk profile signals require an agent team.',
+    costRoute: 'downgraded',
+    downgradeReason: 'Shared risk profile is low; artifact trust policy and policy-backed verify remain mandatory.',
+    trustPolicyEnforced: true
+  });
+}

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

@@ -1,4 +1,5 @@
-export * from './router/agent-runtime-config.js';
-export * from './router/agent-runtime.js';
-export * from './router/route-cache.js';
-export * from './router/route-sdd-task.js';
+export * from './router/agent-runtime-config.js';
+export * from './router/agent-runtime.js';
+export * from './router/route-cache.js';
+export * from './router/route-sdd-task.js';
+export * from './router/runtime-import.js';