@hizliemre/horse-code 0.2.0 → 0.3.1

package/dist/{chunk-7JMWPTJ5.js → chunk-27F44PBD.js}

@@ -5,9 +5,20 @@ import {
   readCheckpoint
 } from "./chunk-ZSQ24YDJ.js";
 import {
+  RoleRegistry,
+  applySkills,
+  buildSkillTool,
+  cliFor,
+  cliInvocation,
+  grokEffort,
+  placedSkills,
   planFor,
   runTraces
-} from "./chunk-MRZVA5JB.js";
+} from "./chunk-YULQ4URQ.js";
+import {
+  SYNTHETIC,
+  runCliAgent
+} from "./chunk-G45RWL7S.js";
 import {
   defaultGitRunner,
   gitVerb
@@ -23,15 +34,17 @@ import {
   readFileTool,
   reinforceTouched,
   reinforceUsed
-} from "./chunk-LLL7QWXB.js";
+} from "./chunk-BFIZMM4G.js";
 import {
   ToolRegistry,
+  runStructuredRole
+} from "./chunk-CYLPQWIF.js";
+import {
   handedOver,
-  runStructuredRole,
   runToCompletion,
   telemetry,
   truncateSafe
-} from "./chunk-AE36LLL2.js";
+} from "./chunk-JLWQCA7B.js";
 import {
   loadTraceIndex,
   pruneTraces,
@@ -39,291 +52,16 @@ import {
   sharedDerived,
   traceRootRel,
   traceable
-} from "./chunk-KAGKX2YT.js";
+} from "./chunk-ZPJP2VH5.js";
 import {
   buildProjectGraph,
   loadGraphSync,
   pruneAreaNames
-} from "./chunk-XEGQT5EN.js";
+} from "./chunk-4M6LXNG2.js";
 import {
   writableStateRoot
 } from "./chunk-6W4UH2BQ.js";
 
