@sayansr26/agent-os 0.5.3 → 0.6.1

package/plugins/agent-os/skills/init/scripts/settings.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * agent-os settings — write the permission and task-tool setup, not describe it.
+ *
+ * Three things, at project scope, user scope, or both:
+ *
+ *   settings.json  permissions.deny  += the git write-protection rules
+ *                  env.CLAUDE_CODE_ENABLE_TODO_TOOLS = "1"
+ *   CLAUDE.md      the task-tracking rule
+ *
+ * Merges, never replaces: existing keys, allow rules, deny rules and a value
+ * the user set for the env flag all survive. Idempotent. Before changing a
+ * file under ~/.claude it copies it to `<file>.agent-os.bak`; project files
+ * are left to git, so a backup does not show up as an untracked file.
+ *
+ * Previews by default. `--apply` writes. The preview is what /agent-os:init
+ * shows the user before asking once; the CLI's `init` asks the same question.
+ *
+ * Usage: node settings.mjs [--root <dir>] [--scope project|user|both] [--apply]
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const TODO_ENV = "CLAUDE_CODE_ENABLE_TODO_TOOLS";
+
+export const TASK_RULE = `- **Always track work with the task tool (TaskCreate / TaskUpdate).** Any request
+  with more than one step gets a task list before work starts: one task per
+  deliverable, marked \`in_progress\` when started and \`completed\` only when
+  verified. Keep it current as scope changes, including work delegated to
+  subagents, so I can see what is done, running and left at any moment.`;
+
+/**
+ * Every git command that changes the repository. Read-only inspection
+ * (status, log, diff, show, blame, …) stays available. The first five close
+ * the flag forms that would otherwise walk past a per-subcommand rule —
+ * references/git-permissions.md explains each judgment call.
+ */
+export const GIT_DENY = [
+  "Bash(git -C*)", "Bash(git -c*)", "Bash(git --git-dir*)", "Bash(git --work-tree*)", "Bash(git --exec-path*)",
+  "Bash(git add *)", "Bash(git am *)", "Bash(git apply *)", "Bash(git bisect *)", "Bash(git branch *)",
+  "Bash(git checkout *)", "Bash(git cherry-pick *)", "Bash(git clean *)", "Bash(git clone *)", "Bash(git commit *)",
+  "Bash(git config *)", "Bash(git fast-import *)", "Bash(git filter-branch *)", "Bash(git gc *)", "Bash(git init *)",
+  "Bash(git merge *)", "Bash(git mv *)", "Bash(git notes *)", "Bash(git prune *)", "Bash(git pull *)",
+  "Bash(git push *)", "Bash(git rebase *)", "Bash(git reflog *)", "Bash(git remote *)", "Bash(git repack *)",
+  "Bash(git replace *)", "Bash(git reset *)", "Bash(git restore *)", "Bash(git revert *)", "Bash(git rm *)",
+  "Bash(git stash *)", "Bash(git submodule *)", "Bash(git switch *)", "Bash(git symbolic-ref *)", "Bash(git tag *)",
+  "Bash(git update-ref *)", "Bash(git worktree *)",
+];
+
+export const userDir = () => process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+
+export function paths(scope, root) {
+  return scope === "user"
+    ? { settings: join(userDir(), "settings.json"), claudeMd: join(userDir(), "CLAUDE.md"), label: "USER (~/.claude)" }
+    : { settings: join(root, ".claude/settings.json"), claudeMd: join(root, "CLAUDE.md"), label: "PROJECT" };
+}
+
+const put = (p, text, keep) => {
+  if (keep && existsSync(p)) copyFileSync(p, `${p}.agent-os.bak`);
+  mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, text); };
+
+// "Bash(git commit *)" and "Bash(git commit:*)" are the same rule to Claude Code.
+const norm = (r) => r.replace(/:\*\)$/, " *)").replace(/\s+/g, " ");
+
+/**
+ * Merge the deny rules and the env flag into one settings.json.
+ * Returns { status: "changed"|"unchanged"|"invalid", file, denyAdded, env, current }
+ * where env is "added" | "present" | "conflict".
+ */
+export function mergeSettings(file, { dry = false, deny = GIT_DENY, todo = true, keep = false } = {}) {
+  let settings = {};
+  if (existsSync(file)) {
+    try { settings = JSON.parse(readFileSync(file, "utf8")); }
+    catch { return { status: "invalid", file, denyAdded: [], env: null }; }
+  }
+  const perms = settings.permissions || {};
+  const have = new Set((perms.deny || []).map(norm));
+  const denyAdded = deny.filter((r) => !have.has(norm(r)));
+
+  let env = null, current;
+  if (todo) {
+    current = (settings.env || {})[TODO_ENV];
+    // "true" and "1" are both truthy to Claude Code; an existing value is the
+    // user's choice and is left alone rather than normalised.
+    if (current === undefined) env = "added";
+    else env = current === "1" || current === "true" || current === true ? "present" : "conflict";
+  }
+
+  if (!denyAdded.length && env !== "added") return { status: "unchanged", file, denyAdded, env, current };
+
+  if (denyAdded.length) settings.permissions = { ...perms, deny: [...(perms.deny || []), ...denyAdded] };
+  if (env === "added") settings.env = { ...(settings.env || {}), [TODO_ENV]: "1" };
+  if (!dry) put(file, JSON.stringify(settings, null, 2) + "\n", keep);
+  return { status: "changed", file, denyAdded, env, current };
+}
+
+/**
+ * Put the task-tracking rule in a CLAUDE.md. Returns "added" | "present" | "no-file".
+ * A project CLAUDE.md is never created — that is the project's own
+ * always-loaded context, and a CLI inventing one leaves a stub nobody owns.
+ * The user's ~/.claude/CLAUDE.md is created when `create` is set.
+ */
+export function addTaskRule(file, { dry = false, create = false, keep = false } = {}) {
+  if (!existsSync(file)) {
+    if (!create) return { status: "no-file", file };
+    if (!dry) put(file, `# Personal working agreement\n\n${TASK_RULE}\n`);
+    return { status: "added", file, section: "new file" };
+  }
+  const text = readFileSync(file, "utf8");
+  if (/TaskCreate/.test(text)) return { status: "present", file };
+
+  // Prefer an operator-preferences section so the rule lands with the other
+  // instructions about how to work rather than orphaned at the bottom.
+  const heading = text.match(/^##\s+Operator preferences\s*$/m);
+  let next;
+  if (heading) {
+    const start = heading.index + heading[0].length;
+    const rest = text.slice(start);
+    const nextHeading = rest.search(/^##\s+/m);
+    const end = nextHeading === -1 ? text.length : start + nextHeading;
+    next = `${text.slice(0, end).replace(/\s*$/, "")}\n\n${TASK_RULE}\n\n${text.slice(end)}`;
+  } else {
+    next = `${text.replace(/\s*$/, "")}\n\n## Working agreement\n\n${TASK_RULE}\n`;
+  }
+  if (!dry) put(file, next.replace(/\n{4,}/g, "\n\n\n"), keep);
+  return { status: "added", file, section: heading ? "Operator preferences" : "Working agreement" };
+}
+
+/** Everything for one scope. */
+export function applyScope(scope, root, { dry = false } = {}) {
+  const p = paths(scope, root);
+  return {
+    scope,
+    label: p.label,
+    settings: mergeSettings(p.settings, { dry, keep: scope === "user" }),
+    rule: addTaskRule(p.claudeMd, { dry, create: scope === "user", keep: scope === "user" }),
+  };
+}
+
+export function describe(r, { dry }) {
+  const s = r.settings, lines = [];
+  const verb = dry ? "would add" : "added";
+  lines.push(`${r.label}  ${s.file}`);
+  if (s.status === "invalid") lines.push("  not valid JSON — left alone; fix it and re-run");
+  else {
+    lines.push(s.denyAdded.length
+      ? `  permissions.deny   ${verb} ${s.denyAdded.length} git write rule(s)${s.denyAdded.length < GIT_DENY.length ? ` (${GIT_DENY.length - s.denyAdded.length} already there)` : ""}`
+      : `  permissions.deny   git write protection already complete`);
+    lines.push({
+      added: `  env.${TODO_ENV}  ${verb} "1"`,
+      present: `  env.${TODO_ENV}  already on`,
+      conflict: `  env.${TODO_ENV}  is "${s.current}" — left as set`,
+    }[s.env]);
+    if (s.status === "changed" && !dry && r.scope === "user" && existsSync(`${s.file}.agent-os.bak`)) lines.push(`  backup             ${s.file}.agent-os.bak`);
+  }
+  lines.push({
+    added: `  ${r.rule.file}  ${dry ? "would add" : "added"} the task-tracking rule (${r.rule.section})`,
+    present: `  ${r.rule.file}  task-tracking rule already there`,
+    "no-file": `  ${r.rule.file}  absent — /agent-os:init builds it`,
+  }[r.rule.status]);
+  return lines;
+}
+
+function main(argv) {
+  const arg = (k, d) => { const i = argv.indexOf(k); return i === -1 ? d : argv[i + 1]; };
+  const root = arg("--root", process.cwd());
+  const scope = arg("--scope", "both");
+  const dry = !argv.includes("--apply");
+  const scopes = scope === "both" ? ["project", "user"] : [scope];
+  if (!scopes.every((s) => s === "project" || s === "user")) {
+    console.error(`--scope must be project, user or both (got "${scope}")`);
+    process.exit(2);
+  }
+  const out = [`AGENT-OS SETTINGS  ${dry ? "preview — nothing written; re-run with --apply" : "applied"}`, ""];
+  for (const s of scopes) out.push(...describe(applyScope(s, root, { dry }), { dry }), "");
+  if (scopes.includes("user")) out.push("~/.claude applies to every project on this machine.");
+  process.stdout.write(out.join("\n") + "\n");
+}
+
+const isMain = () => {
+  try { return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url)); }
+  catch { return false; }
+};
+if (process.argv[1] && isMain()) main(process.argv.slice(2));

