@huseynsnmz/pi-suite 0.2.2 → 0.2.4

package/packages/modes/src/workdir.ts

@@ -0,0 +1,105 @@
+/**
+ * Bash keeps its folder, the way a shell would: a `cd` at the start of a command carries over to later commands while
+ * it stays in the project. Pi starts a new shell for each command, so later ones get the prefix from here, before the
+ * permission system reads them. It follows a literal cd, so paths are judged from the right folder, and this works
+ * with whichever extension runs bash, such as pi-sandbox. Replacing the bash tool would turn that extension off.
+ */
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { applyChoices, checkChoices } from "./review/apply.mjs";
+import { ruleFor } from "./review/collect.mjs";
+
+const LEADING_CD = /^\s*cd\s+(?:'([^']*)'|"([^"$`\\]*)"|([^\s;&|`$<>()'"\\]+))(?=\s*(?:&&|;|\n|$))/;
+/** Bare when it can be, as a rule like `cd /work/app/*` only matches the path as written. */
+const quoted = (text: string) => (/^[\w@%+=:,./-]+$/.test(text) ? text : `'${text.replaceAll("'", "'\\''")}'`);
+
+function folderAt(path: string): string | undefined {
+  try {
+    return statSync(path).isDirectory() ? realpathSync(path) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Where a cd goes. A model often repeats a move it already made, so a path that isn't here is tried from the top and from one up. */
+export function cdTarget(root: string, here: string | undefined, target: string): string | undefined {
+  if (target === "-") return undefined;
+  const path = target === "~" || target.startsWith("~/") ? join(homedir(), target.slice(1)) : target;
+  const from = here ?? root;
+  for (const base of [from, root, dirname(from)]) {
+    const folder = folderAt(resolve(base, path));
+    if (folder !== undefined) return folder;
+  }
+  return undefined;
+}
+
+/** The command to really run, and the folder it moves to if it starts with a cd. */
+export function planCommand(root: string, here: string | undefined, command: string): { command: string; move?: string } {
+  const match = LEADING_CD.exec(command);
+  const move = match === null ? undefined : cdTarget(root, here, match[1] ?? match[2] ?? match[3] ?? "");
+  if (match !== null && move !== undefined) return { command: `cd ${quoted(move)}${command.slice(match[0].length)}`, move };
+  return { command: here === undefined ? command : `cd ${quoted(here)} && ${command}` };
+}
+
+export function isInside(root: string, folder: string): boolean {
+  const inside = relative(root, folder);
+  return inside !== ".." && !inside.startsWith(`..${sep}`) && !isAbsolute(inside);
+}
+
+/** A cd inside the project, as typed or as its full path. Nothing shorter is safe: the permission system doesn't follow a new file's name into the folder a cd reached. */
+export function cdRules(root: string): string[] {
+  return [`cd ${root}`, `cd ${root}/*`];
+}
+
+/**
+ * The permission system judges each part of a chain, so with "*" asking, every `cd x && go test` asks about the cd.
+ * Moving inside the project does nothing by itself, so it's allowed for this project, once, with a backup. A cd
+ * anywhere else still asks. Whoever removes the rules keeps them removed. Returns what to tell the user.
+ */
+export function addCdRules(agentDir: string, root: string): { handled: boolean; notice?: string } {
+  const path = join(agentDir, "extensions", "pi-permission-system", "config.json");
+  if (root === "/" || !existsSync(path)) return { handled: false };
+  try {
+    const bash = JSON.parse(readFileSync(path, "utf8")).permission?.bash;
+    const asks = bash === undefined || (typeof bash === "object" && bash !== null && ruleFor(bash, `cd ${root}/x`) === "ask");
+    if (!asks) return { handled: true };
+    const rules = cdRules(root);
+    if (checkChoices(agentDir, { bash: rules }).length > 0) return { handled: true }; // A path a rule can't hold.
+    applyChoices(agentDir, { bash: rules });
+    return { handled: true, notice: `pi-modes allowed cd inside this project in your bash rules, so you aren't asked about each one. The rest of each command, and a cd anywhere else, are still checked. Remove them from ${path} if you'd rather be asked.` };
+  } catch {
+    return { handled: false }; // Not ours to fix. It's tried again next start.
+  }
+}
+
+export function registerWorkdir(pi: ExtensionAPI) {
+  let here: string | undefined;
+  const moves = new Map<string, string>();
+  pi.on("session_start", () => {
+    here = undefined;
+    moves.clear();
+  });
+  pi.on("tool_result", (event, ctx) => {
+    const move = moves.get(event.toolCallId);
+    if (move === undefined) return undefined;
+    moves.delete(event.toolCallId);
+    if (event.isError) return undefined;
+    const root = realpathSync(ctx.cwd);
+    const stays = isInside(root, move);
+    here = stays && move !== root ? move : undefined;
+    // Told here rather than in the system prompt, which would cost every request and replace the subscription part's prompt.
+    const note = stays ? `Bash stays in ${move} for later commands, so don't repeat the cd.` : `Shell cwd was reset to ${root}`;
+    return { content: [...event.content, { type: "text" as const, text: `\n${note}` }] };
+  });
+  return {
+    folder: () => here,
+    /** Rewrites a bash call in place. */
+    apply(toolCallId: string, input: { command: string }, cwd: string): void {
+      const plan = planCommand(realpathSync(cwd), here, input.command);
+      input.command = plan.command;
+      if (plan.move !== undefined) moves.set(toolCallId, plan.move);
+    },
+  };
+}

package/packages/router/README.md

@@ -9,10 +9,12 @@ Adds `router/auto` to [Pi](https://pi.dev): one choice in `/model` that uses a s
 Requires Pi 1.5 or newer.
 
 ```bash
-pi install npm:@huseynsnmz/pi-suite@0.2.2
+pi install npm:@huseynsnmz/pi-suite@0.2.4
 ```
 
-Log in to the providers you want with `/login`, run `/router` to choose a model for each role, then pick `router/auto` in `/model`.
+Log in to the providers you want with `/login`, run `/router` to choose a model for each role, then pick `router/auto` in `/model`. It's always listed there, and until `plan` and `build` are set it stops with a message telling you to run `/router`.
+
+In `/model`, `Enter` selects a model for this session and `Ctrl+S` saves it as your default for new sessions.
 
 ## Roles
 
@@ -21,21 +23,40 @@ Log in to the providers you want with `/login`, run `/router` to choose a model
 | `plan` | Reads and plans, up to the first edit, and everything in `plan` mode | Required |
 | `build` | Everything after that, and compaction summaries | Required |
 | `reader` | Reads web pages for [pi-web](https://github.com/huseynsnmz/pi-suite/tree/main/packages/web) | Same as `build` |
+| `mastermind` | Reviews past conversations for `/mastermind`, and writes rules for the other models | Not set |
 | `judge` | Decides permission asks for `pi-permission-classifier` | See below |
 | `subagent` | Runs subagents that use `router/auto` | Same as `build` |
 | `fallback` | Takes over when a provider is overloaded or rate limited | Retries on the same model |
 
-`/router` saves them in `~/.pi/agent/router.json`, apart from `judge`, which goes in the judge's own config:
+`/router` saves them under `router` in `~/.pi/agent/suite.json`, apart from `judge`, which goes in the judge's own config. `/suite` opens the same screen.
+
+```json
+{
+  "router": {
+    "plan": "anthropic/claude-opus-5-5",
+    "build": "anthropic/claude-haiku-5-5",
+    "fallback": "openai/gpt-5.6-luna"
+  }
+}
+```
+
+There's no setting per project, so a repository can't choose where your code gets sent.
+
+## Reasoning per role
+
+After you choose a model for a role, `/router` asks how much reasoning it should use, offering only the levels that model has. It's saved next to the roles:
 
 ```json
 {
-  "plan": "anthropic/claude-opus-5-5",
-  "build": "anthropic/claude-haiku-5-5",
-  "fallback": "openai/gpt-5.6-luna"
+  "router": {
+    "plan": "anthropic/claude-opus-5-5",
+    "build": "anthropic/claude-haiku-5-5",
+    "thinking": { "plan": "high", "build": "low" }
+  }
 }
 ```
 
-There's no setting per project, so a repository can't choose where your code gets sent. The thinking level you pick with `/effort` applies to every role, and Pi lowers it for a model that can't do it.
+A role with no level of its own uses the one you pick with `/effort`. Changing a role's model clears its level, because the new model may not have it. A retry keeps the level of the request that failed. `reader` and `subagent` with no model of their own use `build`'s level. `judge` has no level here, as it's set in the judge's own config.
 
 ## How it decides
 
@@ -50,7 +71,7 @@ There's no setting per project, so a repository can't choose where your code get
 - Moving from `plan` to `build` happens once in a session. It loses the prompt cache one time, as any change of model does.
 - The session stays on `build` after that. For a hard follow-up, switch to `plan` mode, or start a new session.
 - If a request fails because the provider is overloaded, it moves to `fallback` for the rest of that turn. The next message tries the first choice again. Any other failure retries on the same model.
-- A role whose model is missing or has no login stops that request with an error naming it, and so does a broken `router.json`. The router doesn't pick another model for you.
+- A role whose model is missing or has no login stops that request with an error naming it, and so do broken router settings. The router doesn't pick another model for you.
 - Leaving `plan` mode counts as finishing planning, whether you approved a plan or changed mode.
 - The roles only apply while `router/auto` is selected. On any other model, nothing goes to them, and pages are read as if the router weren't there.
 - `/suite off router` moves the session to the model that last answered. If `router/auto` is your saved default, later sessions use another available model, as Pi does for any model that no longer exists.
@@ -61,7 +82,7 @@ The phase follows the session tree, so a branch keeps its own.
 
 **`modes`:** tells the router the mode. With it off, the router only goes by the first edit.
 
-**`web`:** your `readerModel` in `web.json` still wins over the `reader` role.
+**`web`:** your `readerModel` in the web settings still wins over the `reader` role.
 
 **`frame`:** shows who answered, such as `Auto → Haiku`. Pi's own footer already does.
 

package/packages/router/src/config.ts

@@ -1,40 +1,54 @@
-// ~/.pi/agent/router.json. Global only: a repository must not choose where your code gets sent.
-import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+// The router section of ~/.pi/agent/suite.json. Global only: a repository must not choose where your code gets sent.
+import { readSection, writeSection } from "../../../src/settings.ts";
 
 /** The judge's model lives only in the judge's own config, so there's one answer to which model judges. */
-export const ROLES = ["plan", "build", "reader", "subagent", "fallback"] as const;
+export const ROLES = ["plan", "build", "reader", "subagent", "fallback", "mastermind"] as const;
 export type Role = (typeof ROLES)[number];
 
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+/** A role left out uses the level selected with /effort. */
+export type RoleThinking = Partial<Record<Role, ThinkingLevel>>;
+
 export interface RouterConfig {
   plan: string;
   build: string;
   reader?: string;
   subagent?: string;
   fallback?: string;
+  mastermind?: string;
+  thinking?: RoleThinking;
 }
 
-export type SavedConfig = Partial<Record<Role, string>>;
+export type SavedConfig = Partial<Record<Role, string>> & { thinking?: RoleThinking };
 
 export const VIRTUAL_PROVIDER = "router";
 export const VIRTUAL_ID = "auto";
 
-export function configPath(agentDir: string): string {
-  return join(agentDir, "router.json");
-}
-
 export function parseRef(ref: string): { provider: string; id: string } {
   const at = ref.indexOf("/");
   return { provider: ref.slice(0, at), id: ref.slice(at + 1) };
 }
 
+function parseThinking(raw: unknown): void {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("suite.json router: thinking must be an object");
+  for (const [role, level] of Object.entries(raw)) {
+    if (!(ROLES as readonly string[]).includes(role)) throw new Error(`suite.json router: thinking has an unknown role "${role}". Use ${ROLES.join(", ")}`);
+    if (!(THINKING_LEVELS as readonly unknown[]).includes(level)) throw new Error(`suite.json router: thinking.${role} must be one of ${THINKING_LEVELS.join(", ")}`);
+  }
+}
+
 /** Throws on anything it doesn't understand, so a typo can't quietly send work to the wrong model. */
 export function parseConfig(raw: unknown): SavedConfig {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("router.json must be an object");
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("suite.json router must be an object");
   for (const [role, ref] of Object.entries(raw)) {
-    if (!(ROLES as readonly string[]).includes(role)) throw new Error(`router.json: unknown role "${role}". Use ${ROLES.join(", ")}`);
-    if (typeof ref !== "string" || !/^[^/\s]+\/\S+$/.test(ref)) throw new Error(`router.json: ${role} must look like "provider/model"`);
-    if (ref.startsWith(`${VIRTUAL_PROVIDER}/`)) throw new Error(`router.json: ${role} can't be a virtual model`);
+    if (role === "thinking") {
+      parseThinking(ref);
+      continue;
+    }
+    if (!(ROLES as readonly string[]).includes(role)) throw new Error(`suite.json router: unknown role "${role}". Use ${ROLES.join(", ")}`);
+    if (typeof ref !== "string" || !/^[^/\s]+\/\S+$/.test(ref)) throw new Error(`suite.json router: ${role} must look like "provider/model"`);
+    if (ref.startsWith(`${VIRTUAL_PROVIDER}/`)) throw new Error(`suite.json router: ${role} can't be a virtual model`);
   }
   return raw as SavedConfig;
 }
@@ -43,23 +57,11 @@ export function isComplete(saved: SavedConfig): saved is RouterConfig {
   return saved.plan !== undefined && saved.build !== undefined;
 }
 
-/** An absent file is a router nobody has set up yet. A broken one throws. */
+/** Nothing there is a router nobody has set up yet. Something broken throws. */
 export function loadConfig(agentDir: string): SavedConfig {
-  let text: string;
-  try {
-    text = readFileSync(configPath(agentDir), "utf8");
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
-    throw error;
-  }
-  return parseConfig(JSON.parse(text));
+  return parseConfig(readSection(agentDir, "router"));
 }
 
 export function saveConfig(agentDir: string, saved: SavedConfig): void {
-  // A linked file, as in a dotfiles setup, stays linked.
-  const named = configPath(agentDir);
-  const path = existsSync(named) ? realpathSync(named) : named;
-  const temp = `${path}.${process.pid}.tmp`;
-  writeFileSync(temp, `${JSON.stringify(saved, null, 2)}\n`);
-  renameSync(temp, path);
+  writeSection(agentDir, "router", saved);
 }

package/packages/router/src/index.ts

@@ -1,15 +1,18 @@
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type ExtensionContext, getAgentDir } from "@earendil-works/pi-coding-agent";
 
-import { isComplete, loadConfig, parseConfig, parseRef, type Role, ROLES, type SavedConfig, saveConfig, VIRTUAL_ID, VIRTUAL_PROVIDER } from "./config.ts";
+import { isComplete, loadConfig, parseConfig, parseRef, type Role, ROLES, type SavedConfig, saveConfig, THINKING_LEVELS, type ThinkingLevel, VIRTUAL_ID, VIRTUAL_PROVIDER } from "./config.ts";
 import { judgeModel, setJudgeModel } from "./judge.ts";
 import { chooseModel, type RouterState } from "./route.ts";
 
 /** Other extensions emit these with an object, and whoever knows fills it in, whatever the load order. */
 const READER_PROBE = "pi-router:reader-model";
+const MASTERMIND_PROBE = "pi-router:mastermind-model";
 const MODE_PROBE = "pi-modes:mode";
+const SETTINGS_PROBE = "pi-suite:router-settings";
 
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 const VIRTUAL_API = "pi-virtual";
+const SELECTED_LEVEL = "same as /effort";
 
 const JUDGE = "judge";
 const JUDGE_HELP = "decides permission asks for pi-permission-classifier";
@@ -19,6 +22,7 @@ const ROLE_HELP: Record<Role, string> = {
   reader: "reads web pages for pi-web",
   subagent: "runs subagents that use this virtual model",
   fallback: "takes over when a provider is overloaded",
+  mastermind: "reviews past conversations for /mastermind, and writes rules for the other models",
 };
 
 /** What a role shows, and offers to go back to, with no model of its own. */
@@ -26,6 +30,7 @@ const UNSET: Partial<Record<Role, string>> = {
   reader: "same as build",
   subagent: "same as build",
   fallback: "none",
+  mastermind: "none",
 };
 
 function refOf(model: { provider: string; id: string } | undefined): string | undefined {
@@ -46,7 +51,15 @@ export default function piRouter(pi: ExtensionAPI): void {
 
   pi.events.on(READER_PROBE, (data) => {
     if (!isComplete(saved)) return;
-    (data as { model?: string }).model = saved.reader ?? saved.build;
+    const probe = data as { model?: string; thinking?: ThinkingLevel };
+    probe.model = saved.reader ?? saved.build;
+    probe.thinking = saved.thinking?.[saved.reader === undefined ? "build" : "reader"];
+  });
+
+  pi.events.on(MASTERMIND_PROBE, (data) => {
+    const probe = data as { model?: string; thinking?: ThinkingLevel };
+    probe.model = saved.mastermind;
+    probe.thinking = saved.thinking?.mastermind;
   });
 
   function currentMode(): string | undefined {
@@ -56,8 +69,8 @@ export default function piRouter(pi: ExtensionAPI): void {
   }
 
   function register(): void {
-    // A broken file still registers, so router/auto stops with the reason rather than Pi picking another model.
-    if (registered || (!isComplete(saved) && problem === undefined)) return;
+    // Always listed. With nothing set or a broken file it stops with the reason, rather than Pi picking another model.
+    if (registered) return;
     registered = true;
     pi.registerVirtualModel<RouterState>({
       provider: VIRTUAL_PROVIDER,
@@ -73,14 +86,14 @@ export default function piRouter(pi: ExtensionAPI): void {
           subagent: process.env.PI_SUBAGENT_CHILD === "1",
           state: request.state,
           previous: refOf(request.previous?.model),
-          failed: request.failed && { model: refOf(request.failed.model) as string, errorMessage: request.failed.message.errorMessage },
+          failed: request.failed && { model: refOf(request.failed.model) as string, errorMessage: request.failed.message.errorMessage, thinking: request.failed.thinkingLevel },
           messages: request.messages,
         });
         const { provider, id } = parseRef(choice.model);
         const model = ctx.modelRegistry.find(provider, id);
         if (model === undefined) throw new Error(`pi-router: ${choice.model} isn't a known model. Run /router`);
         if (!ctx.modelRegistry.hasConfiguredAuth(model)) throw new Error(`pi-router: no login for ${choice.model}. Run /login or /router`);
-        return { model, thinkingLevel: request.thinkingLevel, state: choice.state };
+        return { model, thinkingLevel: choice.thinking ?? request.thinkingLevel, state: choice.state };
       },
     });
   }
@@ -94,9 +107,15 @@ export default function piRouter(pi: ExtensionAPI): void {
     ctx.ui.notify("The permission judge has no model of its own, so with router/auto it can't judge and every ask comes to you. Set judge in /router.", "warning");
   }
 
+  function warnIfNotSetUp(ctx: ExtensionContext): void {
+    if (problem !== undefined || isComplete(saved) || !ctx.hasUI || refOf(ctx.model) !== `${VIRTUAL_PROVIDER}/${VIRTUAL_ID}`) return;
+    ctx.ui.notify("router/auto has no models yet. Run /router to choose plan and build.", "warning");
+  }
+
   pi.on("session_start", (_event, ctx) => {
     register();
     if (problem !== undefined && ctx.hasUI) ctx.ui.notify(problem, "error");
+    warnIfNotSetUp(ctx);
     warnAboutJudge(ctx);
   });
   // Pi keeps virtual models across a reload, so one left here would outlive this extension being turned off.
@@ -105,18 +124,45 @@ export default function piRouter(pi: ExtensionAPI): void {
     registered = false;
     pi.unregisterVirtualModel(VIRTUAL_PROVIDER, VIRTUAL_ID);
   });
-  pi.on("model_select", (_event, ctx) => warnAboutJudge(ctx));
+  pi.on("model_select", (_event, ctx) => {
+    warnIfNotSetUp(ctx);
+    warnAboutJudge(ctx);
+  });
 
   function setRole(role: Role, ref: string | undefined): void {
     // Another session may have changed it since this one read it.
     const next: SavedConfig = { ...loadConfig(agentDir) };
     if (ref === undefined) delete next[role];
     else next[role] = ref;
+    // Another model may not have the same levels, so this role's level is chosen again.
+    if (next.thinking !== undefined) {
+      const { [role]: _dropped, ...others } = next.thinking;
+      if (Object.keys(others).length > 0) next.thinking = others;
+      else delete next.thinking;
+    }
     saved = parseConfig(next);
     saveConfig(agentDir, saved);
     register();
   }
 
+  function setThinking(role: Role, level: ThinkingLevel): void {
+    const next: SavedConfig = { ...loadConfig(agentDir) };
+    next.thinking = { ...next.thinking, [role]: level };
+    saved = parseConfig(next);
+    saveConfig(agentDir, saved);
+  }
+
+  /** Offers only what the chosen model can do. A model with no levels to choose has nothing to ask. */
+  async function chooseThinking(ctx: ExtensionContext, role: Role, ref: string): Promise<void> {
+    const { provider, id } = parseRef(ref);
+    const model = ctx.modelRegistry.find(provider, id);
+    const levels = model === undefined ? [] : getSupportedThinkingLevels(model);
+    if (levels.length < 2) return;
+    const picked = await ctx.ui.select(`Reasoning for ${role} on ${ref}`, [SELECTED_LEVEL, ...levels]);
+    if (picked === undefined || picked === SELECTED_LEVEL) return;
+    setThinking(role, picked as ThinkingLevel);
+  }
+
   async function chooseJudge(ctx: ExtensionContext, models: readonly string[]): Promise<void> {
     const picked = await ctx.ui.select(`${JUDGE} ${JUDGE_HELP}`, ["not set", ...models]);
     if (picked === undefined) return;
@@ -131,7 +177,7 @@ export default function piRouter(pi: ExtensionAPI): void {
   async function chooseRoles(ctx: ExtensionContext): Promise<void> {
     if (problem !== undefined) {
       // Saving over it would throw away whatever the file held.
-      ctx.ui.notify(`${problem}. Fix or delete ~/.pi/agent/router.json, then /reload.`, "error");
+      ctx.ui.notify(`${problem}. Fix the router section of ~/.pi/agent/suite.json, then /reload.`, "error");
       return;
     }
     const models = ctx.modelRegistry.getAvailable().filter((model) => model.api !== VIRTUAL_API).map((model) => `${model.provider}/${model.id}`);
@@ -141,7 +187,11 @@ export default function piRouter(pi: ExtensionAPI): void {
     }
     for (;;) {
       const judge = judgeModel(agentDir);
-      const rows = [...ROLES.map((role) => `${role}: ${saved[role] ?? UNSET[role] ?? "not set"}`), `${JUDGE}: ${judge ?? (judge === null ? "not set" : "not installed")}`];
+      const shown = (role: Role): string => {
+        const level = saved.thinking?.[role];
+        return `${saved[role] ?? UNSET[role] ?? "not set"}${saved[role] !== undefined && level !== undefined ? ` · ${level}` : ""}`;
+      };
+      const rows = [...ROLES.map((role) => `${role}: ${shown(role)}`), `${JUDGE}: ${judge ?? (judge === null ? "not set" : "not installed")}`];
       const row = await ctx.ui.select("Router: which role? (Esc when done)", rows);
       if (row === undefined) break;
       const role = ROLES[rows.indexOf(row)];
@@ -153,15 +203,22 @@ export default function piRouter(pi: ExtensionAPI): void {
       const picked = await ctx.ui.select(`${role} ${ROLE_HELP[role]}`, [...(unset === undefined ? [] : [unset]), ...models]);
       if (picked === undefined) continue;
       try {
-        setRole(role, picked === unset ? undefined : picked);
+        const ref = picked === unset ? undefined : picked;
+        setRole(role, ref);
+        if (ref !== undefined) await chooseThinking(ctx, role, ref);
       } catch (error) {
         ctx.ui.notify((error as Error).message, "error");
       }
     }
-    if (isComplete(saved)) ctx.ui.notify(`Choose ${VIRTUAL_PROVIDER}/${VIRTUAL_ID} in /model to use these.`, "info");
-    else ctx.ui.notify("The router needs both plan and build before router/auto appears.", "warning");
+    if (!isComplete(saved)) ctx.ui.notify("router/auto needs both plan and build before it can answer.", "warning");
+    else if (refOf(ctx.model) !== `${VIRTUAL_PROVIDER}/${VIRTUAL_ID}`) ctx.ui.notify(`Choose ${VIRTUAL_PROVIDER}/${VIRTUAL_ID} in /model to use these.`, "info");
   }
 
+  // /suite opens this screen too, without knowing how it works.
+  pi.events.on(SETTINGS_PROBE, (data) => {
+    (data as { open?: (ctx: ExtensionContext) => Promise<void> }).open = chooseRoles;
+  });
+
   pi.registerCommand("router", {
     description: "Choose which model does what for router/auto",
     handler: async (_args, ctx) => {

package/packages/router/src/route.ts

@@ -1,5 +1,5 @@
 // Which real model answers a request. Pure, so every rule can be tested without Pi.
-import type { RouterConfig } from "./config.ts";
+import type { Role, RouterConfig, ThinkingLevel } from "./config.ts";
 
 export interface RouterState {
   phase: "plan" | "build";
@@ -15,12 +15,14 @@ export interface RouteInput {
   subagent: boolean;
   state: RouterState | undefined;
   previous: string | undefined;
-  failed: { model: string; errorMessage: string | undefined } | undefined;
+  failed: { model: string; errorMessage: string | undefined; thinking?: ThinkingLevel } | undefined;
   messages: readonly { role: string; toolName?: string; isError?: boolean }[];
 }
 
 export interface RouteChoice {
   model: string;
+  /** Only when the role has its own. Otherwise the level selected with /effort applies. */
+  thinking?: ThinkingLevel;
   /** Only when it changed, because Pi stores every new object it gets. */
   state?: RouterState;
 }
@@ -42,9 +44,13 @@ function nextState(input: RouteInput): RouterState {
 }
 
 export function chooseModel(config: RouterConfig, input: RouteInput): RouteChoice {
-  const home = input.subagent ? (config.subagent ?? config.build) : config.build;
+  const forRole = (role: Role, model: string): Pick<RouteChoice, "model" | "thinking"> => {
+    const thinking = config.thinking?.[role];
+    return thinking === undefined ? { model } : { model, thinking };
+  };
+  const home = input.subagent && config.subagent !== undefined ? forRole("subagent", config.subagent) : forRole("build", config.build);
   // Compaction summaries, and any other extension's call that names the virtual model.
-  if (input.reason === "direct") return { model: home };
+  if (input.reason === "direct") return home;
 
   // Worked out first, so an edit made on the fallback or during a retry still counts.
   const state = input.subagent ? input.state : nextState(input);
@@ -52,16 +58,16 @@ export function chooseModel(config: RouterConfig, input: RouteInput): RouteChoic
 
   if (input.reason === "retry" && input.failed) {
     const overloaded = OVERLOADED.test(input.failed.errorMessage ?? "");
-    const moves = overloaded && config.fallback !== undefined && config.fallback !== input.failed.model;
-    return { model: moves ? (config.fallback as string) : input.failed.model, ...changed };
+    if (overloaded && config.fallback !== undefined && config.fallback !== input.failed.model) return { ...forRole("fallback", config.fallback), ...changed };
+    return { model: input.failed.model, ...(input.failed.thinking === undefined ? {} : { thinking: input.failed.thinking }), ...changed };
   }
 
   // Back on the first choice at the next message, not on every tool call in between.
   if (input.reason === "continuation" && input.previous !== undefined && input.previous === config.fallback) {
-    return { model: input.previous, ...changed };
+    return { ...forRole("fallback", input.previous), ...changed };
   }
 
-  if (input.subagent) return { model: home };
-  const model = input.mode === "plan" || state?.phase === "plan" ? config.plan : config.build;
-  return { model, ...changed };
+  if (input.subagent) return home;
+  const choice = input.mode === "plan" || state?.phase === "plan" ? forRole("plan", config.plan) : forRole("build", config.build);
+  return { ...choice, ...changed };
 }

package/packages/subagent/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hüseyin Sönmez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/subagent/README.md

@@ -0,0 +1,17 @@
+# pi-subagent
+
+Part of [pi-suite](../../README.md). Turn it off with `/suite off subagent`.
+
+One tool, `agent`, that hands a task to a fresh copy of Pi and gives back its final answer as text. Wide searches, heavy reading and independent reviews happen in their context rather than yours. There's nothing to set up, and no agents to define.
+
+| `type` | What it can do |
+| --- | --- |
+| `explore` (the default) | Only `read`, `grep`, `find` and `ls`. Also allowed in `plan` and `read-only` |
+| `general` | Everything, under your permission rules. Blocked in `plan` and `read-only` |
+
+- **Parallel:** several calls in one message run at once.
+- **Model:** it uses the session's model and reasoning. With `router/auto`, that's the `subagent` role in `/router`, so a cheaper model can do the reading.
+- **Permissions:** a child's asks come to your session, and `auto` carries over to it.
+- **Limits:** a child can't start its own agents, its answer is cut at 30,000 characters, it isn't saved as a session, and it starts as fast as Pi does. For long work in the background, use [pi-board](../board/README.md).
+
+If you have `pi-subagents` installed, remove it, or the model has two tools for the same job.

package/packages/subagent/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@huseynsnmz/pi-subagent",
+  "version": "0.1.0",
+  "description": "One simple tool for handing a task to a fresh agent.",
+  "type": "module",
+  "license": "MIT",
+  "private": true,
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "node --test test/*.test.ts"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.5.0",
+    "@types/node": "26.6.6",
+    "typescript": "7.0.2",
+    "typebox": "1.4.3"
+  }
+}