@cr1ms0n/pi-subagent 0.8.9 → 0.9.0

package/src/policy.ts

@@ -7,7 +7,7 @@ import type { OutputMode, TaskProfile, TaskSpec } from "./types.js";
 import type { ParallelTaskInput, SubagentParams } from "./schema.js";
 import { BACKEND_NAMES, checkCapabilities, type BackendName } from "./backend.js";
 import { resolveBackend } from "./backends/index.js";
-import { validateModelRequest, type ModelPolicySnapshot } from "./model-policy.js";
+import type { JevRoutingConfig, RoutingDecision, RoutingModelCandidate } from "./routing-types.js";
 import { isThinkingLevel } from "./thinking.js";
 
 export const DEPTH_ENV_VAR = "PI_SUBAGENT_DEPTH";
@@ -62,6 +62,25 @@ export interface ResolvedTask extends TaskSpec {
   resolutionNotes: string[];
 }
 
+/** Local preparation cannot launch: it has candidates, not an execution model/tools. */
+export interface PreparedTask extends Omit<ResolvedTask, "model" | "canWrite" | "effectiveTools" | "routing"> {
+  candidateTools: string[];
+  mandatoryTools: string[];
+  /** Request > agent > profile. Selected candidate and parent are applied only after routing. */
+  requestedThinking?: TaskSpec["thinking"];
+  parentThinking?: TaskSpec["thinking"];
+}
+
+export interface PreparationOptions {
+  maxDepth?: number;
+  maxTasks?: number;
+  defaultTimeoutMs?: number;
+  taskDefaults?: TaskDefaultsByProfile;
+  agents?: Map<string, AgentDefinition>;
+  jevRouting?: JevRoutingConfig;
+  jevRoutingError?: string;
+}
+
 export type ManagementMode = "status" | "wait" | "cancel" | "steer" | "diff" | "apply" | "discard";
 
 export type ValidationResult =
@@ -73,7 +92,7 @@ export type ValidationResult =
       message?: string;
       index?: number;
       synthesis?: string;
-      tasks: ResolvedTask[];
+      tasks: PreparedTask[];
       /** True when action:"plan" requested a dry-run — no spawn. */
       planOnly?: boolean;
     }