package/plugins/agent-os/skills/init/scripts/state.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * agent-os setup state — is this a fresh setup, a repair, or already healthy?
+ *
+ * Both `npx agent-os init` and `/agent-os:init` start here, so neither
+ * re-scaffolds a project that is set up, and both name exactly what a repair
+ * has to touch. Read-only: every check is a file read, and the settings checks
+ * are dry runs of what settings.mjs would write.
+ *
+ * The plugin check reads Claude Code's own records (installed_plugins.json,
+ * enabledPlugins, the marketplace cache) instead of calling the `claude` CLI,
+ * so it also works from inside a session.
+ *
+ * Usage: node state.mjs [projectDir]
+ */
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { addTaskRule, GIT_DENY, mergeSettings, paths, userDir } from "./settings.mjs";
+
+export const PLUGIN_ID = "agent-os@sayan-plugins";
+export const MARKETPLACE_NAME = "sayan-plugins";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const readJson = (p) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; } };
+const real = (p) => { try { return realpathSync(p); } catch { return p; } };
+
+/** -1, 0, 1 for dotted numeric versions; unknown sorts lowest. */
+export function cmpVersion(a, b) {
+  const pa = String(a || "0").split(/[.-]/).map((n) => parseInt(n, 10) || 0);
+  const pb = String(b || "0").split(/[.-]/).map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+/** The version of the plugin this script ships in. */
+export const bundledVersion = () => readJson(join(HERE, "../../../.claude-plugin/plugin.json"))?.version || null;
+
+/**
+ * What Claude Code has installed for this project.
+ * { installed, scope, version, enabled, latest } — latest is the version in the
+ * local marketplace cache, which is only as new as the last marketplace update.
+ */
+export function pluginState(root) {
+  const home = userDir();
+  const rootReal = real(root);
+  const records = readJson(join(home, "plugins/installed_plugins.json"))?.plugins?.[PLUGIN_ID] || [];
+  // Project and local installs belong to one directory; user installs to all.
+  const mine = records.filter((r) => r.scope === "user" || (r.projectPath && real(r.projectPath) === rootReal));
+  const pick = mine.find((r) => r.scope === "project" || r.scope === "local") || mine[0] || null;
+
+  const enabledIn = [
+    join(root, ".claude/settings.local.json"),
+    join(root, ".claude/settings.json"),
+    join(home, "settings.json"),
+  ].map((p) => readJson(p)?.enabledPlugins?.[PLUGIN_ID]).find((v) => v !== undefined);
+
+  const latest = readJson(join(home, "plugins/marketplaces", MARKETPLACE_NAME, "plugins/agent-os/.claude-plugin/plugin.json"))?.version || null;
+  return {
+    installed: !!pick,
+    scope: pick?.scope || null,
+    version: pick?.version || null,
+    enabled: pick ? enabledIn !== false : false,
+    latest,
+  };
+}
+
+/**
+ * Every check, then the verdict:
+ *   fresh    nothing of agent-os is here yet — run the whole setup
+ *   repair   some of it is — fix only the items marked missing
+ *   healthy  all of it is
+ * `expect` is the plugin version the caller wants at minimum (the CLI passes
+ * the version it bundles).
+ */
+export function setupState(root, { expect = bundledVersion() } = {}) {
+  const items = [];
+  const add = (key, label, ok, fix) => items.push({ key, label, ok, fix });
+
+  const hasSource = existsSync(join(root, ".agent-os/config.json"));
+  const claudeMd = (() => { try { return readFileSync(join(root, "CLAUDE.md"), "utf8"); } catch { return null; } })();
+  const hasMemory = existsSync(join(root, ".claude/agent-memory"));
+
+  add("source", ".agent-os/ source", hasSource, "npx @sayansr26/agent-os init");
+  add("claude-md", "CLAUDE.md", claudeMd !== null, "/init in Claude Code, then /agent-os:init");
+
+  for (const scope of ["project", "user"]) {
+    const p = paths(scope, root);
+    const s = mergeSettings(p.settings, { dry: true });
+    const where = scope === "user" ? "~/.claude/settings.json" : ".claude/settings.json";
+    if (s.status === "invalid") { add(`${scope}-settings`, `${where} is valid JSON`, false, `fix ${where} by hand`); continue; }
+    const have = GIT_DENY.length - s.denyAdded.length;
+    add(`${scope}-git`, `${where} git write protection (${have}/${GIT_DENY.length})`, !s.denyAdded.length, `agent-os settings --scope ${scope} --apply`);
+    add(`${scope}-todo`, `${where} task tools`, s.env !== "added", `agent-os settings --scope ${scope} --apply`);
+  }
+  if (claudeMd !== null) {
+    add("task-rule", "CLAUDE.md task-tracking rule", addTaskRule(join(root, "CLAUDE.md"), { dry: true }).status === "present", "agent-os settings --scope project --apply");
+    add("agents-section", "CLAUDE.md says when to use each agent", /agent-os:(feature-cartographer|builder|reviewer)/.test(claudeMd), "/agent-os:init (establishing.md, Step 4b)");
+  }
+
+  const pl = pluginState(root);
+  const want = [expect, pl.latest].filter(Boolean).sort((a, b) => cmpVersion(b, a))[0] || null;
+  add("plugin", "Claude Code plugin installed", pl.installed, "npx @sayansr26/agent-os init");
+  if (pl.installed) {
+    add("plugin-enabled", "plugin enabled", pl.enabled, `claude plugin enable ${PLUGIN_ID}`);
+    add("plugin-version", `plugin version ${pl.version}${want && cmpVersion(pl.version, want) < 0 ? ` (latest ${want})` : ""}`,
+      !want || cmpVersion(pl.version, want) >= 0, "npx @sayansr26/agent-os init  (or /plugin update, then /reload-plugins)");
+  }
+
+  // Settings alone do not count: deny rules may be the user's own.
+  const anything = hasSource || hasMemory || pl.installed || /agent-os/.test(claudeMd || "");
+  const missing = items.filter((i) => !i.ok);
+  const status = !anything ? "fresh" : missing.length ? "repair" : "healthy";
+  return { status, items, missing, plugin: pl };
+}
+
+export function describeState(st) {
+  const lines = [`SETUP  ${st.status.toUpperCase()}${st.status === "repair" ? `  — ${st.missing.length} item(s) to fix` : ""}`];
+  for (const i of st.items) lines.push(`  ${i.ok ? "ok     " : "MISSING"} ${i.label}${i.ok ? "" : `  → ${i.fix}`}`);
+  return lines;
+}
+
+const isMain = () => {
+  try { return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url)); }
+  catch { return false; }
+};
+if (process.argv[1] && isMain()) {
+  const root = process.argv[2] || process.cwd();
+  process.stdout.write(describeState(setupState(root)).join("\n") + "\n");
+}

