@diousk/pi-subagents-fast 0.20.0 → 0.22.0

package/src/agent-manager.ts

@@ -19,10 +19,12 @@ import { statSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resumeAgent, runAgent, type ToolActivity } from "./agent-runner.js";
+import { resolveDefaultModel, resumeAgent, runAgent, type ToolActivity } from "./agent-runner.js";
+import { getAgentConfig } from "./agent-types.js";
 import { assignHandle, handleBase } from "./mention.js";
 import { describeModel } from "./model-resolver.js";
-import type { AgentInvocation, AgentRecord, AgentTombstone, IsolationMode, MentionResolution, SubagentType, ThinkingLevel } from "./types.js";
+import { loadRoutingPolicy, ModelRouter, type RoutingInput } from "./model-routing.js";
+import type { AgentConfig, AgentInvocation, AgentRecord, AgentTombstone, IsolationMode, MentionResolution, SubagentType, ThinkingLevel } from "./types.js";
 import { addUsage, type LifetimeUsage } from "./usage.js";
 import type { CompiledSchema } from "./workflow/json-schema.js";
 import { cleanupWorktree, createWorktree, isWorktreeIsolationEnabled, pruneWorktrees, } from "./worktree.js";
@@ -167,6 +169,10 @@ interface SpawnArgs {
 }
 
 interface SpawnOptions {
+  /** Internal only; stripped at the programmatic/RPC boundary. */
+  routing?: RoutingInput;
+  /** Branch-local definition selected by a trusted invocation resolver. */
+  agentConfig?: AgentConfig;
   description: string;
   /**
    * Optional memorable name for this instance, becoming a second handle
@@ -361,6 +367,7 @@ async function shutdownChildSession(session: AgentSession | undefined): Promise<
 }
 
 export class AgentManager {
+  private router = new ModelRouter();
   private agents = new Map<string, AgentRecord>();
   private cleanupInterval: ReturnType<typeof setInterval>;
   private onComplete?: OnAgentComplete;
@@ -550,7 +557,7 @@ export class AgentManager {
       record.alias = assignHandle(handleBase(options.name), this.takenHandles());
     }
 
-    const args: SpawnArgs = { pi, ctx, type, prompt, options };
+    const args: SpawnArgs = { pi, ctx, type, prompt, options: { ...options, agentConfig: options.agentConfig ?? getAgentConfig(type) } };
 
     const pool = this.poolFor(record);
     if (pool !== undefined && !options.bypassQueue && !this.poolHasRoom(pool)) {
@@ -696,12 +703,65 @@ export class AgentManager {
       if (pool === "background") this.runningBackground--;
       else if (pool === "foreground") this.runningForeground--;
     };
+    const wasQueued = record.startGate !== undefined;
     record.status = "running";
     record.startedAt = Date.now();
     record.startGate = undefined;
     if (pool === "background") this.runningBackground++;
     else if (pool === "foreground") this.runningForeground++;
 
+    const config = options.agentConfig;
+    const provenance = options.routing;
+    const explicit = provenance
+      ? provenance.modelExplicit || provenance.thinkingExplicit
+      : options.model != null || options.thinkingLevel != null;
+    const currentPolicy = wasQueued || !provenance?.policy ? loadRoutingPolicy(options.configCwd ?? ctx.cwd) : undefined;
+    const policy = currentPolicy ?? provenance!.policy!;
+    record.routing = { mode: policy.mode, source: policy.source, fallbackSource: policy.fallbackSource,
+      code: policy.mode === "off" ? "off" : policy.diagnostic ? "guideline_unavailable" : "baseline",
+      reason: policy.mode === "off" ? "Model routing and routing guidance are off" : policy.diagnostic ?? "Using the existing model", guidelinePath: policy.guidelinePath, guidelineHash: policy.guidelineHash };
+    if (policy.diagnostic) console.warn(`[pi-subagents] ${policy.diagnostic}`);
+    const route = policy.mode === "jev" || policy.mode === "shadow" ||
+      (policy.mode === "auto" && !explicit && !config?.model && !config?.thinking && policy.source === "jev");
+    if (!options.resumeSessionFile && provenance?.entrypoint !== "internal" && route) {
+      const stop = () => this.abort(id);
+      options.signal?.addEventListener("abort", stop, { once: true });
+      if (options.signal?.aborted) stop();
+      try {
+        const routed = await this.router.choose(ctx, policy, prompt, options.description ?? type,
+          options.model ?? resolveDefaultModel(ctx.model, ctx.modelRegistry, config?.model),
+          record.abortController!.signal, usage => {
+            record.routingUsage = usage;
+            // Classifier tokens stay separate from coding/context/output budgets.
+            const delta = { input: usage.input, output: usage.output, cacheWrite: usage.cacheWrite, cacheRead: usage.cacheRead, cost: usage.cost.total };
+            this.onUsage?.(record, delta);
+            for (let current: AgentRecord | undefined = record; current; ) {
+              current.lifetimeUsage.cost = (current.lifetimeUsage.cost ?? 0) + usage.cost.total;
+              current = current.parentAgentId ? this.agents.get(current.parentAgentId) : undefined;
+            }
+          });
+        record.routing = { ...routed.decision, guidelinePath: policy.guidelinePath, guidelineHash: policy.guidelineHash };
+        if (routed.model && policy.mode === "shadow") {
+          record.routing = { ...record.routing, code: "shadow", model: undefined, suggestedModel: routed.decision.model,
+            fallbackSource: policy.source, reason: "Jev suggested a model; shadow mode kept the default-priority model" };
+        } else if (routed.model) {
+          options.model = routed.model;
+        }
+      } catch {
+        record.routing.code = "classifier_error";
+        record.routing.reason = "Jev could not choose a model; using the existing model";
+      } finally {
+        options.signal?.removeEventListener("abort", stop);
+      }
+      if (record.status !== "running" || record.abortController!.signal.aborted) {
+        this.settleRun(record, true, pool);
+        return;
+      }
+    } else if (policy.mode === "auto" && (explicit || config?.model || config?.thinking)) {
+      record.routing.code = "explicit";
+      record.routing.reason = "Explicit model or thinking; automatic routing skipped";
+    }
+
     // Worktree isolation: try to create a temporary git worktree. Strict —
     // fail loud if not possible (no silent fallback to main tree). Done BEFORE
     // the run is kicked off so a failure doesn't leave a half-running agent.
@@ -761,6 +821,7 @@ export class AgentManager {
     const promise = runAgent(ctx, type, prompt, {
       pi,
       agentId: id,
+      agentConfig: options.agentConfig,
       model: options.model,
       maxTurns: options.maxTurns,
       isolated: options.isolated,
@@ -1556,6 +1617,7 @@ export class AgentManager {
    */
   async dispose(pi?: ExtensionAPI): Promise<void> {
     clearInterval(this.cleanupInterval);
+    this.abortAll();
     // Clear queue — via dequeue, so anyone blocked in spawnAndWait is woken
     // rather than left awaiting a gate nothing will ever resolve.
     this.dequeue(() => true);

package/src/agent-runner.ts

@@ -14,6 +14,7 @@ import {
   DefaultResourceLoader,
   type ExtensionAPI,
   getAgentDir,
+  type ModelRuntime,
   SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
@@ -27,7 +28,7 @@ import { createNestedSubagentTools, getMaxSubagentDepth, type NestedAgentManager
 import { buildAgentPrompt, type PromptExtras } from "./prompts.js";
 import { preloadSkills } from "./skill-loader.js";
 import { createStructuredCapture, createStructuredOutputTool, structuredRetryPrompt } from "./structured-output.js";
-import type { ServiceTier, SubagentType, ThinkingLevel } from "./types.js";
+import type { AgentConfig, ServiceTier, SubagentType, ThinkingLevel } from "./types.js";
 import type { LifetimeUsage } from "./usage.js";
 import type { CompiledSchema } from "./workflow/json-schema.js";
 
@@ -94,6 +95,8 @@ export function installServiceTierPayload(
  * single-file extensions to the basename minus `.ts`/`.js`.
  */
 export function extensionCanonicalName(extPath: string): string {
+  if (extPath.startsWith("builtin:")) return extPath.slice("builtin:".length).toLowerCase();
+  if (extPath.startsWith("<inline:") && extPath.endsWith(">")) return extPath.slice(8, -1).toLowerCase();
   const base = basename(extPath);
   const name = base === "index.ts" || base === "index.js"
     ? basename(dirname(extPath))
@@ -159,6 +162,7 @@ function extensionPackageName(extPath: string): string | undefined {
  */
 export function extensionCanonicalNames(extPath: string): string[] {
   const canonical = extensionCanonicalName(extPath);
+  if (extPath.startsWith("builtin:") || extPath.startsWith("<inline:")) return [canonical];
   const pkg = extensionPackageName(extPath);
   return pkg && pkg !== canonical ? [canonical, pkg] : [canonical];
 }
@@ -250,12 +254,13 @@ export function parseExtSelectors(entries: string[]): {
  * snapshotted. `registerTool` writes into the very `extension.tools` maps this reads,
  * so `inScope()` sees late arrivals on the next call.
  *
- * Two enforcement points, because neither covers the whole picture:
+ * The active set and call-time checks cover different parts of scope:
  *
  *   - `turn_end` re-narrows the ACTIVE set. pi emits `turn_end` immediately before
  *     `prepareNextTurn` re-snapshots `agent.state.tools`, and session listeners run
  *     synchronously, so the narrow lands in time for turns 2..N.
- *   - `beforeToolCall` blocks out-of-scope calls. Turn 1 cannot be narrowed at all:
+ *   - The loader's bound `tool_call` handler blocks direct and nested calls.
+ *     Turn 1 cannot be narrowed at all:
  *     `before_agent_start` fires INSIDE `prompt()` and may widen the tool set, but
  *     `createContextSnapshot()` freezes that turn's tools immediately after — there
  *     is no hook in between. A call-time check is the only correct guard there.
@@ -285,7 +290,7 @@ export function installExtensionToolScope(
      */
     readmitToolNames: Set<string>;
   },
-): void {
+): (toolName: string) => boolean {
   const { loader, toolNames, disallowedSet, extNames, narrowing, readmitToolNames } = ctx;
 
   // The names allowed right now. Mirrors the `ext:` opt-in flip: when any `ext:`
@@ -309,7 +314,7 @@ export function installExtensionToolScope(
     }
     for (const name of EXCLUDED_TOOL_NAMES) keep.delete(name);
     // Injected tools are legitimately active for this agent — re-admit them so
-    // the renarrow keeps them in the active set and beforeToolCall doesn't
+    // the renarrow keeps them in the active set and the call-time guard doesn't
     // block them. Already vetted against `disallowed_tools` by the caller,
     // which is the only place that knows which kind may be taken back.
     for (const name of readmitToolNames) keep.add(name);
@@ -318,8 +323,14 @@ export function installExtensionToolScope(
 
   const renarrow = () => {
     const allowed = inScope();
-    const next = session.getAllTools().map((t) => t.name).filter((n) => allowed.has(n));
     const current = session.getActiveToolNames();
+    // Keep deferred/codemode tools callable without promoting them into model
+    // declarations. Explicit activation by an extension is preserved in scope.
+    const next = session.getAllTools().filter((tool) =>
+      allowed.has(tool.name) && (
+        tool.exposure === "direct" || tool.exposure === "model-only" || current.includes(tool.name)
+      ),
+    ).map((tool) => tool.name);
     // setActiveToolsByName unconditionally rebuilds the system prompt, so skip
     // the no-op that steady-state turns would otherwise pay for every turn.
     if (next.length !== current.length || next.some((n, i) => n !== current[i])) {
@@ -335,16 +346,7 @@ export function installExtensionToolScope(
     if (event.type === "turn_end") renarrow();
   });
 
-  const priorBeforeToolCall = session.agent.beforeToolCall;
-  session.agent.beforeToolCall = async (context, signal) => {
-    if (!inScope().has(context.toolCall.name)) {
-      return {
-        block: true,
-        reason: `Tool "${context.toolCall.name}" is not available to this subagent.`,
-      };
-    }
-    return priorBeforeToolCall?.(context, signal);
-  };
+  return (toolName) => inScope().has(toolName);
 }
 
 /** Default max turns. undefined = unlimited (no turn limit). */
@@ -434,6 +436,8 @@ export interface ToolActivity {
 }
 
 export interface RunOptions {
+  /** Snapshot of the selected definition for this branch. */
+  agentConfig?: AgentConfig;
   /** ExtensionAPI instance — used for pi.exec() instead of execSync. */
   pi: ExtensionAPI;
   /** Manager-assigned id; suffixes session name to disambiguate parallel spawns (e.g. `Explore#a1b2c3d4`). */
@@ -652,8 +656,8 @@ export async function runAgent(
   prompt: string,
   options: RunOptions,
 ): Promise<RunResult> {
-  const config = getConfig(type);
-  const agentConfig = getAgentConfig(type);
+  const agentConfig = options.agentConfig ?? getAgentConfig(type);
+  const config = agentConfig ?? getConfig(type);
 
   // Resolve working directory: worktree override > parent cwd
   const effectiveCwd = options.cwd ?? ctx.cwd;
@@ -686,7 +690,7 @@ export async function runAgent(
     }
   }
 
-  let toolNames = getToolNamesForType(type);
+  let toolNames = options.agentConfig ? options.agentConfig.builtinToolNames ?? [...BUILTIN_TOOL_NAMES] : getToolNamesForType(type);
 
   // Persistent memory: detect write capability and branch accordingly.
   // Account for disallowedTools — a tool in the base set but on the denylist is not truly available.
@@ -768,6 +772,7 @@ export async function runAgent(
   // must compare against this, not the surviving set (absence from survivors is
   // an exclude *succeeding*).
   let discoveredNames: Set<string> | undefined;
+  let toolInScope: ((toolName: string) => boolean) | undefined;
   const extensionsOverride: ((base: LoadExtensionsResult) => LoadExtensionsResult) | undefined =
     noExtensions || (loadAll && !hasExcludes)
       ? undefined
@@ -776,6 +781,7 @@ export async function runAgent(
           return {
             ...base,
             extensions: base.extensions.filter((e) => {
+              if (e.path === "<inline:subagent-tool-scope>") return true;
               const canons = extensionCanonicalNames(e.path);
               if (canons.some((n) => excludeNames.has(n))) return false; // exclude wins
               return loadAll || canons.some((n) => keepNames.has(n));
@@ -788,6 +794,19 @@ export async function runAgent(
     agentDir,
     noExtensions,
     additionalExtensionPaths,
+    // Pi's nested ctx.executeTool calls dispatch tool_call directly, and prompt
+    // setup can replace agent.beforeToolCall. Enforce scope in that dispatch too.
+    extensionFactories: noExtensions ? [] : [{
+      name: "subagent-tool-scope",
+      hidden: true,
+      factory: (pi) => {
+        pi.on("tool_call", (event) => {
+          if (toolInScope && !toolInScope(event.toolName)) {
+            return { block: true, reason: `Tool "${event.toolName}" is not available to this subagent.` };
+          }
+        });
+      },
+    }],
     extensionsOverride,
     noSkills,
     noPromptTemplates: true,
@@ -1014,24 +1033,14 @@ export async function runAgent(
         })
       : SessionManager.inMemory(effectiveCwd);
 
-  // Pi 0.80.8 replaced createAgentSession's modelRegistry option with
-  // modelRuntime, but ExtensionContext still exposes only the registry facade.
-  // Pass both so the full supported Pi range retains the parent's providers.
-  const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: unknown }).runtime;
-  const sessionOpts: Parameters<typeof createAgentSession>[0] & {
-    modelRegistry: ExtensionContext["modelRegistry"];
-    modelRuntime?: unknown;
-  } = {
+  // ExtensionContext exposes the registry facade; its runtime owns provider auth.
+  const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: ModelRuntime }).runtime;
+  const sessionOpts: Parameters<typeof createAgentSession>[0] = {
     cwd: effectiveCwd,
     agentDir,
     sessionManager,
     settingsManager,
-    modelRegistry: ctx.modelRegistry,
-    // `as never` is what keeps this assignable across the supported Pi range:
-    // pre-0.80.8 the field exists only via the `modelRuntime?: unknown` shim
-    // above, while newer Pi types it as `ModelRuntime` — a shape an opaque
-    // `unknown` read off the private facade field can never satisfy.
-    ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime as never }),
+    modelRuntime: parentModelRuntime,
     model,
     tools: sessionTools,
     customTools: [...nestedTools, ...structuredTools],
@@ -1073,7 +1082,7 @@ export async function runAgent(
   // handled below by re-deriving scope from the loader's live extension maps —
   // `registerTool` writes into those same maps, so late arrivals are judged too.
   if (!noExtensions) {
-    installExtensionToolScope(session, {
+    toolInScope = installExtensionToolScope(session, {
       loader,
       toolNames,
       disallowedSet,

package/src/custom-agents.ts

@@ -3,9 +3,10 @@
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
+import { loadRoutingSettings } from "./settings.js";
 import type { AgentConfig, IsolationMode, MemoryScope, ServiceTier, ThinkingLevel } from "./types.js";
 
 /**
@@ -47,9 +48,10 @@ export function loadCustomAgents(cwd: string, strict = false): Map<string, Agent
   const projectDir = join(cwd, ".pi", "agents");
 
   const agents = new Map<string, AgentConfig>();
-  loadFromDir(globalDir, agents, "global", strict);            // lowest priority
-  loadFromDir(workspaceProjectDir, agents, "project", strict); // shared workspace
-  loadFromDir(projectDir, agents, "project", strict);          // highest priority (overwrites)
+  const excluded = loadRoutingSettings(cwd).guidelineFile;
+  loadFromDir(globalDir, agents, "global", strict, excluded);
+  loadFromDir(workspaceProjectDir, agents, "project", strict, excluded);
+  loadFromDir(projectDir, agents, "project", strict, excluded);
 
   warnedLastLoad = warnedThisLoad;
   warnedThisLoad = new Set();
@@ -57,7 +59,7 @@ export function loadCustomAgents(cwd: string, strict = false): Map<string, Agent
 }
 
 /** Load agent configs from a directory into the map. */
-function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "project" | "global", strict: boolean): void {
+function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "project" | "global", strict: boolean, excluded?: string): void {
   if (!existsSync(dir)) return;
 
   let files: string[];
@@ -68,6 +70,7 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
   }
 
   for (const file of files) {
+    if (file.toLowerCase() === "custom-route.md" || resolve(dir, file) === excluded) continue;
     const filenameType = basename(file, ".md");
 
     const path = join(dir, file);
@@ -297,7 +300,7 @@ function parseMemory(val: unknown): MemoryScope | undefined {
 
 /** Parse the OpenAI Responses/Codex `service_tier` frontmatter field. */
 function parseServiceTier(val: unknown): ServiceTier | undefined {
-  if (val === "auto" || val === "default" || val === "flex" || val === "priority" || val === "scale") {
+  if (val === "auto" || val === "default" || val === "flex" || val === "fast" || val === "priority" || val === "scale") {
     return val;
   }
   return undefined;

package/src/index.ts

@@ -29,12 +29,13 @@ import { isolationParam, resolveAgentInvocationConfig, resolveJoinMode } from ".
 import { describeMention, handleBase, isReservedHandle, parseMention, resolveHandleToType, stripAgentPrefix } from "./mention.js";
 import { runMentionClone } from "./mention-clone.js";
 import { describeModel, type ModelRegistry, resolveModel } from "./model-resolver.js";
+import { loadRoutingPolicy, routingGuidance } from "./model-routing.js";
 import { checkModelScope, isScopeModelsEnabled, setScopeModelsEnabled } from "./model-scope.js";
 import { getMaxSubagentDepth, setMaxSubagentDepth } from "./nested-tools.js";
 import { createOutputFilePath, ensureOutputFile, getOutputTranscriptDefault, sessionTaskDir, setOutputTranscriptDefault, streamToOutputFile, writeInitialEntry } from "./output-file.js";
 import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
-import { applyAndEmitLoaded, loadSettings, type SubagentsSettings, saveAndEmitChanged, type ToolDescriptionMode } from "./settings.js";
+import { applyAndEmitLoaded, loadSettings, projectRoutingSettings, type SubagentsSettings, saveAndEmitChanged, type ToolDescriptionMode } from "./settings.js";
 import { getForegroundOutcomeNote, getStatusNote, partialOutputSuffix } from "./status-note.js";
 import { type AgentConfig, type AgentInvocation, type AgentMentionMode, type AgentRecord, type JoinMode, type NotificationDetails, type SubagentType, type ViewerMarkdownMode, type WidgetMode } from "./types.js";
 import { createMentionProvider, mentionRoster, type TypeInfo } from "./ui/agent-mention.js";
@@ -57,6 +58,7 @@ import {
   type UICtx,
 } from "./ui/agent-widget.js";
 import { FleetList, type FleetUICtx, type FleetWorkflow } from "./ui/fleet-list.js";
+import { showRoutingMenu } from "./ui/model-routing-menu.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { selectItem } from "./ui/select-item.js";
 import { renderWorkflowCard, renderWorkflowEntryCard } from "./ui/workflow-card.js";
@@ -396,6 +398,7 @@ export default function (pi: ExtensionAPI) {
   const reloadCustomAgents = (strict = false) => {
     const userAgents = loadCustomAgents(process.cwd(), strict);
     registerAgents(userAgents);
+    return userAgents;
   };
 
   // Initial load — the only strict one. A bad edit mid-session must not kill the
@@ -561,6 +564,8 @@ export default function (pi: ExtensionAPI) {
       durationMs,
       tokens,
       usage,
+      routing: record.routing,
+      routingUsage: record.routingUsage,
     };
   }
 
@@ -586,6 +591,7 @@ export default function (pi: ExtensionAPI) {
       id: record.id, type: record.type, description: record.description,
       status: record.status, result: record.result, error: record.error,
       startedAt: record.startedAt, completedAt: record.completedAt,
+      routing: record.routing, routingUsage: record.routingUsage,
     });
 
     // Skip notification if result was already consumed via get_subagent_result
@@ -697,6 +703,8 @@ export default function (pi: ExtensionAPI) {
 
   const spawnTopLevel = (piRef: any, ctxRef: any, type: string, prompt: string, options: any) => {
     const safeOptions = { ...(options ?? {}) };
+    delete safeOptions.routing;
+    delete safeOptions.agentConfig;
     delete safeOptions.parentAgentId;
     // Internal too: a forged value would hide an RPC-spawned agent inside
     // someone else's workflow, and take it out of the concurrency pool with it.
@@ -1364,6 +1372,16 @@ export default function (pi: ExtensionAPI) {
     widget.onTurnStart();
   });
 
+  pi.on("before_agent_start", (event, ctx) => {
+    const guidance = routingGuidance(loadRoutingPolicy(ctx.cwd));
+    const description = agentToolDescription + (guidance ? "\n\n" + guidance : "");
+    if (agentTool.description !== description) {
+      agentTool.description = description;
+      pi.registerTool(agentTool);
+    }
+    if (guidance) return { systemPrompt: event.systemPrompt + "\n\n" + guidance };
+  });
+
   /** Build the full type list text dynamically from available agents only. */
   const buildTypeListText = () => {
     const available = getAvailableTypes();
@@ -1578,10 +1596,11 @@ Terse command-style prompts produce shallow, generic work.
   // Held rather than registered inline: the mention clone reuses this exact
   // definition, so the agent it starts is an ordinary top-level spawn instead
   // of a second implementation that has to be kept in step with this one.
+  const initialRoutingGuidance = routingGuidance(loadRoutingPolicy(process.cwd()));
   const agentTool = defineTool({
     name: SUBAGENT_TOOL_NAMES.AGENT,
     label: "Agent",
-    description: agentToolDescription,
+    description: agentToolDescription + (initialRoutingGuidance ? "\n\n" + initialRoutingGuidance : ""),
     promptSnippet: "Launch autonomous sub-agents for complex multi-step tasks",
     promptGuidelines: [
       "Use Agent with specialized agents when the task matches an agent type's description. Subagents are valuable for parallelizing independent queries or for protecting the main context window from excessive results, but should not be used excessively when not needed. Importantly, avoid duplicating work that subagents are already doing — if you delegate research to a subagent, do not also perform the same searches yourself.",
@@ -1769,7 +1788,8 @@ Terse command-style prompts produce shallow, generic work.
       widget.setUICtx(ctx.ui as UICtx);
 
       // Reload custom agents so new project/global .md files are picked up without restart
-      reloadCustomAgents();
+      const userAgents = reloadCustomAgents();
+      const routingPolicy = loadRoutingPolicy(ctx.cwd, userAgents);
 
       const rawType = params.subagent_type as SubagentType;
       // Single decision point for dispatch (#183): unknown, disabled and
@@ -1916,6 +1936,10 @@ Terse command-style prompts produce shallow, generic work.
         const { modelName: recModelName, tags } = buildInvocationTags(rec.invocation);
         const recModeLabel = getPromptModeLabel(type);
         const recTags = recModeLabel ? [recModeLabel, ...tags] : tags;
+        if (rec.routing?.source === "jev" && (rec.routingUsage || rec.routing.unpriced !== undefined)) {
+          recTags.push(rec.routing.mode === "shadow" ? "Jev shadow" : "Jev");
+          if (rec.routing.unpriced) recTags.push("Jev price unavailable");
+        }
         return {
           displayName: getDisplayName(type),
           description: rec.description,
@@ -1952,7 +1976,7 @@ Terse command-style prompts produce shallow, generic work.
             subagent_type: requestedType,
             prompt: params.prompt as string,
             model: params.model as string | undefined,
-            thinking: thinking,
+            thinking: params.thinking as typeof thinking,
             max_turns: effectiveMaxTurns,
             isolated: isolated,
             isolation: isolation,
@@ -2057,6 +2081,8 @@ Terse command-style prompts produce shallow, generic work.
           description: params.description,
           name: params.name as string | undefined,
           model,
+          agentConfig: customConfig,
+          routing: { policy: routingPolicy, modelExplicit: !!resolvedConfig.modelInput, thinkingExplicit: thinking !== undefined, entrypoint: "agent" },
           maxTurns: effectiveMaxTurns,
           isolated,
           inheritContext,
@@ -2211,6 +2237,8 @@ Terse command-style prompts produce shallow, generic work.
           description: params.description,
           name: params.name as string | undefined,
           model,
+          agentConfig: customConfig,
+          routing: { policy: routingPolicy, modelExplicit: !!resolvedConfig.modelInput, thinkingExplicit: thinking !== undefined, entrypoint: "agent" },
           maxTurns: effectiveMaxTurns,
           isolated,
           inheritContext,
@@ -2933,6 +2961,7 @@ Terse command-style prompts produce shallow, generic work.
     // Actions
     options.push("Create new agent");
     options.push("Settings");
+    options.push("Model routing");
 
     const noAgentsMsg = allNames.length === 0 && agents.length === 0
       ? "No agents found. Create specialized subagents that can be delegated to.\n\n" +
@@ -2964,6 +2993,14 @@ Terse command-style prompts produce shallow, generic work.
     } else if (choice === "Settings") {
       await showSettings(ctx);
       await showAgentsMenu(ctx);
+    } else if (choice === "Model routing") {
+      const patch = await showRoutingMenu(ctx);
+      if (patch) {
+        const toast = saveAndEmitChanged({ ...snapshotSettings(), ...patch }, "Model routing settings updated", (event, payload) => pi.events.emit(event, payload), ctx.cwd);
+        ctx.ui.notify(toast.message, toast.level);
+        reloadCustomAgents();
+      }
+      await showAgentsMenu(ctx);
     }
   }
 
@@ -3331,6 +3368,7 @@ Write the file using the write tool. Only write the file, nothing else.`;
 
     const { record } = await manager.spawnAndWait(pi, ctx, "general-purpose", generatePrompt, {
       description: `Generate ${name} agent`,
+      routing: { modelExplicit: false, thinkingExplicit: false, entrypoint: "internal" },
       maxTurns: 5,
       // Exempt from maxConcurrentForeground. This runs from a modal wizard, not
       // a tool call: it passes no signal, and Esc in `ctx.ui` never reaches the
@@ -3440,6 +3478,7 @@ Write the file using the write tool. Only write the file, nothing else.`;
    */
   function snapshotSettings() {
     return {
+      ...projectRoutingSettings(process.cwd()),
       maxConcurrent: manager.getMaxConcurrent(),
       // 0 = unlimited, and the default — see SubagentsSettings.
       maxConcurrentForeground: manager.getMaxConcurrentForeground(),