-// src/agents/cli-auth.ts
-import { spawnSync } from "child_process";
-function profileEnv(kind, configDir) {
-  if (!configDir) return {};
-  return kind === "claude" ? { CLAUDE_CONFIG_DIR: configDir } : { CODEX_HOME: configDir };
-}
-function readAuthStatus(kind, out) {
-  if (kind === "codex") {
-    const m = /logged in(?: using (.+))?/i.exec(out);
-    if (!m || /not logged in/i.test(out)) return { loggedIn: false };
-    const plan = m[1]?.trim();
-    return { loggedIn: true, ...plan ? { plan } : {} };
-  }
-  try {
-    const j = JSON.parse(out);
-    if (!j.loggedIn) return { loggedIn: false };
-    return {
-      loggedIn: true,
-      ...j.email ? { email: j.email } : {},
-      ...j.subscriptionType ? { plan: j.subscriptionType } : {}
-    };
-  } catch {
-    return { loggedIn: false };
-  }
-}
-function statusArgs(kind) {
-  return kind === "claude" ? ["auth", "status"] : ["login", "status"];
-}
-function loginArgs(kind) {
-  return kind === "claude" ? ["auth", "login"] : ["login"];
-}
-function checkProfile(kind, configDir) {
-  const r = spawnSync(kind, statusArgs(kind), {
-    env: { ...process.env, ...profileEnv(kind, configDir) },
-    encoding: "utf8",
-    // A status check that hangs must not hang the startup summary with it.
-    timeout: 2e4
-  });
-  if (r.error) return { loggedIn: false };
-  return readAuthStatus(kind, `${r.stdout ?? ""}${r.stderr ?? ""}`);
-}
-function runLogin(kind, configDir) {
-  const r = spawnSync(kind, loginArgs(kind), {
-    env: { ...process.env, ...profileEnv(kind, configDir) },
-    stdio: "inherit"
-  });
-  if (r.error) {
-    const e = r.error;
-    return e.code === "ENOENT" ? { ok: false, error: `\`${kind}\` is not installed, or not on PATH` } : { ok: false, error: e.message };
-  }
-  return { ok: r.status === 0 };
-}
-
-// src/agents/cli-models.ts
-var CLAUDE_MODELS = ["fable", "opus", "sonnet", "haiku"];
-var CODEX_MODELS = ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.6-luna"];
-var CODEX_DEFAULT = "gpt-5.6-terra";
-function cliCatalog() {
-  return [...CLAUDE_MODELS, ...CODEX_MODELS];
-}
-function cliFor(model) {
-  const m = model.toLowerCase().replace(/^no-think\//, "").replace(/^(cc|claude|cx|codex)\//, "");
-  if (/^(fable|opus|sonnet|haiku)\b/.test(m) || m.startsWith("claude")) return "claude";
-  if (/^(codex|gpt|o[0-9])\b/.test(m)) return "codex";
-  return void 0;
-}
-function cliInvocation(model) {
-  const bare = model.replace(/^no-think\//, "").replace(/^(cc|claude|cx|codex)\//, "");
-  const effort = /-(ultra|max|xhigh|high|medium|low|minimal)$/.exec(bare)?.[1];
-  const name = effort ? bare.slice(0, -(effort.length + 1)) : bare;
-  const resolved = name === "codex" ? CODEX_DEFAULT : name;
-  return {
-    ...resolved ? { model: resolved } : {},
-    ...effort ? { effort } : {}
-  };
-}
-
-// src/agents/cli-agent.ts
-import { spawn } from "child_process";
-function cliArgs(kind, prompt, extra = []) {
-  return kind === "claude" ? ["--output-format", "stream-json", "--verbose", ...extra, "-p", "--", prompt] : ["exec", "--json", "--skip-git-repo-check", ...extra, "--", prompt];
-}
-function decodeClaudeEvent(line) {
-  let e;
-  try {
-    e = JSON.parse(line);
-  } catch {
-    return void 0;
-  }
-  const type = e.type;
-  if (type === "rate_limit_event") {
-    const info = e.rate_limit_info ?? {};
-    const status = String(info.status ?? "unknown");
-    const raw = info.unifiedWindows ?? {};
-    const windows = {};
-    for (const [name, w] of Object.entries(raw)) windows[name] = w?.utilization ?? 0;
-    const quota = {
-      status,
-      windows,
-      ...typeof info.resetsAt === "number" ? { resetsAt: info.resetsAt } : {}
-    };
-    return status.startsWith("allowed") ? { quota } : {
-      quota,
-      /**
-       * The reset time rides along, as an ISO instant rather than prose.
-       *
-       * A spent five-hour window reopens; without saying when, the only safe bench is "the rest of the
-       * run", which on a ten-hour board writes off a subscription for hours after it recovered. The
-       * gateway's wordings said "reset after 4h" and nothing ever parsed them — see `quotaResetAt`.
-       */
-      rateLimited: `${status} \u2014 ${describeWindows(windows)}` + (quota.resetsAt ? ` (resets ${new Date(quota.resetsAt * 1e3).toISOString()})` : "")
-    };
-  }
-  if (type === "assistant") {
-    const msg = e.message;
-    const parts = Array.isArray(msg?.content) ? msg.content : [];
-    const text = parts.filter((b) => typeof b === "object" && b !== null && b.type === "text").map((b) => b.text).join("");
-    const tool = parts.find((b) => typeof b === "object" && b !== null && b.type === "tool_use");
-    return {
-      ...text ? { text } : {},
-      ...msg?.model ? { served: msg.model } : {},
-      ...tool ? { tool: { name: tool.name, ...targetOf(tool.input) ? { target: targetOf(tool.input) } : {} } } : {}
-    };
-  }
-  if (type === "user") {
-    const parts = e.message?.content;
-    const failed = (Array.isArray(parts) ? parts : []).find(
-      (b) => typeof b === "object" && b !== null && b.type === "tool_result" && b.is_error === true
-    );
-    return failed ? { tool: { name: "tool", ok: false } } : void 0;
-  }
-  if (type === "result") {
-    const u = e.usage ?? {};
-    const cost = e.total_cost_usd;
-    return {
-      usage: {
-        freshTokens: u.input_tokens ?? 0,
-        cachedTokens: u.cache_read_input_tokens ?? 0,
-        cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
-        outputTokens: u.output_tokens ?? 0,
-        ...cost !== void 0 ? { costUsd: cost } : {}
-      },
-      ...e.subtype === "error_during_execution" ? { error: String(e.result ?? "the CLI reported an error") } : {}
-    };
-  }
-  return void 0;
-}
-function decodeCodexEvent(line) {
-  let e;
-  try {
-    e = JSON.parse(line);
-  } catch {
-    return void 0;
-  }
-  const type = String(e.type ?? "");
-  if (/rate.?limit/i.test(type)) return { rateLimited: String(e.message ?? "rate limited by the CLI") };
-  if (type === "item.completed") {
-    const item = e.item;
-    if (item?.type === "agent_message" && item.text) return { text: item.text };
-    if (item?.type && item.type !== "agent_message") {
-      const changes = item.changes;
-      const first = Array.isArray(changes) ? changes.find((c) => typeof c?.path === "string")?.path : void 0;
-      const more = Array.isArray(changes) && changes.length > 1 ? ` +${changes.length - 1}` : "";
-      return {
-        tool: {
-          name: item.name ?? item.type,
-          ...first ? { target: `${first}${more}` } : {}
-        }
-      };
-    }
-    return void 0;
-  }
-  if (type === "turn.completed") {
-    const u = e.usage ?? {};
-    return {
-      usage: {
-        freshTokens: u.input_tokens ?? 0,
-        cachedTokens: u.cached_input_tokens ?? 0,
-        cacheWriteTokens: u.cache_write_input_tokens ?? 0,
-        outputTokens: u.output_tokens ?? 0
-      }
-    };
-  }
-  if (type === "turn.failed" || type === "error") {
-    return { error: String(e.message ?? "codex reported an error") };
-  }
-  return void 0;
-}
-function describeWindows(windows) {
-  const parts = Object.entries(windows).map(([k, v]) => `${k} ${Math.round(v * 100)}%`);
-  return parts.length ? parts.join(", ") : "no window reported";
-}
-var SYNTHETIC = "<synthetic>";
-function targetOf(input) {
-  for (const k of ["file_path", "path", "filePath", "notebook_path"]) {
-    const v = input?.[k];
-    if (typeof v === "string" && v) return v;
-  }
-  return void 0;
-}
-function makeStreamReader(decode, onEvent) {
-  let pending = "";
-  const drain = (upToNewline) => {
-    const lines = pending.split("\n");
-    pending = upToNewline ? lines.pop() ?? "" : "";
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      const ev = decode(line);
-      if (ev) onEvent(ev);
-    }
-  };
-  return {
-    push(chunk) {
-      pending += chunk;
-      drain(true);
-    },
-    end() {
-      if (pending.trim()) drain(false);
-    }
-  };
-}
-async function runCliAgent(run) {
-  const decode = run.kind === "claude" ? decodeClaudeEvent : decodeCodexEvent;
-  const args = cliArgs(run.kind, run.prompt, run.args ?? []);
-  return new Promise((resolve6) => {
-    let child;
-    try {
-      child = spawn(run.kind, args, {
-        cwd: run.cwd,
-        signal: run.signal,
-        stdio: ["ignore", "pipe", "pipe"],
-        ...run.configDir ? { env: { ...process.env, ...profileEnv(run.kind, run.configDir) } } : {}
-      });
-    } catch (e) {
-      resolve6({ text: "", error: e instanceof Error ? e.message : String(e), exitCode: -1 });
-      return;
-    }
-    let text = "";
-    let usage;
-    let rateLimited;
-    let served;
-    let quota;
-    let error;
-    let stderr = "";
-    const reader = makeStreamReader(decode, (ev) => {
-      if (ev.text) text += ev.text;
-      if (ev.usage) usage = ev.usage;
-      if (ev.rateLimited) rateLimited = ev.rateLimited;
-      if (ev.served) served = ev.served;
-      if (ev.quota) quota = ev.quota;
-      if (ev.error) error = ev.error;
-      run.onEvent?.(ev);
-    });
-    child.stdout?.on("data", (d) => reader.push(d.toString()));
-    child.stderr?.on("data", (d) => {
-      stderr += d.toString();
-    });
-    child.on("error", (e) => resolve6({ text, ...usage ? { usage } : {}, error: e.message, exitCode: -1 }));
-    child.on("close", (code) => {
-      reader.end();
-      resolve6({
-        text,
-        ...usage ? { usage } : {},
-        ...rateLimited ? { rateLimited } : {},
-        ...quota ? { quota } : {},
-        ...served ? { served } : {},
-        // stderr only becomes the error when nothing better was said — a CLI that warns on stderr and
-        // succeeds must not be read as having failed.
-        ...error ?? (code !== 0 && stderr.trim()) ? { error: error ?? stderr.trim().slice(0, 500) } : {},
-        exitCode: code ?? -1
-      });
-    });
-  });
-}
-
 // src/agent/deadline.ts
 function withDeadline(work, signal, message) {
   work.catch(() => {
@@ -369,7 +107,7 @@ ${m.content}` : m.content);
   return parts.join("\n\n");
 }
 function isLoggedOut(text) {
-  return /not logged in|please run \/login/i.test(text);
+  return /not logged in|not signed in|please run \/login/i.test(text);
 }
 async function* streamWhileRunning(start) {
   const queue = [];
@@ -427,11 +165,17 @@ var CliProvider = class {
     const { model, effort: named } = cliInvocation(req.model);
     if (model) args.push("--model", model);
     const effort = req.effort ?? named;
-    if (effort && kind === "claude") args.push("--effort", effort);
-    if (this.readOnly && kind === "claude") args.push("--disallowed-tools", "Write", "Edit", "NotebookEdit");
+    if (effort && (kind === "claude" || kind === "zai")) args.push("--effort", effort);
+    if (effort && kind === "grok") {
+      const level = grokEffort(effort);
+      if (level) args.push("--reasoning-effort", level);
+    }
+    if (this.readOnly && (kind === "claude" || kind === "zai")) args.push("--disallowed-tools", "Write", "Edit", "NotebookEdit");
     if (this.readOnly && kind === "codex") args.push("--sandbox", "read-only");
-    if (!this.readOnly && kind === "claude") args.push("--permission-mode", "acceptEdits");
+    if (this.readOnly && kind === "grok") args.push("--disallowed-tools", "write,search_replace");
+    if (!this.readOnly && (kind === "claude" || kind === "zai")) args.push("--permission-mode", "acceptEdits");
     if (!this.readOnly && kind === "codex") args.push("--sandbox", "workspace-write");
+    if (!this.readOnly && kind === "grok") args.push("--permission-mode", "acceptEdits");
     const account = this.accounts?.pick(kind);
     let res;
     yield* streamWhileRunning((push) => runCliAgent({
@@ -471,6 +215,14 @@ var CliProvider = class {
       return;
     }
     if (res.error && !res.text.trim()) {
+      if (isLoggedOut(res.error)) {
+        yield {
+          type: "error",
+          retryable: true,
+          message: `${kind} CLI is not logged in${account ? ` under profile "${account.name}"` : ""} \u2014 run \`hcode add-provider ${kind}\` to sign it in again`
+        };
+        return;
+      }
       yield { type: "error", message: `${kind} CLI: ${res.error}`, retryable: res.exitCode !== 0 };
       return;
     }
@@ -638,8 +390,8 @@ async function inheritFromRoot(git, repoRoot, baseWorktree) {
     }
   }
   for (const rel of INHERITED_ASSETS) {
-    const from = join(repoRoot, rel);
-    if (!existsSync(from)) continue;
+    const from = assetSource(repoRoot, rel);
+    if (!from) continue;
     try {
       await stat(from);
       await copyPath(from, join(baseWorktree, rel));
@@ -649,6 +401,12 @@ async function inheritFromRoot(git, repoRoot, baseWorktree) {
   }
   return out;
 }
+function assetSource(repoRoot, rel) {
+  const atRoot = join(repoRoot, rel);
+  if (existsSync(atRoot)) return atRoot;
+  const standing = join(repoRoot, ".horsecode", "worktrees", "traces", "base", rel);
+  return existsSync(standing) ? standing : void 0;
+}
 function describeInherited(i) {
   const parts = [];
   const n = i.modified.length + i.deleted.length;
@@ -825,6 +583,43 @@ var WorktreeManager = class {
     const inherited = await inheritFromRoot((args, cwd) => this.git(args, cwd), this.repoRoot, baseWorktree);
     return { jobSlug, root, baseWorktree, baseBranch, inherited };
   }
+  /**
+   * Opens — or re-enters — a worktree with a FIXED name, for the standing work that is not one job.
+   *
+   * `openSession` mints a fresh dated slug every call, which is right for a job: two runs of "add login" are
+   * two pieces of work and must not share a branch. Tracing is the opposite. It is one long-lived artefact
+   * the project keeps, its index is checkpointed so an interrupted run resumes, and a new worktree per
+   * invocation would both lose that resumption and pile up full checkouts — measured on the project this was
+   * written for, a checkout is not small.
+   *
+   * So the slug is the caller's, and running it twice re-enters the same place. Re-entry is decided by git
+   * rather than by the directory existing: a leftover directory git no longer tracks is not a worktree, and
+   * treating one as resumable is how a run ends up writing into a checkout that no longer has a branch.
+   */
+  async openFixed(fromBranch, slug) {
+    await this.ensureBaseCommit();
+    const worktreesDir = join2(this.worktreeHome, ".horsecode", "worktrees");
+    await mkdir2(worktreesDir, { recursive: true });
+    await writeFile(join2(worktreesDir, ".gitignore"), "*\n", "utf8");
+    const root = join2(worktreesDir, slug);
+    const baseWorktree = join2(root, "base");
+    const baseBranch = `hc/${slug}/base`;
+    let real;
+    try {
+      real = realpathSync(baseWorktree);
+    } catch {
+    }
+    if (real && (await this.registeredWorktrees()).has(real)) {
+      return { jobSlug: slug, root, baseWorktree, baseBranch, resumed: true };
+    }
+    const base = await this.resolveBase(fromBranch);
+    await mkdir2(join2(root, "tasks"), { recursive: true });
+    const listed = await this.git(["for-each-ref", "--format=%(refname:short)", `refs/heads/${baseBranch}`], this.repoRoot);
+    const exists = listed.stdout.trim() === baseBranch;
+    await this.run(exists ? ["worktree", "add", baseWorktree, baseBranch] : ["worktree", "add", "-b", baseBranch, baseWorktree, base], this.repoRoot);
+    const inherited = await inheritFromRoot((args, cwd) => this.git(args, cwd), this.repoRoot, baseWorktree);
+    return { jobSlug: slug, root, baseWorktree, baseBranch, inherited };
+  }
   /** Absolute paths of the worktrees git currently tracks (from `git worktree list --porcelain`). */
   async registeredWorktrees() {
     const r = await this.git(["worktree", "list", "--porcelain"], this.repoRoot);
@@ -1092,546 +887,8 @@ ${out.slice(0, MAX_DIFF_CHARS)}`;
   }
 };
 
-// src/prompts.ts
-var REQUIRED_ROLES = [
-  "refiner",
-  "coach",
-  "brainstormer",
-  "analyst",
-  "planner",
-  "judge",
-  "project-manager",
-  "team-lead",
-  "router",
-  "coder",
-  "designer",
-  "senior-coder",
-  "senior-designer",
-  "architect",
-  "code-reviewer",
-  "task-auditor",
-  "principal-coder",
-  "operational",
-  "memory-keeper",
-  "tracer",
-  "tester"
-];
-var DEFAULT_ROLE_SKILLS = {
-  brainstormer: ["brainstorming"],
-  // The roles that WRITE code get the test discipline inlined, rather than having the code-tests lens reject
-  // vacuous tests after the fact. Rejecting is more expensive than getting it right the first time.
-  coder: ["test-driven-development"],
-  "senior-coder": ["test-driven-development"],
-  // The task list is where a plan becomes something an implementer can actually execute. spec-kit's template
-  // supplies the SHAPE (phases, story grouping, [P] markers); it says almost nothing about what makes an
-  // individual task executable. That is what this skill adds.
-  "project-manager": ["writing-plans"],
-  // The UI roles get design direction inlined for the same reason the coders get TDD: the code-accessibility
-  // and code-maintainability lenses can reject a templated, default-looking interface, but they cannot teach
-  // one. This skill is self-contained (no sibling reference files), which is what makes it safe to inline.
-  designer: ["frontend-design"],
-  "senior-designer": ["frontend-design"]
-  // NB: systematic-debugging is shipped but attached to NO role — it is only needed when something is stuck,
-  // so it stays in the discoverable listing every role already receives and is fetched with the `skill` tool.
-};
-var DEFAULT_PROMPTS = {
-  tracer: "You write the reference note that every other agent reads before it touches a file it did not write. A wrong note is worse than none: an agent will act on it, so accuracy outranks fluency and admitting you cannot tell outranks a plausible guess. State only what the code and the given relationships show; if the business purpose is not evident from them, describe what the file does technically and say nothing about why. Never speculate about intent, history or requirements.",
-  /**
-   * The role that exercises work already built and writes down what actually happened.
-   *
-   * Every rule below is here because its absence produces the one output worse than no testing at all: a
-   * report that says PASSED about something nobody ran. Such a report is not merely empty — it manufactures
-   * confidence, and the next person spends it.
-   */
-  tester: "You verify software that already exists, by running its scenarios and recording what they actually did. You are not here to build, fix or improve anything: the code under test is finished, and changing it would mean the thing you verified is not the thing that shipped.\n\nEVIDENCE IS THE WHOLE JOB. A scenario's outcome is what you OBSERVED \u2014 a database row, a log line, an HTTP response, a screen the user confirmed. Record the evidence beside every result: the query you ran and what it returned, the log event id and its line, the response body. A result you cannot show is not a result.\n\nIF A STEP WRITES TO THE DATABASE, THE RESPONSE IS NOT THE EVIDENCE. A 201 or a 204 says the request was accepted; it does not say what was stored, and a screen showing the new state does not either \u2014 both can be right while the row is wrong. For every step that creates or changes a record: query the database for that row and put the query AND the rows it returned in the report, and query the logs for the event that step should have emitted and put the query AND the line it returned there too. Absence is evidence as well: when a step must NOT emit an event \u2014 a no-op, a rejected change \u2014 show the query returning nothing. Without both, the scenario is NOT EXECUTED, however convincing the response looked.\n\nNever mark a scenario PASSED that you did not execute and observe. If you could not run it \u2014 the data does not exist, the surface is unreachable, the case is destructive against a live system \u2014 label it NOT EXECUTED and say exactly why. FAILED means you ran it and the behaviour was wrong; say what you expected, what happened, and the evidence for both. Guessing from the source is not executing: where you reasoned from code alone, say so in those words.\n\nWrite each result into the report BEFORE moving on to the next scenario. The report is a living document, not something assembled at the end: a run that stops halfway must leave behind everything it learned up to that point.\n\n\u2026and say each verdict OUT LOUD as you reach it, in one or two sentences: which scenario, what it did, and the single piece of evidence that settled it \u2014 the row, the log line, the status code. The full evidence still goes in the report; this is so the person watching the run knows what you found without opening a file. Say the failures and the NOT EXECUTED ones the same way, and with the same brevity: a result nobody hears is one they have to go looking for.\n\nNever start or stop the development environment \u2014 application hosts, dev servers, containers, databases. Those are the developer's to run. When you need something up, say which command they should run and wait for them to confirm it is ready.\n\nYou do NOT write product code. When you find something wrong that is not the verdict of the scenario you are running \u2014 a missing label, prose rendered as raw markup, a wrong format, or something the developer points out in passing \u2014 call `report_finding`. Another role fixes it and you are told when it is done, so you can re-check what it affected. Do not fix it yourself: changing the product mid-verification means the thing you verified is not the thing that shipped. And do not fail a scenario over it \u2014 a scenario fails when the scenario itself does not pass, not because something else was noticed while running it.\n\nIf the project's own rules (its constitution) say more about how verification is done here, they govern over this description \u2014 read them and follow them.",
-  refiner: "Your #1 rule: `refinedPrompt` MUST ALWAYS be in ENGLISH. If the user wrote in another language (Turkish, German, Spanish, \u2026), TRANSLATE their intent into English \u2014 never echo their language back. This is non-negotiable: a Turkish input like 'bir todo app geli\u015Ftir, \xF6nce backend' MUST come out as English 'Build a todo app; implement the backend first.'\n\nRewrite the user's message down to the raw core intent the AI needs to act on \u2014 clear, direct, and structured. Strip all politeness, emotional, and filler words (please, thanks, kindly, 'could you', 'would you', 'I'd like', etc.) and anything that carries no instruction. Do NOT add words, qualifiers, or scope the user did not state (e.g. do not add 'always'). Keep the user's own perspective and form \u2014 a question stays a question, an instruction stays an instruction; do NOT describe the user in the third person and do NOT answer the request. Example: a polite request like 'would you please answer me in language X?' becomes just 'respond in language X' (drop 'please'; do not add 'always' or any scope the user didn't state). Also classify the intent: 'chat' (conversation/question), 'feature' (new feature/work), 'bugfix' (bug fix), 'govern' (establish or amend the project's OWN standing rules and principles \u2014 writing or revising the constitution, the coding conventions, the project's rules; work whose entire output is a governing document, with no source code changed). Judge by what the request PRODUCES, not by what it mentions: 'write the project constitution from CLAUDE.md' is govern, and so is 'update our commit-message rules'; 'make the code follow the constitution' changes source and is feature. Also 'verify' \u2014 the user wants work that ALREADY EXISTS exercised and its behaviour confirmed with evidence: running a pull request's test scenarios, doing a smoke test of a feature that is already built, producing a test report. Judge by what it PRODUCES: a record of what the software DID is verify; changing what it does is feature or bugfix. 'Run the smoke tests for PR 677 and mark them passed' is verify, and so is 'check that the wizard works end to end'. 'The wizard is broken, fix it' is bugfix. Finally 'undo' \u2014 the user is asking you to REVERSE what the previous turn did, not to do anything new: 'undo that', 'revert your changes', 'go back to the previous version', 'that was wrong, put it back'. Classify by whether the request refers to work already done: undoing is never a rewrite, and asking for a different result ('rewrite it shorter') is not an undo. Also detect the natural language the user wrote in and return its English name as `language` (e.g. 'Turkish', 'English', 'German') \u2014 this is separate from refinedPrompt, which stays English. Also produce `title`: what the work is ABOUT, as a 2-5 word English kebab-case noun phrase suitable for a git branch name \u2014 the SUBJECT, not the action. 'build a luxury todo app' is 'luxury-todo-app'; 'add a login page' is 'login-page'; 'fix the null crash on retry' is 'null-crash-on-retry'. Do not open with a verb (build/add/fix/implement/update): the tool is already doing it, so the verb says nothing and crowds out the words that identify the work. Lowercase, dash-joined, no punctuation. Return the result via submit as {refinedPrompt, intent, language, title}. Remember: refinedPrompt in English, always.",
-  brainstormer: "You run the BRAINSTORM stage: you turn a raw request into a decided design, before anything is specified.\n\nThe `brainstorming` skill above is the authority on HOW to do this \u2014 follow it. What follows is only how it binds to this pipeline, because the skill names conventions from a different habitat:\n\n- OUTPUT: write the design brief to the file named in your message (specs/NNN-slug/brainstorm.md). Ignore the skill's `docs/superpowers/specs/\u2026` path.\n- NEXT STAGE: the SPEC is written from your brief, by another agent, immediately after you. There is no `writing-plans` skill to invoke here \u2014 finishing the brief IS the terminal step.\n- QUESTIONS: ask through the `ask_user` tool. For a choice between approaches use its rich option form ({label, description, preview}) so the trade-offs sit beside the list; lead with your recommendation. The user may attach a note to their answer \u2014 treat it as binding.\n- NOT AVAILABLE: the visual companion (there is no browser) and the per-checklist task list. Skip both.\n\nWrite what was DECIDED, not a transcript: the chosen approach, why it beat the others, the rejected alternatives with their reason, the constraints the spec must honour, and what is out of scope. Keep it short \u2014 it is the brief the spec is written from, not the spec itself, and it carries no implementation detail beyond the architectural choice.\n\nScale to the request: a small, obvious change deserves a paragraph and no questions at all.",
-  coach: "You are horse-code, a terminal-based AI coding agent. Your product identity is always horse-code \u2014 never claim to be Claude Code, Gemini CLI, Antigravity, or any other product, even though the underlying language model powering you may be Claude, Gemini, or another model. Answer the user's technical questions about their repository and code. If needed, inspect the repository with read_file/grep/glob.\n\nWork out loud while you do it. Before a batch of tool calls, say in ONE line what you are looking for and why; when something you read changes your mind, say that too. This is not a summary at the end \u2014 the user is watching an empty screen while you search, and a run that reads thirty files in silence is indistinguishable from one that is stuck, and impossible to redirect before the tokens are spent. Keep each line short: a sentence, not a paragraph.\n\nBe concise, direct, and helpful.",
-  // analyst + planner are spec-kit-driven (their system prompt comes from the fetched spec-kit command
-  // prompts — see src/speckit/phases.ts); they carry no default prompt here, only a model (peekModel).
-  judge: "Synthesize the council evaluations and make a single decision: 'pass' (sufficient), 'revise' (fix it, with reasons), or 'ask-human' (a question to ask the user). Return {decision, feedback, question} via submit.",
-  "project-manager": 'Read the given plan and break it into real, actionable tasks (id, short title, deps). Each task should be a single, clear piece of work. Return {tasks} via submit.\n\nThe `writing-plans` skill above governs WHAT MAKES A TASK EXECUTABLE \u2014 take that from it and nothing else. Two bindings, because the skill describes a different habitat:\n- STRUCTURE comes from the spec-kit tasks template you are given (phases, story grouping, [P] markers), NOT from the skill\'s own document layout. Ignore its `docs/superpowers/plans/\u2026` path, its required-sub-skill header, and its execution-handoff section: this pipeline already owns worktrees, dispatch and review.\n- What you DO take: exact file paths per task, a real test cycle rather than a vague "add tests" step, no placeholders (no TBD/TODO/"similar to task N"), and interfaces named explicitly so a task whose implementer never sees the others still knows the signatures it must produce and consume.\n- SIZING is the third rebinding, and the one that costs most when it is missed. The skill says "bite-sized", "one action, 2-5 minutes", "the smallest unit worth a reviewer\'s gate" \u2014 sound advice where a gate is one reader glancing at a diff. Here a card is not a line in a document: it is its own worktree, its own implementer, a full review TEAM of lenses, a council when they disagree, an acceptance gate and a merge. That overhead is paid per CARD and barely varies with the card\'s size, so splitting work finer does not divide the cost, it multiplies it.\nSize a card to a coherent piece of BEHAVIOUR a reviewer can judge whole, not to a file. An entity, its configuration, its migration and its tests are one card, because nobody can review one without the others and nothing is deliverable until all of them exist. Split only for a reason that survives being said out loud: the parts can be reviewed and merged independently, or they must run in parallel in different worktrees. "They are different files" is not such a reason. Fold setup and scaffolding into the card whose deliverable needs them.',
-  "task-auditor": "You are the last check on a task breakdown before any of it is built. Every hour of implementation after you is spent executing this list, and a bad list does not fail \u2014 the tasks pass their reviews and the wrong work is delivered correctly. Its structure has already been checked mechanically; you are here for the part only a reader can answer: does the breakdown deliver what the plan requires, and would a task's acceptance criteria still hold for an implementation that missed the point? Do not propose better work than the plan asked for \u2014 scope you invent here becomes hours someone spends. Flag any task whose only deliverable is an answer \u2014 verifying, inspecting, confirming \u2014 because an implementer reads the code as part of doing the work, and a task that ends with the repository unchanged has spent a review round on nothing. Flag OVER-SPLITTING for the same reason, and it is the more expensive mistake: every card carries a full review team, a council and an acceptance gate whatever its size, so a breakdown that gives a class and its configuration separate cards pays that overhead twice for work no one can review apart. Say which cards should be one. A clean breakdown is the normal case; say so. Return {missing, weak} via submit.",
-  "team-lead": "You audit a task breakdown before any of it runs. The schedule itself is computed from the declared dependencies and is not yours to write; what nothing has checked is whether those dependencies are RIGHT. You are given the tasks with the files each one writes and what must be true when it is done, plus the groups that would run at the same time in separate worktrees. Find the task that cannot actually start yet because it needs a type, function, table or config key another task in its own group creates \u2014 and say which declared dependencies hold work back for no reason. Both answers are usually empty; say so rather than inventing an edge. Return {missing, spurious} via submit.",
-  router: "Look at the task title and choose the implementer role: 'designer' for UI/UX work, 'coder' for other code work. Return {role} via submit.",
-  coder: "Implement the given task in the worktree. If it is a new task, start from scratch; if it is a returning task, address the reviewer notes. Work with read/write/edit/grep/glob/shell and run the tests.\n\nThe `test-driven-development` skill above is how you write code here: the failing test comes first, and it must fail for the RIGHT reason before you make it pass. A test that asserts nothing is worse than no test \u2014 it reports success forever. Bindings for this pipeline: your worktree is already prepared (do not create one), every file you write is committed as you write it, and there is no separate agent to hand off to \u2014 you take the task to green yourself.",
-  designer: "Implement the UI/UX task in the worktree. Focus on the user interface and experience; work with read/write/edit.\n\nThe `frontend-design` skill above governs the LOOK: aesthetic direction, typography, and choices that do not read as templated defaults. Follow the project's existing visual language where there is one \u2014 a distinctive design that fights the surrounding product is worse than a plain one that fits it.",
-  "senior-coder": "Take over the task the coder got stuck on; implement it with a more careful approach. Take the reviewer notes and previous attempts into account.\n\nYou are here because a previous attempt failed, so start by understanding WHY rather than rewriting: the `systematic-debugging` skill is available (fetch it with the `skill` tool) and is the right tool when a test fails or behaviour is unexplained. The `test-driven-development` skill above still governs how you write the fix \u2014 reproduce the failure in a test first, then make it pass.",
-  "senior-designer": "Take over the UI/UX task the designer got stuck on; implement it more carefully.\n\nA previous attempt already failed, so establish WHY before redesigning \u2014 the `systematic-debugging` skill is available via the `skill` tool when the failure is behavioural rather than visual. The `frontend-design` skill above still governs the look.",
-  architect: "Analyze the root cause of a repeatedly failing task or a merge conflict, and produce a concrete solution plan. Return {rootCause, plan} via submit.\n\nFetch the `systematic-debugging` skill with the `skill` tool and follow it: your job is the ROOT CAUSE, and the failure mode to avoid is proposing a plausible fix for a cause you never established. Say what the evidence is, not what it might be.",
-  "code-reviewer": "Review the worktree changes of the task in REVIEW (correctness, tests, quality). Return {verdict: pass|fail, notes} via submit \u2014 your decision is final.",
-  "principal-coder": "Holistically review all changes in the PR (base worktree). If sufficient, approve; otherwise request-changes with concrete comments. In the final decision round, give accept or ask-human (a question to ask the user).",
-  "memory-keeper": "You are the ONLY writer into this project's long-term memory. Everything else \u2014 every review lens, the council, the judge \u2014 can merely PROPOSE; you decide.\n\nTreat every proposal as an UNVERIFIED CLAIM from a narrow, single-angle agent that saw one slice of one job, not as text to store. Most proposals are wrong in a specific way: they generalize a one-off into a rule, they restate the finding the agent was reviewing, or they record general programming advice any model already knows. Discard all of those. When a claim does survive, REWRITE it in your own words \u2014 never store an agent's sentence verbatim. Merge proposals that say the same thing into one memory.\n\nA memory qualifies ONLY if it is (a) durable \u2014 still true next month, (b) project-specific, and (c) actionable \u2014 it would change what an agent does. Write conventions, constraints, gotchas and root causes. A `lesson` must state what went wrong AND what to do instead. Set `audience` only when the memory is genuinely useful to specific roles and useless to the rest; leave it out otherwise.\n\nNEVER write transient run detail (task ids, attempt counts, what happened today), never restate the request, never duplicate a memory that already exists, and never include credentials, tokens, keys, or anything resembling a secret. Each memory is one self-contained sentence that makes sense with no other context.\n\nReturn at most 5 memories via submit as {memories}. Returning NONE is the most common correct answer \u2014 prefer an empty list over a weak memory, because a bad memory is injected into every future run.",
-  operational: "You handle version control for the project. Given a git diff of work just completed, write a single Conventional Commits message: `type(scope): subject`. Types: feat, fix, docs, refactor, test, chore, style, perf, build, ci. Choose the scope from the touched area (e.g. spec, plan, tasks, or a module name) or omit it. The subject is imperative, lowercase, \u226472 chars, no trailing period. Add a short body only if the change genuinely needs explanation. Commit messages are always in English. Return {message} via submit."
-};
-var SPEC_TEAM = [
-  { name: "spec-completeness", perspective: "coverage of the REQUESTED scope: capabilities the user asked for that are missing, or behavior left unspecified", models: [] },
-  { name: "spec-clarity", perspective: "ambiguity: requirements that can be read two ways, vague wording, unresolved NEEDS CLARIFICATION markers", models: [] },
-  { name: "spec-consistency", perspective: "internal contradictions between requirements, acceptance scenarios, and success criteria", models: [] },
-  { name: "spec-scope", perspective: "scope discipline: requirements the user never asked for, gold-plating, scope creep beyond the request", models: [] },
-  { name: "spec-abstraction-leak", perspective: "implementation detail that has leaked into the spec (languages, frameworks, APIs, storage mechanics, code structure) \u2014 a spec must stay technology-agnostic", models: [] },
-  { name: "spec-verifiability", perspective: "are success criteria measurable and technology-agnostic, and can each acceptance scenario be tested without knowing the implementation", models: [] },
-  { name: "spec-user-value", perspective: "do the user stories deliver the value the user actually asked for, and is the priority ordering sensible", models: [] },
-  { name: "spec-domain-model", perspective: "key entities, their attributes and relationships \u2014 coherent and complete at the domain level, with no implementation detail", models: [] },
-  { name: "spec-privacy", perspective: "requirement-level data handling: what data is stored, who may see it, what must never leak or be retained", models: [] }
-];
-var PLAN_TEAM = [
-  { name: "plan-spec-conformance", perspective: "traceability to the approved spec: every requirement covered by the plan, and nothing planned that the spec never asked for", models: [] },
-  { name: "plan-architecture", perspective: "layering, module boundaries, dependency direction, overall structural coherence", models: [] },
-  { name: "plan-data-model", perspective: "schema and entity design, relationships, migrations, integrity constraints", models: [] },
-  { name: "plan-api-contracts", perspective: "interface and contract design, naming, backward compatibility, ergonomics", models: [] },
-  { name: "plan-security", perspective: "threat model, authentication/authorization design, input validation, secret handling, injection surfaces", models: [] },
-  { name: "plan-concurrency", perspective: "race conditions, atomicity, ordering, multi-writer/multi-tab safety, shared-state design", models: [] },
-  { name: "plan-resilience", perspective: "failure modes, error propagation, recovery, retries, partial-failure behavior", models: [] },
-  { name: "plan-performance", perspective: "algorithmic complexity, hot paths, resource bounds, scalability of the chosen design", models: [] },
-  { name: "plan-test-strategy", perspective: "how the design will be proven: seams, dependency injection, contract/integration test layers, what each test actually establishes", models: [] },
-  { name: "plan-simplicity", perspective: "YAGNI: over-engineering, unnecessary abstraction, complexity the requested scope does not justify", models: [] },
-  { name: "plan-dependencies", perspective: "third-party choices, supply-chain risk, versioning, licensing", models: [] },
-  { name: "plan-observability", perspective: "logging, metrics, tracing, debuggability, actionable failure signals", models: [] },
-  { name: "plan-structure", perspective: "project structure: directory/file layout, build setup, adherence to existing repo conventions", models: [] },
-  { name: "plan-feasibility", perspective: "can this be built and maintained as described, in reasonable increments, with the effort the request warrants", models: [] }
-];
-var CODE_TEAM = [
-  { name: "code-plan-conformance", perspective: "does the code implement what the task required \u2014 nothing missing, and no extra scope beyond the task", models: [] },
-  { name: "code-correctness", perspective: "logical correctness, edge cases, off-by-one and boundary conditions, invariants", models: [] },
-  { name: "code-security", perspective: "injection, secret leakage, missing authorization checks, unsafe APIs, unvalidated input", models: [] },
-  { name: "code-error-handling", perspective: "swallowed errors, propagation, cleanup on failure, partial-failure behavior", models: [] },
-  { name: "code-concurrency", perspective: "race conditions, deadlocks, atomicity, shared mutable state", models: [] },
-  { name: "code-tests", perspective: "is the new behavior covered, and do the tests actually assert something meaningful (no vacuous tests)", models: [] },
-  { name: "code-data-integrity", perspective: "persistence correctness, transactions, validation at boundaries, migration safety", models: [] },
-  { name: "code-performance", perspective: "hot paths, unnecessary allocation/work, N+1 patterns, obvious inefficiency", models: [] },
-  { name: "code-maintainability", perspective: "naming, structure, complexity, readability, future tech-debt", models: [] },
-  { name: "code-simplicity", perspective: "dead code, duplication, unnecessary abstraction, complexity the task does not justify", models: [] },
-  { name: "code-api-surface", perspective: "public interface shape, backward compatibility, accidental API exposure", models: [] },
-  { name: "code-accessibility", perspective: "accessibility of UI code: keyboard operation, ARIA/semantics, contrast, i18n readiness", models: [] },
-  { name: "code-observability", perspective: "logging/metrics where a failure would otherwise be undiagnosable", models: [] },
-  { name: "code-dependencies", perspective: "newly introduced dependencies: justified, correctly versioned, no supply-chain or licensing problem", models: [] },
-  { name: "code-conventions", perspective: "consistency with the surrounding codebase's idioms, patterns, and style", models: [] }
-];
-var DEFAULT_COUNCIL = [
-  { name: "correctness-judge", perspective: "Is the work under review correct, coherent and internally consistent? Weigh the team's correctness/logic/data findings.", models: [] },
-  { name: "risk-judge", perspective: "What is the real blast radius of shipping this as-is? Weigh security, failure modes, concurrency, and data-integrity findings against likelihood and severity.", models: [] },
-  { name: "completeness-judge", perspective: "Is what was asked for fully and unambiguously covered? Weigh the team's completeness, gap, and contract findings.", models: [] },
-  { name: "user-value-judge", perspective: "Does this deliver the user's actual intent well? Weigh usability, accessibility, and whether the scope serves the request without gold-plating.", models: [] },
-  { name: "feasibility-judge", perspective: "Can this be built and maintained as described? Weigh architecture, simplicity, dependencies, and maintainability findings against effort.", models: [] }
-];
-function placedSkills() {
-  return [...new Set(Object.values(DEFAULT_ROLE_SKILLS).flat())];
-}
-
-// src/providers/anthropic.ts
-function isAnthropicModel(model) {
-  return /(^|\/)(claude|fable|mythos)/i.test(model) || /claude/i.test(model);
-}
-
-// src/tui/role-models.ts
-var WEAK_RE = /\b(flash|mini|nano|haiku|lite|small|turbo|fast|\d{1,2}b)\b/i;
-var FLAGSHIP_ROLES = ["judge", "principal-coder"];
-var COUNCIL_ROLES = DEFAULT_COUNCIL.map((c) => c.name);
-var SPEC_LENS_ROLES = SPEC_TEAM.map((c) => c.name);
-var PLAN_LENS_ROLES = PLAN_TEAM.map((c) => c.name);
-var CODE_LENS_ROLES = CODE_TEAM.map((c) => c.name);
-var STRONG_ROLES = [
-  "brainstormer",
-  "analyst",
-  "planner",
-  "architect",
-  "senior-coder",
-  "senior-designer",
-  ...COUNCIL_ROLES,
-  ...PLAN_LENS_ROLES,
-  ...CODE_LENS_ROLES
-];
-var MID_ROLES = ["coach", "coder", "designer", "code-reviewer", "operational", "memory-keeper", "task-auditor", ...SPEC_LENS_ROLES];
-var FAST_ROLES = ["refiner", "router", "project-manager", "team-lead"];
-var CAPABLE_ROLES = /* @__PURE__ */ new Set([...FLAGSHIP_ROLES, ...STRONG_ROLES, ...MID_ROLES]);
-var ROLE_PROFILES = {
-  tracer: "Writes the per-file reference note every other agent reads before changing unfamiliar code \u2014 high volume, but its output is a COMMITTED FILE, not a turn in a conversation: a shallow note is believed by every agent that opens that file, forever, and nothing later corrects it. Give it the MOST capable non-[flagship] model in the catalogue, not merely one that qualifies as [strong]. Volume is not a reason to go cheaper here.",
-  refiner: "Classifies intent and rewrites the prompt every turn \u2014 highest call volume, trivial task \u2192 a fast, cheap model.",
-  router: "Picks coder-vs-designer for a task \u2014 tiny and frequent \u2192 fast, cheap.",
-  "project-manager": "Turns a task list into board items \u2014 light and structured \u2192 fast, cheap.",
-  "task-auditor": "The only check on the task breakdown before hours of implementation are spent executing it \u2014 reads the plan against the task list and finds what was dropped. Low volume, and everything downstream depends on it \u2192 a capable model, never the cheapest.",
-  "team-lead": "Coordinates implementation waves \u2014 light orchestration \u2192 fast, cheap.",
-  coach: "Your main interactive assistant, used constantly all session (highest interaction volume) \u2192 a capable but EFFICIENT model, never the costly flagship.",
-  brainstormer: "Turns a raw request into a decided design before the spec: explores the repo, weighs 2-3 approaches, gets the user to choose. Low volume, sets the direction for everything downstream \u2192 a strong reasoning model.",
-  analyst: "Authors the spec and constitution \u2192 a strong reasoning model (Opus-tier).",
-  planner: "Designs the implementation plan \u2192 a strong reasoning model (Opus-tier).",
-  architect: "Diagnoses stuck tasks and produces recovery plans \u2014 serious design work \u2192 a strong model.",
-  judge: "Critiques specs/plans and makes the final review call \u2014 low volume, high stakes \u2192 the most capable flagship model.",
-  coder: "Writes the bulk of the implementation \u2014 very high work volume \u2192 a good high-throughput coding model (Sonnet-tier), NOT the flagship (wasteful at this volume).",
-  "senior-coder": "Reviews and revises above the coder \u2014 must be MORE capable than the coder (Opus-tier).",
-  "principal-coder": "Final code decision-maker \u2014 low volume, high stakes \u2192 the flagship is appropriate.",
-  designer: "Builds UI \u2014 high volume \u2192 a capable coding/design model, not the flagship.",
-  "senior-designer": "Senior UI reviewer \u2014 more capable than the designer.",
-  "code-reviewer": "Reviews diffs \u2014 moderate volume \u2192 a solid capable model.",
-  "memory-keeper": "Decides what a finished job taught the project and writes it to durable memory \u2014 low volume, but a bad memory poisons every later run \u2192 a capable, efficient model, never the cheapest.",
-  operational: "Handles version control: writes conventional commit messages and (later) drives merges/conflicts \u2014 high volume \u2192 a capable, efficient model."
-};
-for (const [stage, lenses, heft] of [
-  ["spec", SPEC_TEAM, "a capable, efficient model (a spec is a short business-level doc)"],
-  ["plan", PLAN_TEAM, "a strong model (technical design judgment)"],
-  ["code", CODE_TEAM, "a strong model (reads real implementations)"]
-]) {
-  for (const l of lenses) ROLE_PROFILES[l.name] = `${stage.toUpperCase()}-review lens \u2014 ${l.perspective}. Low volume, quality-critical \u2192 ${heft}.`;
-}
-for (const c of DEFAULT_COUNCIL) {
-  ROLE_PROFILES[c.name] = `Review COUNCIL decider \u2014 ${c.perspective} Casts the binding pass/revise vote on contested work \u2192 a strong model.`;
-}
-var ROLE_ADVICE = ROLE_PROFILES;
-function filterModelsForRole(role, all, exclude = []) {
-  const advice = ROLE_ADVICE[role];
-  const excluded2 = new Set(exclude);
-  const avail = all.filter((m) => !excluded2.has(m));
-  if (CAPABLE_ROLES.has(role)) {
-    const strong = avail.filter((m) => !WEAK_RE.test(m));
-    if (strong.length === 0) return { models: avail.length ? avail : all, note: advice ? `${advice} (No strong models detected \u2014 showing all.)` : void 0 };
-    return { models: strong, note: `${advice ?? ""} Showing ${strong.length} of ${avail.length} models (fast/weak models hidden for this role).`.trim() };
-  }
-  if (FAST_ROLES.includes(role)) {
-    const fast = avail.filter((m) => WEAK_RE.test(m));
-    if (fast.length === 0) return { models: avail.length ? avail : all, note: advice };
-    return { models: fast, note: `${advice ?? ""} Showing ${fast.length} of ${avail.length} fast/cheap models.`.trim() };
-  }
-  return { models: avail.length ? avail : all };
-}
-function effortFor(role, model) {
-  if (!isAnthropicModel(model)) return void 0;
-  if (FLAGSHIP_ROLES.includes(role)) return "max";
-  if (STRONG_ROLES.includes(role)) return "xhigh";
-  if (FAST_ROLES.includes(role)) return "low";
-  if (MID_ROLES.includes(role)) return "high";
-  return void 0;
-}
-var effortBump = (s) => /-(ultra|max|xhigh)/.test(s) ? 4 : /-high/.test(s) ? 3 : /-medium/.test(s) ? 2 : /-low/.test(s) ? 1 : 0;
-var versionBump = (s, family) => {
-  if (family) {
-    const m = s.match(new RegExp(`${family}[-_. ]?(\\d+)(?:[-.](\\d+))?`));
-    if (m) {
-      const major = Number(m[1]);
-      const minor = m[2] === void 0 ? 0 : Number(m[2]);
-      if (major < 100) return major + (minor < 10 ? minor / 10 : minor / 100);
-    }
-  }
-  const g = s.match(/(\d)[-.](\d)\b/);
-  return g ? Number(g[1]) + Number(g[2]) / 10 : 0;
-};
-var KNOWN_FAMILY_RE = /(fable|mythos|opus|sonnet|haiku|claude|codex|gpt-|\bo\d\b|gemini|deepseek|llama|qwen|kimi|glm|mistral|grok|nova|command-r|phi-\d)/i;
-var NON_TEXT_RE = /\b(image|imagen|vision|video|veo|tts|audio|speech|voice|embed|embedding|rerank|ocr|computer-use|realtime|moderation)\b/i;
-function isKnownModel(model) {
-  return KNOWN_FAMILY_RE.test(model) && !NON_TEXT_RE.test(model);
-}
-var UNRANKED_SCORE = 50;
-function capabilityScore(model) {
-  const s = model.toLowerCase();
-  if (WEAK_RE.test(s)) return 20 + effortBump(s);
-  if (/fable|mythos/.test(s)) return 100;
-  if (/opus/.test(s)) return 88 + versionBump(s, "opus");
-  if (/codex|gpt-5|\bo3\b/.test(s)) return 82 + effortBump(s) + versionBump(s, "gpt") / 100;
-  if (/sonnet/.test(s)) return 78 + versionBump(s, "sonnet");
-  if (/gemini/.test(s) && /pro/.test(s)) return 76 + versionBump(s, "gemini") + effortBump(s);
-  if (/gpt-4/.test(s)) return 65;
-  if (/deepseek/.test(s)) return 55;
-  return UNRANKED_SCORE;
-}
-function mostCapable(models) {
-  return [...models].sort((a, b) => capabilityScore(b) - capabilityScore(a))[0] ?? "";
-}
-function modelBand(model) {
-  if (WEAK_RE.test(model)) return "fast";
-  const s = capabilityScore(model);
-  if (s >= 95) return "flagship";
-  if (s >= 84) return "strong";
-  if (s <= UNRANKED_SCORE) return "fast";
-  return "mid";
-}
-function baseModel(model) {
-  const segs = model.toLowerCase().split("/");
-  let s = segs[segs.length - 1];
-  s = s.replace(/-(ultra|max|xhigh|high|medium|low|free|thinking|preview)\b/g, "");
-  s = s.replace(/-\d{6,8}\b/g, "");
-  return s.replace(/-+$/, "");
-}
-function modelFamily(model) {
-  return baseModel(model).replace(/[-.]v?\d+(?:[-.]\d+)*(?=[-.]|$)/g, "").replace(/[-.]{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
-}
-function latestFirst(models) {
-  const best = /* @__PURE__ */ new Map();
-  for (const m of models) {
-    const key2 = modelFamily(m);
-    const cur = best.get(key2);
-    if (!cur || capabilityScore(m) > capabilityScore(cur)) best.set(key2, m);
-  }
-  const isLatest = (m) => best.get(modelFamily(m)) === m;
-  return [...models.filter(isLatest), ...models.filter((m) => !isLatest(m))];
-}
-function versionlessId(model) {
-  const cut = model.lastIndexOf("/");
-  const prefix = cut >= 0 ? model.slice(0, cut + 1) : "";
-  const name = model.slice(cut + 1).toLowerCase().replace(/-\d{6,8}\b/g, "").replace(/[-.]v?\d+(?:[-.]\d+)*(?=[-.]|$)/g, "").replace(/[-.]{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
-  return prefix + name;
-}
-var DURABLE_ROLES = ["tracer"];
-function strongestPrimary(chain, pool) {
-  const head = chain[0];
-  if (!head) return chain;
-  let best = head;
-  for (const m of pool) {
-    if (modelBand(m) === "flagship" || !isKnownModel(m)) continue;
-    if (capabilityScore(m) > capabilityScore(best)) best = m;
-  }
-  if (best === head) return chain;
-  const at = chain.indexOf(best);
-  if (at > 0) {
-    const next = [...chain];
-    next[at] = head;
-    next[0] = best;
-    return next;
-  }
-  return [best, ...chain.slice(1)];
-}
-function newestPrimary(chain, pool) {
-  const head = chain[0];
-  if (!head) return chain;
-  const key2 = versionlessId(head);
-  let best = head;
-  for (const m of pool) {
-    if (versionlessId(m) !== key2) continue;
-    if (capabilityScore(m) > capabilityScore(best)) best = m;
-  }
-  if (best === head) return chain;
-  const at = chain.indexOf(best);
-  if (at > 0) {
-    const next = [...chain];
-    next[at] = head;
-    next[0] = best;
-    return next;
-  }
-  return [best, ...chain.slice(1)];
-}
-function dedupBest(models) {
-  const best = /* @__PURE__ */ new Map();
-  for (const m of models) {
-    const key2 = baseModel(m);
-    const cur = best.get(key2);
-    if (!cur || capabilityScore(m) > capabilityScore(cur)) best.set(key2, m);
-  }
-  return [...best.values()].sort((a, b) => capabilityScore(b) - capabilityScore(a));
-}
-function sourceOf(model) {
-  const s = model.toLowerCase().replace(/^no-think\//, "");
-  return cliFor(s) ?? s.split("/")[0];
-}
-function interleaveBySource(pool) {
-  const bySource = /* @__PURE__ */ new Map();
-  for (const m of pool) {
-    const s = sourceOf(m);
-    const q = bySource.get(s);
-    if (q) q.push(m);
-    else bySource.set(s, [m]);
-  }
-  const queues = [...bySource.values()];
-  const out = [];
-  for (let more = true; more; ) {
-    more = false;
-    for (const q of queues) {
-      const m = q.shift();
-      if (m !== void 0) {
-        out.push(m);
-        more = true;
-      }
-    }
-  }
-  return out;
-}
-var BAND_ORDER = { fast: 0, mid: 1, strong: 2, flagship: 3 };
-function bandDistance(primary, candidate) {
-  const p = BAND_ORDER[modelBand(primary)];
-  const c = BAND_ORDER[modelBand(candidate)];
-  return Math.abs(c - p) * 2 + (c < p ? 1 : 0);
-}
-function pickFallbacks(primary, pool, n) {
-  const chosen = [];
-  const usedModels = /* @__PURE__ */ new Set([baseModel(primary)]);
-  const usedSources = /* @__PURE__ */ new Set([sourceOf(primary)]);
-  const byHeft = pool.map((m, i) => ({ m, i })).sort((a, b) => bandDistance(primary, a.m) - bandDistance(primary, b.m) || a.i - b.i).map((x) => x.m);
-  for (const m of byHeft) {
-    if (chosen.length >= n) break;
-    if (usedModels.has(baseModel(m)) || usedSources.has(sourceOf(m))) continue;
-    chosen.push(m);
-    usedModels.add(baseModel(m));
-    usedSources.add(sourceOf(m));
-  }
-  for (const m of byHeft) {
-    if (chosen.length >= n) break;
-    if (usedModels.has(baseModel(m))) continue;
-    chosen.push(m);
-    usedModels.add(baseModel(m));
-  }
-  return chosen;
-}
-var FALLBACK_COUNT = 2;
-function adjustRoleModels(roles, models, unfit) {
-  if (models.length === 0) return [];
-  const recognised = models.filter(isKnownModel);
-  const pick = recognised.length ? recognised : models;
-  const capable = dedupBest(pick.filter((m) => !WEAK_RE.test(m)));
-  const fast = dedupBest(pick.filter((m) => WEAK_RE.test(m)));
-  const capablePool = capable.length ? capable : fast;
-  const fastPool = fast.length ? fast : capable;
-  const primaryPool = latestFirst(capablePool);
-  const primaryFast = latestFirst(fastPool);
-  const nonFlagship = primaryPool.filter((m) => modelBand(m) !== "flagship");
-  const strongPool = primaryPool.filter((m) => modelBand(m) === "strong");
-  const midPool = primaryPool.filter((m) => modelBand(m) === "mid");
-  const wanted = new Set(roles);
-  const forRole = (role, pool) => {
-    if (!unfit) return pool;
-    const fit = pool.filter((m) => !unfit(role, m));
-    return fit.length ? fit : pool;
-  };
-  const known = /* @__PURE__ */ new Set([...FLAGSHIP_ROLES, ...STRONG_ROLES, ...MID_ROLES, ...FAST_ROLES]);
-  const primary = /* @__PURE__ */ new Map();
-  const flagSrc = primaryPool;
-  FLAGSHIP_ROLES.filter((r) => wanted.has(r)).forEach((r, i) => {
-    const src = forRole(r, flagSrc);
-    primary.set(r, src[i % src.length]);
-  });
-  const strongSrc = interleaveBySource(strongPool.length ? strongPool : nonFlagship.length ? nonFlagship : primaryPool);
-  STRONG_ROLES.filter((r) => wanted.has(r)).concat(roles.filter((r) => !known.has(r))).forEach((r, i) => {
-    const src = forRole(r, strongSrc);
-    primary.set(r, src[i % src.length]);
-  });
-  const midSrc = interleaveBySource(midPool.length ? midPool : nonFlagship.length ? nonFlagship : primaryPool);
-  MID_ROLES.filter((r) => wanted.has(r)).forEach((r, i) => {
-    const src = forRole(r, midSrc);
-    primary.set(r, src[i % src.length]);
-  });
-  FAST_ROLES.filter((r) => wanted.has(r)).forEach((r, i) => {
-    const src = forRole(r, primaryFast);
-    primary.set(r, src[i % src.length]);
-  });
-  return roles.map((role) => {
-    const head = primary.get(role) ?? primaryPool[0];
-    const capForFb = MID_ROLES.includes(role) ? capablePool.filter((m) => modelBand(m) !== "flagship") : capablePool;
-    const pool = FAST_ROLES.includes(role) ? [...fastPool, ...capForFb] : [...capForFb, ...fastPool];
-    return { role, models: newestPrimary([head, ...pickFallbacks(head, forRole(role, pool), FALLBACK_COUNT)], models) };
-  });
-}
-
-// src/skills/apply.ts
-import { readFile } from "fs/promises";
-import { readdirSync as readdirSync2 } from "fs";
-import { resolve as resolve2, sep as sep3 } from "path";
-import { z } from "zod";
-function applySkills(basePrompt, mandatory, registry) {
-  const parts = [basePrompt];
-  if (mandatory.length) {
-    const sections = mandatory.map((name) => {
-      const skill = registry.get(name);
-      if (!skill) throw new Error(`applySkills: undefined skill: ${name}`);
-      const where = skill.dir ? `
-_Skill base directory: ${skill.dir}_
-` : "";
-      return `## ${skill.name}${where}
-${skill.content}`;
-    });
-    parts.push(`# Mandatory Skills
-${sections.join("\n\n")}`);
-  }
-  const mandatorySet = new Set(mandatory);
-  const available = registry.list().filter((s) => !mandatorySet.has(s.name));
-  if (available.length) {
-    const lines = available.map((s) => `- ${s.name}: ${s.description}`);
-    parts.push(`# Discoverable Skills (call the skill tool to fetch its content)
-${lines.join("\n")}`);
-  }
-  return parts.join("\n\n");
-}
-var skillParams = z.object({
-  name: z.string().describe("The skill's name, exactly as it is listed."),
-  /**
-   * A supporting document inside the skill's own directory, e.g. "reference/critique.md".
-   *
-   * Described, because an undescribed optional string gets filled in. Measured: four consecutive calls sent
-   * `file: ""` and every one of them failed — the skill was there, its content was one branch away, and an
-   * empty string took the other branch.
-   */
-  file: z.string().optional().describe('Optional. A supporting document inside the skill, e.g. "reference/critique.md". Omit it to read the skill itself \u2014 do not pass an empty string.')
-});
-var DOCS_SHOWN = 12;
-function docsIn(dir) {
-  try {
-    return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.name !== "SKILL.md" && !e.name.startsWith(".")).map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort().slice(0, DOCS_SHOWN);
-  } catch {
-    return [];
-  }
-}
-var MAX_SKILL_DOC_CHARS = 3e4;
-var MAX_SKILLS_LISTED = 12;
-function noSuchSkill(name, available) {
-  const shape = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
-  const same = available.filter((s) => shape(s) === shape(name));
-  if (same.length === 1) {
-    return `skill not found: ${name} \u2014 did you mean \`${same[0]}\`? Call it with that exact name.`;
-  }
-  if (!available.length) return `skill not found: ${name}. This project has no skills installed, so carry on without one.`;
-  const near = available.filter((s) => shape(s).includes(shape(name)) || shape(name).includes(shape(s)));
-  if (near.length && near.length <= MAX_SKILLS_LISTED) {
-    return `skill not found: ${name}. Closest by name: ${near.map((s) => `\`${s}\``).join(", ")}. Call one of those exactly if it is what you meant, or carry on without a skill.`;
-  }
-  const shown = available.slice(0, MAX_SKILLS_LISTED);
-  const rest = available.length - shown.length;
-  return `skill not found: ${name}. Available: ${shown.join(", ")}${rest > 0 ? `, and ${rest} more \u2014 the full list is in your system prompt` : ""}. Use one of these exactly, or carry on without a skill \u2014 do not guess another name.`;
-}
-function buildSkillTool(registry) {
-  return {
-    name: "skill",
-    description: 'Fetch a skill\'s content by name. Some skills are dispatchers whose SKILL.md points at supporting documents (e.g. "see reference/critique.md"); pass `file` with that relative path to read one. Fetch a document only when the skill actually sends you to it.',
-    permissionLevel: "safe",
-    parameters: skillParams,
-    run: async (rawArgs) => {
-      const parsed = skillParams.safeParse(rawArgs);
-      if (!parsed.success) {
-        return { content: `skill: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
-      }
-      const { name, file } = parsed.data;
-      const skill = registry.get(name);
-      if (!skill) return { content: noSuchSkill(name, registry.list().map((s) => s.name)), isError: true };
-      if (file === void 0 || !file.trim()) {
-        const where = skill.dir ? `_Skill base directory: ${skill.dir}_
-
-` : "";
-        return { content: `${where}${skill.content}`, isError: false };
-      }
-      if (!skill.dir) return { content: `skill ${name}: has no supporting documents`, isError: true };
-      const target = resolve2(skill.dir, file);
-      const root = resolve2(skill.dir);
-      if (target !== root && !target.startsWith(root + sep3)) {
-        return { content: `skill ${name}: ${file} is outside the skill directory`, isError: true };
-      }
-      let raw;
-      try {
-        raw = await readFile(target, "utf8");
-      } catch {
-        const has = docsIn(skill.dir);
-        return {
-          content: `skill ${name}: no such document: ${file}` + (has.length ? `. It has: ${has.join(", ")}` : `. It has no supporting documents.`),
-          isError: true
-        };
-      }
-      if (raw.length <= MAX_SKILL_DOC_CHARS) return { content: raw, isError: false };
-      return {
-        content: `${raw.slice(0, MAX_SKILL_DOC_CHARS)}
-
-[skill ${name}/${file}: truncated at ${MAX_SKILL_DOC_CHARS} of ${raw.length} chars]`,
-        isError: false
-      };
-    }
-  };
-}
-
 // src/engine/unfinished.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync, statSync } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync, statSync } from "fs";
 import { join as join3 } from "path";
 function boardCounts(dir) {
   try {
@@ -1647,7 +904,7 @@ function unfinishedSessions(cwd, commitCount = () => 0) {
   const root = join3(cwd, ".horsecode", "worktrees");
   if (!existsSync3(root)) return [];
   const out = [];
-  for (const id of readdirSync3(root)) {
+  for (const id of readdirSync2(root)) {
     const dir = join3(root, id);
     try {
       if (!statSync(dir).isDirectory()) continue;
@@ -1684,7 +941,7 @@ function describeUnfinished(s) {
 
 // src/tools/git.ts
 import { execFile } from "child_process";
-import { z as z2 } from "zod";
+import { z } from "zod";
 var READ_ONLY = /* @__PURE__ */ new Set([
   "status",
   "log",
@@ -1755,8 +1012,8 @@ var READ_ONLY_PAIRS = /* @__PURE__ */ new Set([
   "stash show"
 ]);
 var REFUSED_ARG = /^(--output|-c$|--config-env|--exec-path|-C$|--git-dir|--work-tree|--upload-pack|--receive-pack)/;
-var params = z2.object({
-  args: z2.array(z2.string()).min(1).describe(
+var params = z.object({
+  args: z.array(z.string()).min(1).describe(
     'Git arguments as a list, without the leading "git" \u2014 e.g. ["status","--porcelain"] or ["log","-5","--oneline"].'
   )
 });
@@ -1925,7 +1182,7 @@ var gitTool = {
     const args = parsed.data.args;
     const why = refuse(args);
     if (why) return { content: why, isError: true, settled: true };
-    const out = await new Promise((resolve6) => {
+    const out = await new Promise((resolve5) => {
       const child = execFile("git", args, {
         cwd: ctx.cwd,
         timeout: GIT_TIMEOUT_MS,
@@ -1935,7 +1192,7 @@ var gitTool = {
         env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat", GIT_TERMINAL_PROMPT: "0" }
       }, (err, stdout, stderr) => {
         const text = `${stdout}${stderr}`.trim();
-        resolve6({ code: err?.code ?? (err ? 1 : 0), text });
+        resolve5({ code: err?.code ?? (err ? 1 : 0), text });
       });
       ctx.signal?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
     });
@@ -1996,7 +1253,7 @@ var gitWriteTool = {
     const args = parsed.data.args;
     const why = refuseWrite(args);
     if (why) return { content: why, isError: true, settled: true };
-    const out = await new Promise((resolve6) => {
+    const out = await new Promise((resolve5) => {
       const child = execFile("git", args, {
         cwd: ctx.cwd,
         // A push talks to a server: the read tool's 30s is a reasonable ceiling for a local query and a
@@ -2007,7 +1264,7 @@ var gitWriteTool = {
         // prompt no one can see — the TUI owns the terminal, so the agent would simply hang.
         env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat", GIT_TERMINAL_PROMPT: "0" }
       }, (err, stdout, stderr) => {
-        resolve6({ code: err ? 1 : 0, text: `${stdout}${stderr}`.trim() });
+        resolve5({ code: err ? 1 : 0, text: `${stdout}${stderr}`.trim() });
       });
       ctx.signal?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
     });
@@ -2019,9 +1276,9 @@ var gitWriteTool = {
 };
 
 // src/tools/remember.ts
-import { z as z3 } from "zod";
-var params2 = z3.object({
-  fact: z3.string().describe(
+import { z as z2 } from "zod";
+var params2 = z2.object({
+  fact: z2.string().describe(
     "One short sentence, durable and project-specific: where something lives, which command builds it, a convention this codebase follows, a schema detail that cost you a search. Not what you did, not what is true of the language in general \u2014 something the next agent would otherwise have to rediscover."
   )
 });
@@ -2046,7 +1303,7 @@ function buildRememberTool(sink) {
 var rememberFactTool = buildRememberTool();
 
 // src/speckit/layout.ts
-import { existsSync as existsSync4, mkdirSync, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync4, mkdirSync, readdirSync as readdirSync3 } from "fs";
 import { join as join4 } from "path";
 function specsDir(workdir) {
   return join4(workdir, "specs");
@@ -2091,7 +1348,7 @@ function featureSlugFor(workdir, title) {
   const want = toSlug(title);
   const dir = specsDir(workdir);
   if (existsSync4(dir)) {
-    const names = readdirSync4(dir);
+    const names = readdirSync3(dir);
     for (const name of names) {
       if (name.replace(/^\d+-/, "") === want) return name;
     }
@@ -2109,7 +1366,7 @@ function nextFeatureSlug(workdir, title) {
   const dir = specsDir(workdir);
   let max = 0;
   if (existsSync4(dir)) {
-    for (const name of readdirSync4(dir)) {
+    for (const name of readdirSync3(dir)) {
       const m = name.match(/^(\d+)-/);
       if (m) max = Math.max(max, Number(m[1]));
     }
@@ -2127,7 +1384,7 @@ function scaffoldFeature(workdir, slug) {
 import { createHash } from "crypto";
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join5 } from "path";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/engine/constitution.ts
 var SCOPES = ["always", "backend", "frontend", "data", "infra", "docs", "review", "spec", "test", "govern"];
@@ -2263,10 +1520,10 @@ function labellingLooksWrong(scoped) {
 }
 
 // src/engine/constitution-store.ts
-var LabelsSchema = z4.object({
-  labels: z4.array(z4.object({
-    index: z4.number().int().describe("The rule's number, exactly as given to you."),
-    scopes: z4.array(z4.enum(SCOPES)).describe(
+var LabelsSchema = z3.object({
+  labels: z3.array(z3.object({
+    index: z3.number().int().describe("The rule's number, exactly as given to you."),
+    scopes: z3.array(z3.enum(SCOPES)).describe(
       `Which kinds of work this rule actually binds. Only the ones it really governs: a rule that reaches everyone is carried into every agent's prompt, so a scope added "to be safe" is paid for on every call that will never use it.`
     )
   }))
@@ -2354,12 +1611,12 @@ async function constitutionNote(deps, cwd, work) {
 }
 
 // src/engine/reviewer.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 
 // src/tools/find-tool.ts
-import { z as z5 } from "zod";
-var params3 = z5.object({
-  query: z5.string().describe(
+import { z as z4 } from "zod";
+var params3 = z4.object({
+  query: z4.string().describe(
     'What you need a tool for, in a few words \u2014 e.g. "pull request comments", "list angular projects". Or an exact tool name to fetch just that one.'
   )
 });
@@ -2447,8 +1704,8 @@ ${rows.join("\n")}`,
 // src/tools/unfinished-tool.ts
 import { execFileSync } from "child_process";
 import { join as join6 } from "path";
-import { z as z6 } from "zod";
-var params4 = z6.object({});
+import { z as z5 } from "zod";
+var params4 = z5.object({});
 function commitsAhead(cwd, branch) {
   try {
     const out = execFileSync(
@@ -2497,10 +1754,10 @@ To continue one of these, the user says **continue** \u2014 that reopens the ses
 };
 
 // src/tools/propose-memory.ts
-import { z as z7 } from "zod";
-var params5 = z7.object({
-  text: z7.string(),
-  kind: z7.enum(["fact", "lesson"]).optional().describe(
+import { z as z6 } from "zod";
+var params5 = z6.object({
+  text: z6.string(),
+  kind: z6.enum(["fact", "lesson"]).optional().describe(
     "`fact`: something true about this project that a later run would otherwise have to rediscover (where something lives, which command builds it). `lesson`: something learned the hard way \u2014 an approach that failed and what to do instead."
   )
 });
@@ -2756,11 +2013,11 @@ async function diffSince(cwd, sinceRef, git = defaultGitRunner) {
 // src/engine/reviewer.ts
 var CODE_REVIEW_MAX_TURNS = 25;
 var CODE_REVIEW_TIMEOUT_MS = 10 * 60 * 1e3;
-var VerdictSchema = z8.object({
-  verdict: z8.enum(["pass", "fail"]).describe(
+var VerdictSchema = z7.object({
+  verdict: z7.enum(["pass", "fail"]).describe(
     "`fail` only if the code does not do what the task required, or does it wrongly. Style you would have written differently is a note on a `pass` \u2014 a fail sends the task back around the whole cycle."
   ),
-  notes: z8.array(z8.string())
+  notes: z7.array(z7.string())
 });
 function readOnlyRegistry(deps, opts = {}) {
   const r = new ToolRegistry();
@@ -2828,9 +2085,9 @@ ${describeDiff(diff)}` };
 // src/tools/write.ts
 import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname3, resolve as resolve3, sep as sep4 } from "path";
-import { z as z9 } from "zod";
-var params6 = z9.object({ path: z9.string(), content: z9.string() });
+import { dirname as dirname3, resolve as resolve2, sep as sep3 } from "path";
+import { z as z8 } from "zod";
+var params6 = z8.object({ path: z8.string(), content: z8.string() });
 var writeFileTool = {
   name: "write_file",
   description: "Writes content to a file (creates parent directories). Creating a NEW file is always allowed; to OVERWRITE an existing file you must read_file it first in this run \u2014 otherwise the write is refused.",
@@ -2849,9 +2106,9 @@ var writeFileTool = {
       };
     }
     const a = parsed.data;
-    const target = resolve3(ctx.cwd, a.path);
-    const cwdResolved = resolve3(ctx.cwd);
-    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep4)) {
+    const target = resolve2(ctx.cwd, a.path);
+    const cwdResolved = resolve2(ctx.cwd);
+    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep3)) {
       return { content: `write_file: path is outside cwd: ${a.path}`, isError: true };
     }
     if (ctx.readFiles && existsSync6(target) && !ctx.readFiles.has(target)) {
@@ -2879,21 +2136,21 @@ var writeFileTool = {
 };
 
 // src/tools/edit.ts
-import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve4, sep as sep5 } from "path";
-import { z as z10 } from "zod";
-var params7 = z10.object({
-  path: z10.string(),
-  oldString: z10.string(),
-  newString: z10.string(),
-  replaceAll: z10.boolean().optional()
+import { readFile, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve3, sep as sep4 } from "path";
+import { z as z9 } from "zod";
+var params7 = z9.object({
+  path: z9.string(),
+  oldString: z9.string(),
+  newString: z9.string(),
+  replaceAll: z9.boolean().optional()
 });
 var NEAR_MISS_CHARS = 600;
 var MAX_MATCH_LINES = 5;
 var norm = (t) => t.replace(/[ \t]+/g, " ").replace(/[ \t]+$/gm, "").trim();
 function shortPath(path, cwd) {
-  const abs = resolve4(cwd, path);
-  return abs === cwd ? "." : abs.startsWith(cwd + sep5) ? abs.slice(cwd.length + 1) : path;
+  const abs = resolve3(cwd, path);
+  return abs === cwd ? "." : abs.startsWith(cwd + sep4) ? abs.slice(cwd.length + 1) : path;
 }
 function whyNotFound(content, oldString) {
   if (/^\s*\d+\t/m.test(oldString)) {
@@ -2934,14 +2191,14 @@ var editFileTool = {
       };
     }
     const a = parsed.data;
-    const target = resolve4(ctx.cwd, a.path);
-    const cwdResolved = resolve4(ctx.cwd);
-    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep5)) {
+    const target = resolve3(ctx.cwd, a.path);
+    const cwdResolved = resolve3(ctx.cwd);
+    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep4)) {
       return { content: `edit_file: path is outside cwd: ${a.path}`, isError: true };
     }
     let content;
     try {
-      content = await readFile2(target, "utf8");
+      content = await readFile(target, "utf8");
     } catch (e) {
       return {
         content: `edit_file error: ${e instanceof Error ? e.message : String(e)}`,
@@ -2988,13 +2245,13 @@ var editFileTool = {
 };
 
 // src/tools/shell.ts
-import { spawn as spawn2 } from "child_process";
-import { resolve as resolve5, sep as sep6 } from "path";
-import { z as z11 } from "zod";
-var params8 = z11.object({
-  command: z11.string(),
+import { spawn } from "child_process";
+import { resolve as resolve4, sep as sep5 } from "path";
+import { z as z10 } from "zod";
+var params8 = z10.object({
+  command: z10.string(),
   /** Milliseconds before the command is killed. Defaults to DEFAULT_TIMEOUT_MS, capped at MAX_TIMEOUT_MS. */
-  timeout: z11.number().int().positive().optional()
+  timeout: z10.number().int().positive().optional()
 });
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_TIMEOUT_MS = 6e5;
@@ -3029,7 +2286,7 @@ var REWRITES = [
 ];
 var REDIRECT = /(?:^|[^0-9<>&])>>?\s*(?!\/dev\/|\/tmp\/|&)([A-Za-z0-9_./-]*\.[A-Za-z0-9]+)/;
 function leavesWorkdir(command, cwd) {
-  const base = resolve5(cwd);
+  const base = resolve4(cwd);
   let at = base;
   for (const seg of command.split(/&&|\|\||;|\|/)) {
     const m = /^\s*(?:cd|pushd)(?:\s+(.*))?$/.exec(seg.trim());
@@ -3037,8 +2294,8 @@ function leavesWorkdir(command, cwd) {
     const raw = (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     if (!raw || raw === "~" || raw === "$HOME" || raw.startsWith("~/")) return raw || "~";
     if (raw === "-") return "-";
-    at = resolve5(at, raw);
-    if (at !== base && !at.startsWith(base + sep6)) return raw;
+    at = resolve4(at, raw);
+    if (at !== base && !at.startsWith(base + sep5)) return raw;
   }
   return void 0;
 }
@@ -3105,7 +2362,7 @@ var shellTool = {
     return new Promise((resolvePromise) => {
       let child;
       try {
-        child = spawn2(a.command, {
+        child = spawn(a.command, {
           cwd: ctx.cwd,
           shell: true,
           signal: ctx.signal,
@@ -3169,8 +2426,8 @@ ${body}${tail}`, isError: timedOut || code !== 0 });
 };
 
 // src/tools/web.ts
-import { z as z12 } from "zod";
-var params9 = z12.object({ url: z12.string().url() });
+import { z as z11 } from "zod";
+var params9 = z11.object({ url: z11.string().url() });
 var MAX_CHARS = 1e5;
 function createWebFetchTool(fetchFn = globalThis.fetch) {
   return {
@@ -3245,8 +2502,8 @@ async function refreshTraces(opts) {
   }
   const targets = candidates.filter((f) => !gone.includes(f));
   if (!targets.length) return out;
-  const model = opts.models.find(Boolean);
-  if (!model) return out;
+  const chain = opts.models.filter(Boolean);
+  if (!chain.length) return out;
   try {
     const g = await buildProjectGraph(opts.cwd);
     out.graph = g.message;
@@ -3259,7 +2516,7 @@ async function refreshTraces(opts) {
     const res = await runTraces({
       cwd: opts.cwd,
       provider: opts.provider,
-      model,
+      models: chain,
       plan,
       // No liveFiles: this run knows only the files one task changed, and a pruner given that list would
       // read every OTHER trace in the project as orphaned and delete it.
@@ -3293,14 +2550,14 @@ async function commitRefreshed(git, baseWorktree, traceRootRel2) {
 }
 
 // src/engine/writer-registry.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 
 // src/engine/normalize-question.ts
-import { z as z13 } from "zod";
-var NormalizedQuestionSchema = z13.object({
-  question: z13.string().describe("The core question, concise, WITHOUT the embedded options table/list."),
-  options: z13.array(z13.string()).describe("Each selectable choice as a SHORT label; the recommended one first, suffixed ' (recommended)'. Empty when the question is genuinely open-ended."),
-  multiSelect: z13.boolean().describe("true only if the user may pick more than one.")
+import { z as z12 } from "zod";
+var NormalizedQuestionSchema = z12.object({
+  question: z12.string().describe("The core question, concise, WITHOUT the embedded options table/list."),
+  options: z12.array(z12.string()).describe("Each selectable choice as a SHORT label; the recommended one first, suffixed ' (recommended)'. Empty when the question is genuinely open-ended."),
+  multiSelect: z12.boolean().describe("true only if the user may pick more than one.")
 });
 var PROMPT = "You reformat an agent's question for a terminal UI that renders selectable options (arrow keys + Enter). Given the raw question text \u2014 which may embed choices as a markdown table, an A/B/C/D list, or a 'recommended' suggestion \u2014 extract exactly:\n- `question`: the core question, concise, WITHOUT the embedded options table/list.\n- `options`: each selectable choice as a SHORT label. If one choice is recommended, list it FIRST and append ' (recommended)'. Do NOT add an 'other' / free-text / 'answer in your own words' option \u2014 the UI already provides that.\n- `multiSelect`: true only if the user may pick several.\nIf the text is genuinely open-ended (no discrete choices), return options: []. Preserve the user's language. Return the result via submit.";
 function looksLikeChoices(text) {
@@ -3367,21 +2624,21 @@ var clipLabel = (body) => {
 };
 
 // src/engine/writer-registry.ts
-var askUserParams = z14.object({
-  question: z14.string(),
+var askUserParams = z13.object({
+  question: z13.string(),
   // For a multiple-choice question, list the choices here → the UI shows a selectable checkbox/radio list
   // (arrow keys + Enter) instead of a free-text box. Omit for an open-ended question.
   //
   // A choice may be a plain string, or an object carrying what the label alone cannot say: a one-line
   // `description`, and a `preview` rendered in a panel beside the list while that option is focused. Use the
   // rich form when the decision turns on the trade-offs rather than the name (e.g. "which approach?").
-  options: z14.array(z14.union([
-    z14.string(),
-    z14.object({ label: z14.string(), description: z14.string().optional(), preview: z14.string().optional() })
+  options: z13.array(z13.union([
+    z13.string(),
+    z13.object({ label: z13.string(), description: z13.string().optional(), preview: z13.string().optional() })
   ])).optional().describe(
     "The choices, when the question has discrete answers \u2014 the UI renders a selectable list instead of a free-text box. Omit for an open-ended question. A choice may be a plain string, or an object with a one-line `description` and a `preview` shown beside the list; use the rich form when the decision turns on trade-offs rather than on the name."
   ),
-  multiSelect: z14.boolean().optional().describe(
+  multiSelect: z13.boolean().optional().describe(
     "True when the user may pick more than one (checkboxes); omitted means pick exactly one (radio)."
   ),
   /**
@@ -3390,7 +2647,7 @@ var askUserParams = z14.object({
    * Present ⇒ this is a hand-off, not a question: the run has stopped because only a person can carry the
    * next step, and the UI says so rather than showing a bare "? Question".
    */
-  steps: z14.array(z14.string()).optional().describe(
+  steps: z13.array(z13.string()).optional().describe(
     'What the user has to DO before they can answer \u2014 one action per entry. Supplying this makes it a HAND-OFF rather than a question: the run has stopped because only a person can carry the next step, and the UI says so instead of showing a bare "? Question". Use it whenever you are asking someone to go and perform something and report back; leave it out when you only want an answer.'
   )
 });
@@ -3589,7 +2846,7 @@ var RoleFitness = class {
 };
 
 // src/engine/routing.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 
 // src/engine/route-role.ts
 var STYLE_EXT = [".css", ".scss", ".sass", ".less", ".styl"];
@@ -3656,8 +2913,8 @@ function routeByEvidence(card) {
 }
 
 // src/engine/routing.ts
-var RouteSchema = z15.object({
-  role: z15.enum(["coder", "designer"]).describe(
+var RouteSchema = z14.object({
+  role: z14.enum(["coder", "designer"]).describe(
     "Who should implement this. `designer` when the work IS how the thing looks or behaves to a person \u2014 layout, spacing, colour, copy, interaction. `coder` for everything else. Judge by what the work is, not by the file type: a component file holding a data hook is code work; a component file whose whole job is appearance is design work."
   )
 });
@@ -3719,9 +2976,9 @@ function createDefaultRegistry() {
 }
 
 // src/engine/operational.ts
-import { z as z16 } from "zod";
-var CommitSchema = z16.object({
-  message: z16.string().describe("A Conventional Commits message: `type(scope): subject`, English, imperative.")
+import { z as z15 } from "zod";
+var CommitSchema = z15.object({
+  message: z15.string().describe("A Conventional Commits message: `type(scope): subject`, English, imperative.")
 });
 var MAX_DIFF = 12e3;
 var OPERATIONAL_MAX_TURNS = 3;
@@ -3967,14 +3224,14 @@ function deadlineWarning(elapsedMs, budgetMs) {
 }
 var MAX_WRITTEN_CHARS = 6e4;
 async function writtenText(cwd, touched) {
-  const { readFile: readFile4 } = await import("fs/promises");
+  const { readFile: readFile3 } = await import("fs/promises");
   const { join: join10 } = await import("path");
   const parts = [];
   let used = 0;
   for (const p of [...new Set(touched)]) {
     if (used >= MAX_WRITTEN_CHARS) break;
     try {
-      const t = await readFile4(join10(cwd, p), "utf8");
+      const t = await readFile3(join10(cwd, p), "utf8");
       parts.push(t.slice(0, MAX_WRITTEN_CHARS - used));
       used += t.length;
     } catch {
@@ -4169,391 +3426,18 @@ ${handOver}`;
 // src/engine/review.ts
 import { existsSync as existsSync8 } from "fs";
 import { isAbsolute, join as join8 } from "path";
-import { z as z17 } from "zod";
-
-// src/agent/roles.ts
-function isTransientFailure(reason) {
-  const r = reason.toLowerCase();
-  if (/\b(429|rate.?limit|quota|exhaust|insufficient|billing|credit)\b/.test(r)) return false;
-  return /overload|529|50[0234]|timeout|timed out|deadline|econnreset|epipe|socket hang up|stream ended|temporar|unavailable|try again/.test(r);
-}
-function isSourceCapacity(reason) {
-  return /capacity is (?:temporarily unavailable|busy)/i.test(reason);
-}
-function sourcePrefix(model) {
-  const s = model.replace(/^no-think\//, "");
-  const cli = cliFor(s);
-  if (cli) return cli;
-  const i = s.indexOf("/");
-  return i > 0 ? s.slice(0, i) : void 0;
-}
-function weightedCycle(sources, weights) {
-  const queues = sources.map((s) => Array(Math.max(1, weights[s] ?? 1)).fill(s));
-  const out = [];
-  for (let more = true; more; ) {
-    more = false;
-    for (const q of queues) {
-      const m = q.shift();
-      if (m !== void 0) {
-        out.push(m);
-        more = true;
-      }
-    }
-  }
-  return out;
-}
-function canonicalSource(name) {
-  const s = name.toLowerCase().replace(/^no-think\//, "");
-  if (s === "cc" || s === "claude") return "claude";
-  if (s === "cx") return "codex";
-  return sourcePrefix(s) ?? s;
-}
-function providerOutage(reason) {
-  return /no active credentials for provider:?\s*([\w.-]+)/i.exec(reason)?.[1] ?? /provider\s+'?([\w.-]+)'?\s+is not configured/i.exec(reason)?.[1] ?? /all\s+([\w.-]+)\s+accounts have exhausted their quota/i.exec(reason)?.[1] ?? /shared egress ip quota exhausted\s*\(([\w.-]+)\)/i.exec(reason)?.[1] ?? /^\s*(claude|codex)\s+CLI:\s*rejected\b/i.exec(reason)?.[1]?.toLowerCase();
-}
-function quotaResetAt(reason) {
-  const iso = /\(resets\s+([0-9T:.\-]+Z)\)/i.exec(reason)?.[1];
-  const t = iso ? Date.parse(iso) : NaN;
-  return Number.isFinite(t) ? t : void 0;
-}
-var RoleRegistry = class _RoleRegistry {
-  // durable behavioral rules → appended to EVERY role's prompt
-  constructor(roles, defaultPrompts = {}, skillRegistry) {
-    this.roles = roles;
-    this.defaultPrompts = defaultPrompts;
-    this.skillRegistry = skillRegistry;
-  }
-  roles;
-  defaultPrompts;
-  skillRegistry;
-  modelOverride;
-  roleOverrides = /* @__PURE__ */ new Map();
-  // per-role model CHAIN override (highest priority)
-  effortOverrides = /* @__PURE__ */ new Map();
-  // Models that failed retryably (429/5xx/quota) → skipped in every chain until released. Kept WITH the
-  // reason and the time so a coordinator can report them and later re-probe whether the limit has reset.
-  quarantine = /* @__PURE__ */ new Map();
-  notify;
-  // fallback UI note sink (wired once the controller exists)
-  onQuarantine;
-  /** What each model has actually managed to do in each ROLE — see setFitness. */
-  fitness;
-  // Models that answered in prose instead of calling the submit tool. Not a transport error, so nothing ever
-  // benched them: the chain quietly slid to the fallback on EVERY call, forever, in every role that held them.
-  strikes = /* @__PURE__ */ new Map();
-  rulesProvider;
-  /** Every configured role name — used to validate a role reference produced by a model (memory audiences). */
-  names() {
-    return [.../* @__PURE__ */ new Set([...Object.keys(this.roles), ...Object.keys(this.defaultPrompts)])];
-  }
-  /** Wire the fallback-note sink (called after the controller exists). */
-  setNotify(fn) {
-    this.notify = fn;
-  }
-  /** Wire the durable-rules source (memory). Rules are appended to every role's system prompt (always honored). */
-  setRules(fn) {
-    this.rulesProvider = fn;
-  }
-  /** The rule block to append to a role's prompt — empty when there are no rules. Public so prompt-supplying
-   *  callers (spec-kit phases build their own prompt) can append it too. */
-  ruleSuffix() {
-    const rules = this.rulesProvider?.() ?? [];
-    return rules.length ? `
-
-User rules (ALWAYS honor these):
-${rules.map((r) => `- ${r}`).join("\n")}` : "";
-  }
-  /** Live-swap the model used by every role (session-only; clears on undefined/empty). */
-  setModelOverride(model) {
-    this.modelOverride = model && model.length > 0 ? model : void 0;
-  }
-  /** Live-swap the model CHAIN of ONE role (session-only; wins over the global override). Clears on empty. */
-  setRoleModel(roleName, models) {
-    const chain = (typeof models === "string" ? [models] : models ?? []).filter((m) => m.length > 0);
-    if (chain.length) this.roleOverrides.set(roleName, chain);
-    else this.roleOverrides.delete(roleName);
-  }
-  /**
-   * How hard this role should work, set alongside its chain.
-   *
-   * An override on the live registry rather than a config re-read, for the same reason `setRoleModel` is one:
-   * `/roles adjust` has to take effect in the session that ran it, not only in the next one.
-   *
-   * `undefined` REMOVES it — a role reassigned from a Claude model to one whose effort cannot be set must
-   * stop carrying a level, or the config keeps a number that no longer applies to anything.
-   */
-  setRoleEffort(roleName, effort) {
-    if (effort) this.effortOverrides.set(roleName, effort);
-    else this.effortOverrides.delete(roleName);
-  }
-  /**
-   * Wire the record of what each model has actually managed to do in each role.
-   *
-   * Without it a chain is only a list of names from a catalogue. With it, a model that has twice answered
-   * this role in prose instead of doing its work stops being offered to this role — while staying available
-   * to every other role, where it may be perfectly good.
-   */
-  setFitness(f) {
-    this.fitness = f;
-  }
-  /** Wire the quarantine hook: whatever benches a model, every role still holding it must be re-assigned. */
-  setOnQuarantine(fn) {
-    this.onQuarantine = fn;
-  }
-  /** Mark a model spent — every chain skips it from now on, until it is released. */
-  markExhausted(model, reason = "unavailable", now = Date.now(), until) {
-    if (!model || this.isQuarantined(model)) return;
-    const ends = until ?? (isTransientFailure(reason) ? now + _RoleRegistry.TRANSIENT_BENCH_MS : void 0);
-    this.quarantine.set(model, { at: now, reason, ...ends !== void 0 && { until: ends } });
-    this.onQuarantine?.(model, reason, ends);
-  }
-  /** Every model any role's chain names — the pool this registry can actually reach for. */
-  knownModels() {
-    return [...new Set(Object.values(this.roles).flatMap((r) => r.models ?? []))];
-  }
-  /**
-   * Benches every model of one provider, for a failure that is about the provider itself.
-   *
-   * Returns what it took out, so the caller can say so once instead of six times. Falls back to benching the
-   * single model when the pool names none of that provider — an unknown provider is still a real failure.
-   */
-  markProviderExhausted(provider, model, reason, now = Date.now()) {
-    const want = canonicalSource(provider);
-    const hit = this.knownModels().filter((m) => sourcePrefix(m) === want);
-    const until = quotaResetAt(reason);
-    for (const m of hit) this.markExhausted(m, reason, now, until);
-    if (!hit.length) {
-      this.markExhausted(model, reason, now);
-      return [model];
-    }
-    return hit;
-  }
-  /**
-   * How long a BEHAVIOURAL bench lasts before the model is tried again.
-   *
-   * A model that is out of quota is out until the quota returns, and nothing here can shorten that. A model
-   * that answered in prose is a different case entirely: the transport was fine, and the next prompt may not
-   * be the one it stumbled on. Benching it for the rest of a multi-hour run costs every role that held it —
-   * measured live, one such bench re-assigned SIXTEEN roles away from the best model available.
-   */
-  static STRUCTURAL_BENCH_MS = 10 * 6e4;
-  /**
-   * How long a TRANSPORT bench lasts — the busy server, not the spent subscription.
-   *
-   * The argument above, one door over. A model that answered in prose gets ten minutes because the transport
-   * was fine; a model whose transport said "Overloaded" for one second is the same case in its purest form,
-   * and it was the one getting benched for the whole session.
-   *
-   * Measured live, in the middle of a feature run: `cc/claude-opus-5` served five calls in the preceding two
-   * minutes (23.8s, 2.9s, 3.1s, 25.3s, 38.7s, all ok), then one 529 in 1.7 seconds — and 18 roles were moved
-   * off the best model in the fleet for the rest of the session. A 529 is the textbook transient condition;
-   * the API's own guidance for it is to retry with backoff.
-   *
-   * Two minutes: long enough that a genuinely struggling gateway is not hammered, short enough that a
-   * one-second blip costs a couple of turns rather than an afternoon.
-   */
-  static TRANSIENT_BENCH_MS = 2 * 6e4;
-  /**
-   * How many structured failures a model gets before it is benched. One miss can be a genuinely hard prompt;
-   * a pattern is the model. Low, because every strike costs a full wasted pass in every role that holds it.
-   */
-  static STRUCTURAL_STRIKES = 2;
-  /**
-   * Records that a model finished a turn WITHOUT producing the structured result it was asked for (prose
-   * instead of a tool call). This is not "unavailable" — the transport was fine — so it never reached the
-   * retryable path that benches a model, and the chain slid to the fallback on every single call instead.
-   * Returns the strike count; at the threshold the model is quarantined like any other spent one.
-   */
-  markStructuralFailure(model, reason = "no valid structured result", role) {
-    if (!model) return 0;
-    const key2 = role ? `${model}::${role}` : model;
-    const n = (this.strikes.get(key2) ?? 0) + 1;
-    this.strikes.set(key2, n);
-    if (n < _RoleRegistry.STRUCTURAL_STRIKES) return n;
-    if (role) {
-      this.fitness?.record?.(role, model, reason);
-      const rolesFailed = [...this.strikes.entries()].filter(([k, v]) => k.startsWith(`${model}::`) && v >= _RoleRegistry.STRUCTURAL_STRIKES).length;
-      if (rolesFailed >= _RoleRegistry.STRUCTURAL_ROLES_BEFORE_BENCH) {
-        this.markExhausted(
-          model,
-          `${reason} (in ${rolesFailed} roles)`,
-          Date.now(),
-          Date.now() + _RoleRegistry.STRUCTURAL_BENCH_MS
-        );
-      }
-      return n;
-    }
-    this.markExhausted(model, reason, Date.now(), Date.now() + _RoleRegistry.STRUCTURAL_BENCH_MS);
-    return n;
-  }
-  /**
-   * How many DISTINCT roles must reject a model this way before it is benched outright.
-   *
-   * Two, because one role can have a prompt that a good model reads badly — and the fitness record already
-   * takes it out of that role. A second, unrelated role failing the same way is the first evidence that the
-   * model, not the prompt, is the problem.
-   */
-  static STRUCTURAL_ROLES_BEFORE_BENCH = 2;
-  /** Models currently quarantined, with why and when — surfaced to the user and re-probed before an adjust. */
-  quarantined() {
-    return [...this.quarantine].map(([model, q]) => ({ model, ...q }));
-  }
-  isQuarantined(model, now = Date.now()) {
-    const q = this.quarantine.get(model);
-    if (!q) return false;
-    if (q.until !== void 0 && now >= q.until) {
-      this.quarantine.delete(model);
-      this.strikes.clear();
-      return false;
-    }
-    return true;
-  }
-  /** Put a model back in play (its quota reset, or the user forced it). */
-  release(model) {
-    this.strikes.delete(model);
-    return this.quarantine.delete(model);
-  }
-  /**
-   * Roles whose CURRENT chain still contains `model`. When a model is quarantined these are the roles that
-   * would otherwise keep resolving to a dead chain, so they are exactly the ones to re-assign.
-   */
-  rolesUsing(model) {
-    return this.names().filter((r) => this.rawChain(r).includes(model));
-  }
-  /**
-   * The role's chain BEFORE quarantine filtering — what was actually assigned to it.
-   *
-   * The order is the documented one and nothing precedes it: per-role override, then the session model, then
-   * the config. It used to bail on an empty CONFIG chain before either override was consulted, which made a
-   * role the config had never heard of impossible to assign — the one case where assigning is the whole
-   * point. Measured with `tester`, added in a version the user's config predated: `/roles adjust` set the
-   * override, the override was skipped, and the role stayed broken for the rest of the session while the
-   * error message recommended running `/roles adjust`.
-   */
-  rawChain(roleName) {
-    const perRole = this.roleOverrides.get(roleName);
-    if (perRole && perRole.length) return perRole;
-    if (this.modelOverride && roleName !== "refiner") return [this.modelOverride];
-    return this.roles[roleName]?.models ?? [];
-  }
-  /** True when every model assigned to this role is quarantined — the chain has collapsed and needs replacing. */
-  chainCollapsed(roleName) {
-    const raw = this.rawChain(roleName);
-    return raw.length > 0 && raw.every((m) => this.isQuarantined(m));
-  }
-  /** The full model chain for a role by priority: per-role override → global override (non-refiner) → config. */
-  chain(roleName) {
-    const base = this.rawChain(roleName);
-    if (!base.length) return [];
-    const live = base.filter((m) => !this.isQuarantined(m));
-    const usable = live.length ? live : base;
-    const fit = this.fitness ? usable.filter((m) => !this.fitness.unfit(roleName, m)) : usable;
-    return fit.length ? fit : usable;
-  }
-  /**
-   * The role's chain ROTATED by `slot`. Parallel workers share one role — five implementers in a wave are all
-   * `coder` — so every one of them resolved to the same chain head and hammered a single subscription until it
-   * rate-limited. Rotating gives each worker a different lead model while keeping its FULL fallback set, so
-   * spreading the load costs no resilience.
-   */
-  chainFor(roleName, slot = 0) {
-    const c = this.chain(roleName);
-    if (c.length < 2) return c;
-    const order = [];
-    for (const m of c) {
-      const s = sourceOf(m);
-      if (!order.includes(s)) order.push(s);
-    }
-    const cycle = weightedCycle(order, this.sourceWeights?.() ?? {});
-    if (cycle.length) {
-      const want = cycle[(slot % cycle.length + cycle.length) % cycle.length];
-      const i = c.findIndex((m) => sourceOf(m) === want);
-      if (i > 0) return [c[i], ...c.filter((_, j) => j !== i)];
-      if (i === 0) return c;
-    }
-    const k = (slot % c.length + c.length) % c.length;
-    return k === 0 ? c : [...c.slice(k), ...c.slice(0, k)];
-  }
-  /** How many accounts each source has connected — set at the composition root; equal weights without it. */
-  sourceWeights;
-  /** Wire the account weights (called once the pool exists). */
-  setSourceWeights(fn) {
-    this.sourceWeights = fn;
-  }
-  /** The model a role would use next (chain head), for UI display only. */
-  peekModel(roleName) {
-    return this.chain(roleName)[0] ?? "";
-  }
-  /**
-   * The chain (primary + fallbacks) and session-fallback hooks for a role, WITHOUT its system prompt —
-   * for callers that supply their own prompt (e.g. spec-kit phases). resolve() layers the prompt on top.
-   */
-  fallbackOpts(roleName) {
-    const chain = this.chain(roleName);
-    const notify = this.notify;
-    const effort = this.effortOverrides.get(roleName) ?? this.roles[roleName]?.effort;
-    return {
-      // Travels with the chain, not with the prompt: the seven callers that take only the chain are exactly
-      // the ones whose work is heaviest (the tester, the analyst, the spec-kit phases).
-      ...effort ? { effort } : {},
-      /**
-       * The name belongs to the CHAIN, not to the prompt.
-       *
-       * It was put on `resolve()` alone, on the assumption that every caller spreads a resolved role. Seven
-       * do not: they take the chain from here and supply their own prompt (the spec-kit phases, the tester,
-       * the analyst, the question normalizer). Measured on the first run after the change — 19 tool calls,
-       * one of them attributed. Everything the attribution was for happens in those seven.
-       */
-      role: roleName,
-      model: chain[0] ?? "",
-      fallbacks: chain.slice(1),
-      onExhausted: (m, reason) => {
-        const why = reason ?? "unavailable";
-        const source = providerOutage(why) ?? (isSourceCapacity(why) ? sourcePrefix(m) : void 0);
-        if (source) this.markProviderExhausted(source, m, why);
-        else this.markExhausted(m, why);
-      },
-      onStructuralFailure: (m, reason) => this.markStructuralFailure(m, reason, roleName),
-      onFallback: notify ? (from, to, reason) => notify(`\u2935 \`${from}\` \u2192 \`${to}\` \u2014 ${reason}`) : void 0
-    };
-  }
-  /** The skills already attached to a role — what task-level routing must not inline a second time. */
-  skillsFor(roleName) {
-    return this.roles[roleName]?.skills ?? [];
-  }
-  resolve(roleName) {
-    const role = this.roles[roleName];
-    if (!role) throw new Error(`undefined role: ${roleName}`);
-    if (!this.rawChain(roleName).length) {
-      throw new Error(
-        `role '${roleName}' has no model defined \u2014 set one with \`/roles setmodel\`, run \`/roles adjust\`, or choose a session model with \`/model\`.`
-      );
-    }
-    let systemPrompt = role.systemPrompt ?? this.defaultPrompts[roleName];
-    if (systemPrompt === void 0) throw new Error(`role '${roleName}' has no systemPrompt`);
-    if (this.skillRegistry) {
-      try {
-        systemPrompt = applySkills(systemPrompt, role.skills ?? [], this.skillRegistry);
-      } catch (e) {
-        throw new Error(`role '${roleName}' skill error: ${e instanceof Error ? e.message : String(e)}`);
-      }
-    }
-    return { ...this.fallbackOpts(roleName), systemPrompt: systemPrompt + this.ruleSuffix() };
-  }
-};
-
-// src/engine/review.ts
+import { z as z16 } from "zod";
 function asChoice(o) {
   return typeof o === "string" ? { label: o } : o;
 }
-var AssessmentSchema = z17.object({
-  findings: z17.array(z17.object({
-    severity: z17.enum(["critical", "medium", "low"]).describe(
+var AssessmentSchema = z16.object({
+  findings: z16.array(z16.object({
+    severity: z16.enum(["critical", "medium", "low"]).describe(
       "`critical`: shipping it this way causes real harm \u2014 wrong behaviour, data loss, a security hole. `medium`: it should be fixed but nothing breaks if it ships. `low`: a preference or a tidy-up."
     ),
-    note: z17.string()
+    note: z16.string()
   })).default([]),
-  recommendation: z17.enum(["approve", "revise"]).describe(
+  recommendation: z16.enum(["approve", "revise"]).describe(
     "`revise` only if at least one finding must be addressed before this can ship; otherwise `approve` and leave the findings as notes. Findings you would not block on do not make it a revise."
   )
 });
@@ -4594,18 +3478,18 @@ function coverage(assessments) {
   const verified = assessments.length - unverified;
   return { verified, unverified, enough: !assessments.length || verified / assessments.length >= TEAM_MIN_COVERAGE };
 }
-var CouncilVoteSchema = z17.object({
-  vote: z17.enum(["pass", "revise"]).describe(
+var CouncilVoteSchema = z16.object({
+  vote: z16.enum(["pass", "revise"]).describe(
     "`revise` only if something must change before this can ship. A concern you would not block on is a `pass` with the concern in the rationale."
   ),
-  rationale: z17.string()
+  rationale: z16.string()
 });
-var JudgeSchema = z17.object({
-  decision: z17.enum(["pass", "revise", "ask-human"]).describe(
+var JudgeSchema = z16.object({
+  decision: z16.enum(["pass", "revise", "ask-human"]).describe(
     "`pass`: it can ship. `revise`: it can be fixed from the feedback below, without anyone being asked. `ask-human` ONLY when the decision is genuinely not yours \u2014 the reviewers disagree on something a person owns, or the answer depends on intent nobody wrote down. It stops the run and costs someone their attention; do not use it for a call you can make."
   ),
-  feedback: z17.array(z17.string()),
-  question: z17.string()
+  feedback: z16.array(z16.string()),
+  question: z16.string()
 });
 var STAGE_FRAMING = {
   spec: `You are reviewing a SPECIFICATION: it states WHAT the product must do and WHY, written for business stakeholders. By design it MUST NOT contain implementation detail (languages, frameworks, APIs, storage mechanics, code structure) \u2014 those decisions belong to the LATER plan stage.
@@ -5190,10 +4074,10 @@ async function runCodeReview(deps, workdir, taskTitle, request, emit = () => {
 }
 
 // src/engine/acceptance.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 
 // src/engine/criterion-commands.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var RUNNABLE_COMMANDS = [
   "dotnet",
   "npm",
@@ -5226,12 +4110,12 @@ function commandsIn(criterion) {
 }
 async function runCommand(cwd, argv, timeoutMs = CRITERION_TIMEOUT_MS) {
   const [bin, ...args] = argv;
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     let child;
     try {
-      child = spawn3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1" } });
+      child = spawn2(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1" } });
     } catch (e) {
-      resolve6({ argv, passed: false, exitCode: null, timedOut: false, output: e instanceof Error ? e.message : String(e) });
+      resolve5({ argv, passed: false, exitCode: null, timedOut: false, output: e instanceof Error ? e.message : String(e) });
       return;
     }
     let out = "";
@@ -5248,11 +4132,11 @@ async function runCommand(cwd, argv, timeoutMs = CRITERION_TIMEOUT_MS) {
     }, timeoutMs);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve6({ argv, passed: false, exitCode: null, timedOut: false, output: e.message });
+      resolve5({ argv, passed: false, exitCode: null, timedOut: false, output: e.message });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve6({ argv, passed: !timedOut && code === 0, exitCode: code, timedOut, output: out.slice(-MAX_OUTPUT) });
+      resolve5({ argv, passed: !timedOut && code === 0, exitCode: code, timedOut, output: out.slice(-MAX_OUTPUT) });
     });
   });
 }
@@ -5286,9 +4170,9 @@ ${r.output.slice(-800)}
 }
 
 // src/engine/test-runner.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { join as join9 } from "path";
 var TEST_TIMEOUT_MS = 6e5;
 var MAX_TEST_OUTPUT = 12e3;
@@ -5297,7 +4181,7 @@ async function detectTestCommand(cwd) {
   const pkgPath = join9(cwd, "package.json");
   if (existsSync9(pkgPath)) {
     try {
-      const pkg = JSON.parse(await readFile3(pkgPath, "utf8"));
+      const pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
       const script = pkg.scripts?.test;
       if (script && !PLACEHOLDER.test(script)) {
         const runner = existsSync9(join9(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync9(join9(cwd, "yarn.lock")) ? "yarn" : existsSync9(join9(cwd, "bun.lockb")) ? "bun" : "npm";
@@ -5319,8 +4203,8 @@ async function runProjectTests(cwd, cmd) {
   const command = cmd ?? await detectTestCommand(cwd);
   if (!command) return { skipped: true, passed: true, output: "", timedOut: false };
   const [bin, ...args] = command.argv;
-  return new Promise((resolve6) => {
-    const child = spawn4(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1" } });
+  return new Promise((resolve5) => {
+    const child = spawn3(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1" } });
     let out = "";
     const take = (d) => {
       out += d.toString();
@@ -5335,7 +4219,7 @@ async function runProjectTests(cwd, cmd) {
     }, TEST_TIMEOUT_MS);
     const done = (code, extra = "") => {
       clearTimeout(timer);
-      resolve6({
+      resolve5({
         skipped: false,
         passed: code === 0 && !timedOut,
         command: command.argv.join(" "),
@@ -5346,7 +4230,7 @@ async function runProjectTests(cwd, cmd) {
     };
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve6({
+      resolve5({
         skipped: true,
         passed: true,
         command: command.argv.join(" "),
@@ -5377,13 +4261,13 @@ ${run.output}`;
 function normalizeCriterion(s) {
   return s.toLowerCase().replace(/[`*_]/g, "").replace(/\s+/g, " ").trim().replace(/[.,;:!?…]+$/, "");
 }
-var AcceptanceSchema = z18.object({
-  checks: z18.array(z18.object({
-    criterion: z18.string().describe(
+var AcceptanceSchema = z17.object({
+  checks: z17.array(z17.object({
+    criterion: z17.string().describe(
       "Copy the criterion VERBATIM from the numbered list you were given, including any backticks and punctuation. Do not paraphrase, renumber or reformat it \u2014 it is matched back to the task by text."
     ),
-    met: z18.boolean(),
-    evidence: z18.string().describe(
+    met: z17.boolean(),
+    evidence: z17.string().describe(
       'Where you SAW it: a file path and what it contains, a symbol, a test name. "It looks fine" is not evidence.'
     )
   }))
@@ -5631,31 +4515,31 @@ async function runTaskCycle(deps, board, taskId, worktreePath, slot = 0) {
 }
 
 // src/board/board.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 var MAX_STAGE_EVENTS = 200;
-var stageEventSchema = z19.object({
-  role: z19.string(),
-  action: z19.string(),
-  note: z19.string().optional()
+var stageEventSchema = z18.object({
+  role: z18.string(),
+  action: z18.string(),
+  note: z18.string().optional()
 });
-var cardSchema = z19.object({
-  id: z19.string(),
-  title: z19.string(),
-  column: z19.enum(["TODO", "IN-PROGRESS", "REVIEW", "DONE", "MERGED", "PARKED", "ABANDONED"]),
-  worktree: z19.string().optional(),
-  deps: z19.array(z19.string()),
-  acceptance: z19.array(z19.string()).default([]),
+var cardSchema = z18.object({
+  id: z18.string(),
+  title: z18.string(),
+  column: z18.enum(["TODO", "IN-PROGRESS", "REVIEW", "DONE", "MERGED", "PARKED", "ABANDONED"]),
+  worktree: z18.string().optional(),
+  deps: z18.array(z18.string()),
+  acceptance: z18.array(z18.string()).default([]),
   // default: boards persisted before the gate existed still load
-  files: z19.array(z19.string()).default([]),
+  files: z18.array(z18.string()).default([]),
   // ditto — a board written before file lists existed still loads
-  reviewNotes: z19.array(z19.string()),
+  reviewNotes: z18.array(z18.string()),
   // Optional rather than defaulted: a board written before this existed must round-trip unchanged, and an
   // empty list is the same statement as no list at all.
-  clearedLenses: z19.array(z19.string()).optional(),
-  attempts: z19.number(),
-  stageHistory: z19.array(stageEventSchema)
+  clearedLenses: z18.array(z18.string()).optional(),
+  attempts: z18.number(),
+  stageHistory: z18.array(stageEventSchema)
 });
-var boardDataSchema = z19.object({ version: z19.literal(1), cards: z19.array(cardSchema) });
+var boardDataSchema = z18.object({ version: z18.literal(1), cards: z18.array(cardSchema) });
 function migrateDelivered(c) {
   if (c.column !== "DONE") return c;
   return c.stageHistory.some((e) => e.action === "merged") ? { ...c, column: "MERGED" } : c;
@@ -5823,40 +4707,14 @@ var Board = class _Board {
 };
 
 export {
-  checkProfile,
-  runLogin,
   SHORT_CALL_MS,
   LONG_CALL_MS,
-  cliCatalog,
   CliProvider,
   describeInherited,
   describeTopUp,
   toSlug,
   mainWorktreeRoot,
   WorktreeManager,
-  REQUIRED_ROLES,
-  DEFAULT_ROLE_SKILLS,
-  DEFAULT_PROMPTS,
-  SPEC_TEAM,
-  PLAN_TEAM,
-  CODE_TEAM,
-  DEFAULT_COUNCIL,
-  placedSkills,
-  ROLE_PROFILES,
-  filterModelsForRole,
-  effortFor,
-  isKnownModel,
-  capabilityScore,
-  mostCapable,
-  modelBand,
-  DURABLE_ROLES,
-  strongestPrimary,
-  newestPrimary,
-  sourceOf,
-  adjustRoleModels,
-  applySkills,
-  buildSkillTool,
-  RoleRegistry,
   unfinishedSessions,
   describeUnfinished,
   gitTool,