package/plugins/auto-route/.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "auto-route",
+  "version": "0.1.0",
+  "description": "Picks the model and effort level for each turn from what the prompt asks for",
+  "types": "./types/index.d.ts",
+  "author": {
+    "name": "Sayan Choudhury",
+    "email": "sayan.choudhury.in@gmail.com"
+  },
+  "homepage": "https://github.com/sayansr26/agent-os",
+  "repository": "https://github.com/sayansr26/agent-os",
+  "license": "MIT",
+  "keywords": [
+    "model-routing",
+    "effort",
+    "mod"
+  ]
+}

package/plugins/auto-route/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.ts"] }

package/plugins/auto-route/hooks/register.ts

@@ -0,0 +1,143 @@
+import { atom, read, update } from 'claude-code'
+import type { ModelEffort, Register } from 'claude-code'
+
+import type { Mode, Route, Tier } from '../types'
+
+// Edit this table to change what each tier runs on.
+const TIERS: Record<Tier, { model: string; effort: ModelEffort }> = {
+  light: { model: 'claude-haiku-5-5', effort: 'low' },
+  standard: { model: 'claude-sonnet-5-5', effort: 'medium' },
+  deep: { model: 'claude-opus-5-5', effort: 'high' },
+  max: { model: 'claude-opus-5-5', effort: 'max' },
+}
+
+// Checked top to bottom; the first tier whose pattern matches wins.
+const RULES: { tier: Tier; reason: string; pattern: RegExp }[] = [
+  {
+    tier: 'max',
+    reason: 'asked to think hard',
+    pattern: /\b(ultrathink|think (really )?hard|think harder|deep dive)\b/i,
+  },
+  {
+    tier: 'max',
+    reason: 'security or concurrency',
+    pattern:
+      /\b(security (audit|review)|vulnerabilit|race condition|deadlock|memory leak|incident|data loss)/i,
+  },
+  {
+    tier: 'deep',
+    reason: 'design or debugging',
+    pattern:
+      /\b(architect|design|refactor|migrat|debug|root cause|investigate|why (is|does|doesn't|isn't)|plan|implement|build (a|the|an)|new feature|end[- ]to[- ]end|across|whole (repo|codebase|app)|optimi[sz]e|performance|review)/i,
+  },
+  {
+    tier: 'light',
+    reason: 'small or lookup task',
+    pattern:
+      /^(what|which|where|who|when|is|are|does|do|can|show|list|print|explain briefly|rename|fix (the )?typo|format|lint|bump|commit message|thanks|thank you|ok|yes|no)\b/i,
+  },
+]
+
+export const classify = (text: string): Route => {
+  const words = text.trim().split(/\s+/).filter(Boolean).length
+  const rule = RULES.find(one => one.pattern.test(text))
+
+  if (rule && !(rule.tier === 'light' && words > 40)) {
+    return { tier: rule.tier, reason: rule.reason }
+  }
+
+  if (words > 150) {
+    return { tier: 'deep', reason: 'long, detailed prompt' }
+  }
+
+  return words <= 8
+    ? { tier: 'light', reason: 'short prompt' }
+    : { tier: 'standard', reason: 'regular coding task' }
+}
+
+const MODES: readonly Mode[] = ['auto', 'off', 'light', 'standard', 'deep', 'max']
+
+const mode = atom({ plugin: 'auto-route', key: 'mode' } as const, 'auto')
+const route = atom({ plugin: 'auto-route', key: 'route' } as const, null)
+
+const describe = (current: Mode, last: Route | null) => {
+  if (current === 'off') {
+    return 'auto-route: off'
+  }
+
+  const pinned = current === 'auto' ? '' : ' (pinned)'
+  const tier = current === 'auto' ? last?.tier : current
+
+  if (!tier) {
+    return 'auto-route: waiting for a prompt'
+  }
+
+  const { model, effort } = TIERS[tier]
+
+  return `auto-route: ${tier}${pinned} · ${model.replace(/^claude-/, '')} / ${effort}`
+}
+
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    await $.command.register({
+      name: 'route',
+      description: 'Auto model routing: auto, off, or pin light | standard | deep | max',
+    })
+
+    return next(e)
+  })
+
+  on('command.run', { command: 'route' }, async ($, e) => {
+    const asked = e.args.trim().toLowerCase()
+
+    if (asked !== '') {
+      const next = MODES.find(one => one === asked)
+
+      if (!next) {
+        return { text: `auto-route: unknown mode "${asked}". Use ${MODES.join(', ')}.` }
+      }
+
+      await update($, mode, () => next)
+    }
+
+    const text = describe(await read($, mode), await read($, route))
+    $.ui.status(text)
+
+    return { text: text.replace(/^auto-route: /, '') }
+  })
+
+  on('prompt.submit', async ($, e, next) => {
+    // A prompt delivered into a running turn keeps that turn's route.
+    const current = await read($, mode)
+    const isRouted = e.turnId === undefined && !e.command && current === 'auto'
+    $.ui.log(`auto-route: prompt.submit mode=${current} turnId=${e.turnId ?? '-'} command=${e.command ? 'yes' : 'no'} routed=${isRouted}`)
+
+    if (isRouted) {
+      const picked = classify(e.text)
+      await update($, route, () => picked)
+      $.ui.status(describe('auto', picked))
+    }
+
+    return next(e)
+  }).catch(($, e, next) => {
+    $.ui.log('auto-route: prompt.submit hook failed')
+
+    return next(e)
+  })
+
+  on('turn.step', async function* ($, e, next) {
+    const current = await read($, mode)
+    const last = await read($, route)
+    const tier = current === 'auto' ? last?.tier : current === 'off' ? undefined : current
+
+    // Subagents choose their own model; leave their requests alone.
+    if (e.agentId !== undefined || !tier) {
+      return yield* next(e)
+    }
+
+    const { model, effort } = TIERS[tier]
+    $.ui.log(`auto-route: turn.step ${e.model}/${e.effort ?? '-'} -> ${model}/${effort}`)
+
+    return yield* next({ ...e, model, effort })
+  })
+}