@@ -87,7 +106,6 @@ function resolveTools(
   profile: TaskProfile,
   requested: string[] | undefined,
   availableTools: string[],
-  activeTools: string[],
   backend: BackendName,
 ): { tools?: string[]; canWrite?: boolean; error?: string } {
   const available = new Set(availableTools);
@@ -116,9 +134,9 @@ function resolveTools(
     return { tools: source, canWrite: false };
   }
 
-  const source = addContextTools(requested ?? activeTools);
+  const source = addContextTools(requested ?? availableTools);
   const unknown = source.filter((tool) => !available.has(tool));
-  if (unknown.length) return { error: `Active tools are unavailable: ${unknown.join(", ")}` };
+  if (unknown.length) return { error: `Candidate tools are unavailable: ${unknown.join(", ")}` };
   // General-profile custom tools are conservatively write-capable unless explicitly known non-writing.
   return {
     tools: source,
@@ -158,8 +176,8 @@ function normalizeTask(
   index: number,
   parent: ParentContext,
   defaultProfile: TaskProfile,
-  defaults: { timeoutMs?: number; taskDefaults?: TaskDefaultsByProfile; agents?: Map<string, AgentDefinition>; modelPolicy?: ModelPolicySnapshot; modelPolicyError?: string } = {},
-): { task?: ResolvedTask; error?: string } {
+  defaults: PreparationOptions = {},
+): { task?: PreparedTask; error?: string } {
   if (!item.task?.trim()) return { error: `Task ${index + 1} must not be blank` };
 
   // Named agent resolution is still used for persona/profile/tool behavior;
@@ -172,17 +190,9 @@ function normalizeTask(
     if (!lookup.agent) return { error: `Task ${index + 1}: ${lookup.error}` };
     agent = lookup.agent;
   }
-  if (!defaults.modelPolicy) {
-    return { error: defaults.modelPolicyError ?? "Model policy is not configured. Add modelPolicy.default to ~/.pi/subagent.json; management actions remain available, but new spawns are rejected." };
+  if (item.model !== undefined || item.fallback_models !== undefined) {
+    return { error: `Task ${index + 1}: omit model and fallback_models (including empty lists). Jev must select from jevRouting.models; manual/fixed routing is no longer supported.` };
   }
-  const modelCheck = validateModelRequest(defaults.modelPolicy, {
-    agent: agent?.name ?? item.agent,
-    model: item.model,
-    fallbackModels: item.fallback_models,
-    fallbackModelsProvided: item.fallback_models !== undefined,
-  });
-  if (modelCheck.error || !modelCheck.route) return { error: `Task ${index + 1}: ${modelCheck.error ?? "model policy validation failed"}` };
-  const modelRoute = modelCheck.route;
   if (item.output_mode && !item.output) return { error: `Task ${index + 1}: output_mode requires output` };
   if (item.fork_resume && !item.resume) return { error: `Task ${index + 1}: fork_resume requires resume` };
   if (item.timeout_ms !== undefined && (!Number.isInteger(item.timeout_ms) || item.timeout_ms < 1)) {
@@ -220,17 +230,22 @@ function normalizeTask(
   if (!BACKEND_NAMES.includes(backend)) {
     return { error: `Task ${index + 1}: unknown backend '${backend}' (expected ${BACKEND_NAMES.join(", ")})` };
   }
+  if (backend !== "pi") return { error: `Task ${index + 1}: new Jev-routed work supports backend:"pi" only; ${backend} is not supported. Existing-run management remains available.` };
   const profile = item.profile ?? agent?.profile ?? defaultProfile;
-  const requestedTools = item.tools ?? agent?.tools;
-  const resolved = resolveTools(profile, requestedTools, parent.availableTools, parent.activeTools ?? parent.availableTools, backend);
+  const requestedTools = item.tools;
+  const childDepth = (parent.depth ?? parseDepth()) + 1;
+  const nestedAllowed = profile === "general" && childDepth < (defaults.maxDepth ?? defaultConfig.maxDepth)
+    && agent?.spawns !== false && (!Array.isArray(agent?.spawns) || agent.spawns.length > 0);
+  const availableTools = parent.availableTools.filter((tool) => nestedAllowed || !["subagent", "subagent_wait"].includes(tool));
+  const resolved = resolveTools(profile, requestedTools, availableTools, backend);
   if (resolved.error || !resolved.tools || resolved.canWrite === undefined) return { error: resolved.error ?? "Tool resolution failed" };
   const cwd = resolvePath(parent.cwd, item.cwd);
   const output = item.output ? resolvePath(cwd, item.output) : undefined;
   // Non-model fields retain the existing precedence: explicit request > agent
-  // file > per-profile config defaults > parent inheritance. Model routing was
-  // validated above and is exclusively owned by modelPolicy.
+  // file > per-profile config defaults; candidate/parent thinking waits for routing.
   const profileDefaults: TaskDefaults = defaults.taskDefaults?.[profile] ?? {};
-  const effectiveThinking = item.thinking ?? agent?.thinking ?? profileDefaults.thinking ?? modelRoute.thinking ?? parent.thinking;
+  const requestedThinking = item.thinking ?? agent?.thinking ?? profileDefaults.thinking;
+  const effectiveThinking = requestedThinking ?? parent.thinking;
   if (effectiveThinking !== undefined && !isThinkingLevel(effectiveThinking)) {
     return { error: `Task ${index + 1}: thinking must be a non-empty Pi thinking level string without whitespace or control characters` };
   }
@@ -272,20 +287,19 @@ function normalizeTask(
       label,
       task: repairDoubleEncodedText(item.task.trim()),
       systemPrompt: systemPrompt ? repairDoubleEncodedText(systemPrompt) : systemPrompt,
-      // Model routing is exclusively owned by modelPolicy. Legacy agent,
-      // taskDefaults, and parent-session model fields never participate.
-      model: item.model!.trim(),
-      thinking: effectiveThinking,
-      tools: resolved.tools,
+      // No model or effective tool set exists until finalizeRoutedTasks succeeds.
+      requestedThinking,
+      parentThinking: parent.thinking,
+      thinking: requestedThinking,
+      candidateTools: resolved.tools.filter((tool) => !CONTEXT_MANAGEMENT_TOOLS.has(tool)),
+      mandatoryTools: resolved.tools.filter((tool) => CONTEXT_MANAGEMENT_TOOLS.has(tool)),
       profile,
       cwd,
-      timeoutMs: item.timeout_ms ?? agent?.timeoutMs ?? profileDefaults.timeoutMs ?? defaults.timeoutMs ?? defaultConfig.defaultTimeoutMs,
+      timeoutMs: item.timeout_ms ?? agent?.timeoutMs ?? profileDefaults.timeoutMs ?? defaults.defaultTimeoutMs ?? defaultConfig.defaultTimeoutMs,
       maxTurns: item.max_turns ?? agent?.maxTurns ?? profileDefaults.maxTurns,
       maxCost: item.max_cost ?? agent?.maxCost ?? profileDefaults.maxCost,
       graceTurns: item.grace_turns ?? agent?.graceTurns,
-      // The immutable configured route is copied into the TaskSpec; callers
-      // cannot add, remove, or reorder fallback models after validation.
-      fallbackModels: [...modelRoute.fallbackModels],
+      fallbackModels: [],
       maxRetries: item.max_retries ?? agent?.maxRetries ?? profileDefaults.maxRetries,
       contextFork: item.context === "fork",
       parentSessionFile: item.context === "fork" ? parent.sessionFile : undefined,
@@ -301,27 +315,26 @@ function normalizeTask(
       // Child's own future-spawn allowlist never inherits from boot env —
       // only the named persona's frontmatter `spawns` restricts grandchildren.
       spawns: agent?.spawns,
-      canWrite: resolved.canWrite,
-      effectiveTools: resolved.tools,
+
       resolutionNotes: [
         `backend=${backend}`,
         `profile=${profile}`,
-        `access=${resolved.canWrite ? "RW" : "RO"}`,
+
         ...(agent ? [`agent=${agent.name}`] : []),
-        `model-policy=${defaults.modelPolicy.agents.has(agent?.name ?? item.agent?.trim().toLowerCase() ?? "") ? "agent" : "default"}`,
+        "routing=jev (pending)",
       ],
     },
   };
 }
 
-function validateParallel(tasks: ResolvedTask[]): string | undefined {
+function validateParallel(tasks: Array<Pick<TaskSpec, "output" | "canWrite" | "isolation" | "cwd" | "allowSharedWrites">>): string | undefined {
   const outputs = new Set<string>();
   for (const task of tasks) {
     if (task.output && outputs.has(task.output)) return `Duplicate output path: ${task.output}`;
     if (task.output) outputs.add(task.output);
   }
 
-  const sharedByCwd = new Map<string, ResolvedTask[]>();
+  const sharedByCwd = new Map<string, Array<Pick<TaskSpec, "output" | "canWrite" | "isolation" | "cwd" | "allowSharedWrites">>>();
   for (const task of tasks.filter((task) => task.canWrite && task.isolation !== "worktree")) {
     const list = sharedByCwd.get(task.cwd!) ?? [];
     list.push(task);
@@ -395,57 +408,9 @@ export function shouldRegisterSubagentTool(
 export function validateSubagentRequest(
   params: SubagentParams,
   parent: ParentContext,
-  options: {
-    maxDepth?: number;
-    maxTasks?: number;
-    defaultTimeoutMs?: number;
-    taskDefaults?: TaskDefaultsByProfile;
-    agents?: Map<string, AgentDefinition>;
-    modelPolicy?: ModelPolicySnapshot;
-    modelPolicyError?: string;
-  } = {},
+  options: PreparationOptions = {},
 ): ValidationResult {
-  const defaults = {
-    timeoutMs: options.defaultTimeoutMs,
-    taskDefaults: options.taskDefaults,
-    agents: options.agents,
-    modelPolicy: options.modelPolicy,
-    modelPolicyError: options.modelPolicyError,
-  };
-  const depth = parent.depth ?? parseDepth();
-  const maxDepth = options.maxDepth ?? defaultConfig.maxDepth;
-  if (depth >= maxDepth) return { ok: false, error: `Subagent nesting depth limit reached (${depth} >= ${maxDepth})` };
-
-  // Boot spawn policy (from our parent) — fail closed; applies to new spawn modes only.
-  const spawnPolicy = parseSpawnPolicy(process.env[SPAWNS_ENV_VAR]);
-  if (spawnPolicy.kind !== "unrestricted") {
-    const hasSpawnWork = typeof params.task === "string" || Array.isArray(params.tasks);
-    if (hasSpawnWork) {
-      if (spawnPolicy.kind === "disabled") {
-        return { ok: false, error: `Subagent spawning is disabled by parent policy (${describeSpawnPolicy(spawnPolicy)})` };
-      }
-      // Allowlist requires a named agent from the list; agentless is rejected.
-      const requestedAgents: Array<string | undefined> = Array.isArray(params.tasks)
-        ? params.tasks.map((t) => t.agent)
-        : [params.agent];
-      for (let i = 0; i < requestedAgents.length; i++) {
-        const agentName = requestedAgents[i]?.trim().toLowerCase();
-        if (!agentName) {
-          return {
-            ok: false,
-            error: `Task ${i + 1}: agentless tasks are not allowed under parent ${describeSpawnPolicy(spawnPolicy)}`,
-          };
-        }
-        if (!spawnPolicy.agents.includes(agentName)) {
-          return {
-            ok: false,
-            error: `Task ${i + 1}: agent "${agentName}" is not in parent ${describeSpawnPolicy(spawnPolicy)}`,
-          };
-        }
-      }
-    }
-  }
-
+  const defaults = options;
   const hasAction = params.action !== undefined;
   const hasTask = typeof params.task === "string";
   const hasTasks = Array.isArray(params.tasks);
@@ -486,12 +451,46 @@ export function validateSubagentRequest(
     return { ok: true, mode: params.action as ManagementMode, async: false, id: params.id, message: params.message, index: params.index, tasks: [] };
   }
 
+  const depth = parent.depth ?? parseDepth();
+  const maxDepth = options.maxDepth ?? defaultConfig.maxDepth;
+  if (depth >= maxDepth) return { ok: false, error: `Subagent nesting depth limit reached (${depth} >= ${maxDepth})` };
+  if (!options.jevRouting) return { ok: false, error: options.jevRoutingError ?? "Jev routing is not configured. Add jevRouting.models with exact IDs and descriptions to ~/.pi/subagent.json; existing-run management remains available." };
+  // Boot spawn policy (from our parent) — fail closed; applies to new spawn modes only.
+  const spawnPolicy = parseSpawnPolicy(process.env[SPAWNS_ENV_VAR]);
+  if (spawnPolicy.kind !== "unrestricted") {
+    const hasSpawnWork = typeof params.task === "string" || Array.isArray(params.tasks);
+    if (hasSpawnWork) {
+      if (spawnPolicy.kind === "disabled") {
+        return { ok: false, error: `Subagent spawning is disabled by parent policy (${describeSpawnPolicy(spawnPolicy)})` };
+      }
+      // Allowlist requires a named agent from the list; agentless is rejected.
+      const requestedAgents: Array<string | undefined> = Array.isArray(params.tasks)
+        ? params.tasks.map((t) => t.agent)
+        : [params.agent];
+      for (let i = 0; i < requestedAgents.length; i++) {
+        const agentName = requestedAgents[i]?.trim().toLowerCase();
+        if (!agentName) {
+          return {
+            ok: false,
+            error: `Task ${i + 1}: agentless tasks are not allowed under parent ${describeSpawnPolicy(spawnPolicy)}`,
+          };
+        }
+        if (!spawnPolicy.agents.includes(agentName)) {
+          return {
+            ok: false,
+            error: `Task ${i + 1}: agent "${agentName}" is not in parent ${describeSpawnPolicy(spawnPolicy)}`,
+          };
+        }
+      }
+    }
+  }
+
   if (hasTasks) {
     const rawTasks = params.tasks!;
     const maxTasks = options.maxTasks ?? defaultConfig.maxTasksPerRun;
     if (!rawTasks.length || rawTasks.length > maxTasks) return { ok: false, error: `Expected 1..${maxTasks} tasks (configurable via maxTasksPerRun)` };
     // Top-level TaskFields apply only to single-task mode.
-    if (params.system_prompt !== undefined || params.model !== undefined || params.tools !== undefined || params.profile !== undefined || params.cwd !== undefined || params.resume !== undefined || params.agent !== undefined) {
+    if (params.system_prompt !== undefined || params.model !== undefined || params.fallback_models !== undefined || params.tools !== undefined || params.profile !== undefined || params.cwd !== undefined || params.resume !== undefined || params.agent !== undefined) {
       return { ok: false, error: "Top-level task options cannot be combined with tasks[]; set them on each tasks[] item" };
     }
     // Context forking duplicates the whole parent conversation per child;
@@ -499,7 +498,7 @@ export function validateSubagentRequest(
     if (rawTasks.length > 1 && rawTasks.some((task) => task.context === "fork")) {
       return { ok: false, error: "context:'fork' is single-task only; parallel fanout would duplicate the parent conversation per child" };
     }
-    const tasks: ResolvedTask[] = [];
+    const tasks: PreparedTask[] = [];
     for (let index = 0; index < rawTasks.length; index++) {
       const normalized = normalizeTask(rawTasks[index] as ParallelTaskInput, index, parent, "explore", defaults);
       if (normalized.error || !normalized.task) return { ok: false, error: normalized.error ?? "Invalid task" };
@@ -529,3 +528,35 @@ export function validateSubagentRequest(
 export function describeCapability(task: ResolvedTask): string {
   return `${task.profile}/${task.canWrite ? "RW" : "RO"} tools=[${task.effectiveTools.join(",")}]`;
 }
+
+/** Final local authority: no raw caller model field is synthesized to bypass policy. */
+export function finalizeRoutedTasks(
+  prepared: readonly PreparedTask[],
+  decisions: readonly RoutingDecision[],
+  models: readonly RoutingModelCandidate[],
+): { ok: true; tasks: ResolvedTask[] } | { ok: false; error: string } {
+  if (prepared.length !== decisions.length) return { ok: false, error: "Routing decision count does not match the prepared tasks." };
+  const tasks: ResolvedTask[] = [];
+  for (let index = 0; index < prepared.length; index++) {
+    const item = prepared[index]!;
+    const decision = decisions[index]!;
+    const candidate = models.find((entry) => entry.model === decision.selectedModel);
+    if (!candidate) return { ok: false, error: `Task ${index + 1}: selector chose a model outside the available dedicated candidates.` };
+    if (new Set(decision.selectedTools).size !== decision.selectedTools.length || decision.selectedTools.some((tool) => !item.candidateTools.includes(tool))) {
+      return { ok: false, error: `Task ${index + 1}: selector chose tools outside the locally permitted candidates.` };
+    }
+    const tools = [...new Set([...decision.selectedTools, ...item.mandatoryTools])];
+    const canWrite = tools.some((tool) => !NON_WRITING_TOOLS.has(tool));
+    if (item.profile !== "general" && canWrite) return { ok: false, error: `Task ${index + 1}: writable selector choice violates ${item.profile}.` };
+    const { candidateTools: _candidates, mandatoryTools, requestedThinking, parentThinking, ...spec } = item;
+    const thinking = requestedThinking ?? candidate.thinking ?? parentThinking;
+    tasks.push({
+      ...spec, model: candidate.model, thinking, tools, effectiveTools: tools, canWrite,
+      fallbackModels: [],
+      routing: { ...decision, mandatoryTools: [...mandatoryTools], outcome: "success" },
+      resolutionNotes: [...item.resolutionNotes.filter((note) => !note.startsWith("routing=")), "routing=jev", `access=${canWrite ? "RW" : "RO"}`],
+    });
+  }
+  const problem = validateParallel(tasks);
+  return problem ? { ok: false, error: problem } : { ok: true, tasks };
+}