package/plugins/auto-route/tests/route.test.ts

@@ -0,0 +1,87 @@
+import { expect, test } from 'claude-code/testing'
+import type { HookStream, TurnStepChunk, TurnStepInput, TurnStepResult } from 'claude-code'
+
+import { classify } from '../hooks/register'
+
+const STEP: TurnStepInput = {
+  turnId: 't1',
+  index: 0,
+  model: 'claude-opus-5-5',
+  effort: 'high',
+  messageCount: 1,
+}
+
+const ORIGIN = { kind: 'composer' } as const
+
+const prompt = (text: string) => ({ text, wait: false, origin: ORIGIN })
+
+const route = (args: string) => ({
+  command: 'route',
+  args,
+  origin: ORIGIN,
+  presentation: { isFullscreen: false, columns: 120 },
+})
+
+// Reads the request's stream to its end, as the engine would.
+type Steps = { turn: { step: (e: TurnStepInput) => HookStream<TurnStepChunk, TurnStepResult> } }
+
+const step = async ($: Steps, e: TurnStepInput) => {
+  const stream = $.turn.step(e)
+  for await (const _ of stream) {
+  }
+  return stream.result
+}
+
+test('prompts land in the expected tier', async () => {
+  expect(classify('what does this function return?').tier).toBe('light')
+  expect(classify('ok').tier).toBe('light')
+  expect(
+    classify('add a loading spinner to the submit button on the ask form and disable it while saving').tier,
+  ).toBe('standard')
+  expect(classify('refactor the fix ranking so it weighs environment matches').tier).toBe('deep')
+  expect(classify('debug why the MCP search is slow').tier).toBe('deep')
+  expect(classify('ultrathink about the verification model').tier).toBe('max')
+  expect(classify('is there a race condition in the release watcher?').tier).toBe('max')
+})
+
+test('the routed model and effort reach the request, subagents untouched', async ($, on) => {
+  const sent: TurnStepInput[] = []
+  on('ui.status', () => ({ value: undefined }))
+  on('prompt.submit', (_, e) => ({ text: e.text }))
+  on('turn.step', async function* (_, e) {
+    sent.push(e)
+    return { turnId: e.turnId, index: e.index, answer: '', toolUses: [], stopReason: 'end_turn', usage: null }
+  })
+
+  await $.prompt.submit(prompt('what is in package.json?'))
+  await step($, STEP)
+  await step($, { ...STEP, agentId: 'a1' })
+
+  expect(sent[0]?.model).toBe('claude-haiku-5-5')
+  expect(sent[0]?.effort).toBe('low')
+  expect(sent[1]?.model).toBe('claude-opus-5-5')
+  expect(sent[1]?.effort).toBe('high')
+})
+
+test('/route pins a tier and off stops routing', async ($, on) => {
+  const sent: TurnStepInput[] = []
+  on('command.register', () => ({ value: { command: 'route' } }))
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  on('ui.status', () => ({ value: undefined }))
+  on('prompt.submit', (_, e) => ({ text: e.text }))
+  on('turn.step', async function* (_, e) {
+    sent.push(e)
+    return { turnId: e.turnId, index: e.index, answer: '', toolUses: [], stopReason: 'end_turn', usage: null }
+  })
+
+  await $.session.start({ cwd: '/', surface: 'terminal', isInteractive: true })
+  await $.command.run(route('max'))
+  await $.prompt.submit(prompt('ok'))
+  await step($, STEP)
+  expect(sent[0]?.effort).toBe('max')
+
+  await $.command.run(route('off'))
+  await step($, { ...STEP, model: 'claude-sonnet-5-5', effort: 'medium' })
+  expect(sent[1]?.model).toBe('claude-sonnet-5-5')
+  expect(sent[1]?.effort).toBe('medium')
+})

package/plugins/auto-route/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.claude-plugin/types/tsconfig.json"
+}

package/plugins/auto-route/types/index.d.ts

@@ -0,0 +1,12 @@
+export type Tier = 'light' | 'standard' | 'deep' | 'max'
+
+// 'auto' classifies each prompt; a tier pins it; 'off' leaves the session's own.
+export type Mode = 'auto' | 'off' | Tier
+
+export type Route = { tier: Tier; reason: string }
+
+declare module 'claude-code' {
+  interface PluginState {
+    'auto-route': { mode: Mode; route: Route | null }
+  }
+}