@hizliemre/horse-code 0.1.2 → 0.3.0

package/dist/cli.js

@@ -2,25 +2,24 @@
 import {
   MAX_PARALLEL_TASKS,
   MemoryStore,
-  OmniRouteProvider,
   Timings,
   autonomousAskHuman,
   defaultCmdRunner,
+  describeTally,
   detectPlatform,
   makeApprove,
   makeAskUser,
   makePRAdapter,
   nodeLineReader,
+  proposeSplit,
   restoreTerminal,
   runJob,
   sttySane
-} from "./chunk-K2VERI5Q.js";
-import {
-  listOmniRouteModels
-} from "./chunk-O74BDQKS.js";
-import "./chunk-3UYA3KUG.js";
+} from "./chunk-XYZVZPAY.js";
+import "./chunk-M2RKCIGV.js";
 import {
   CODE_TEAM,
+  CliProvider,
   DEFAULT_COUNCIL,
   DEFAULT_PROMPTS,
   DEFAULT_ROLE_SKILLS,
@@ -28,16 +27,20 @@ import {
   REQUIRED_ROLES,
   RoleFitness,
   RoleRegistry,
+  SHORT_CALL_MS,
   SPEC_TEAM,
   WorktreeManager,
+  ZAI_MODELS,
   buildCouncilRegistry,
   buildTeamRegistry,
+  cliCatalog,
   mainWorktreeRoot,
+  modelsFor,
   toSlug
-} from "./chunk-RPVAIS3P.js";
+} from "./chunk-UEWVVN5L.js";
 import "./chunk-QF4MP6BS.js";
-import "./chunk-EQX7BQYN.js";
-import "./chunk-FGVJFMK5.js";
+import "./chunk-UGESK765.js";
+import "./chunk-ZSQ24YDJ.js";
 import {
   parseFrontmatter
 } from "./chunk-BY4DP7IE.js";
@@ -45,7 +48,12 @@ import {
   UNSET_MODEL,
   loadConfig,
   saveSkillSource
-} from "./chunk-4EWK7HWQ.js";
+} from "./chunk-EAF22QIG.js";
+import {
+  CLI_KINDS,
+  checkProfile,
+  runLogin
+} from "./chunk-G45RWL7S.js";
 import "./chunk-H2FDGPVW.js";
 import {
   buildBrief,
@@ -53,50 +61,460 @@ import {
   planFor,
   runTraces,
   traceableFiles
-} from "./chunk-NNTIACT4.js";
+} from "./chunk-MRZVA5JB.js";
 import {
   defaultGitRunner
-} from "./chunk-IW2KBAVZ.js";
+} from "./chunk-LPQU436C.js";
 import {
   InjectionLog,
   memoryNote
-} from "./chunk-DRZSUQ7Q.js";
-import "./chunk-2SVAHH5N.js";
+} from "./chunk-LLL7QWXB.js";
+import "./chunk-63E73TGI.js";
 import {
   Telemetry,
+  ToolRegistry,
   clearPerfMarks,
   sampleMemory,
   setTelemetry,
   stripThinking,
   telemetry,
   writeHeapSnapshot
-} from "./chunk-VPAWRRHL.js";
+} from "./chunk-AE36LLL2.js";
 import {
   briefStatus
-} from "./chunk-DTWKSZXY.js";
+} from "./chunk-6OSEQOYY.js";
 import {
   discoverTraceRoot,
   setTraceRoot
-} from "./chunk-FFYBY2NA.js";
+} from "./chunk-KAGKX2YT.js";
 import {
   buildProjectGraph,
   graphStatus,
   graphifyPython
-} from "./chunk-PGOYDOI4.js";
+} from "./chunk-XEGQT5EN.js";
 import {
   sessionBase
-} from "./chunk-SSDLHWSF.js";
-import "./chunk-B67BK5GQ.js";
+} from "./chunk-6W4UH2BQ.js";
 
 // src/cli.ts
 import { execFileSync } from "child_process";
-import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, realpathSync } from "fs";
-import { join as join8, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, realpathSync, rmSync } from "fs";
+import { join as join11, dirname as dirname5 } from "path";
 import { pathToFileURL } from "url";
 
+// src/agents/cli-accounts.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+var SPENT = 0.95;
+function readingKey(kind, name) {
+  return `${kind}:${name}`;
+}
+function fileUsageStore(home) {
+  const path = join(home, ".horsecode", "usage.json");
+  return {
+    load() {
+      try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof parsed !== "object" || parsed === null) return {};
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+          const r = v;
+          if (typeof r?.spent === "number" && typeof r?.at === "number") out[k] = { spent: r.spent, at: r.at };
+        }
+        return out;
+      } catch {
+        return {};
+      }
+    },
+    save(readings) {
+      try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(readings, null, 2) + "\n");
+      } catch {
+      }
+    }
+  };
+}
+var AccountPool = class {
+  accounts;
+  store;
+  readings;
+  constructor(accounts = [], store) {
+    this.accounts = accounts;
+    this.store = store;
+    this.readings = store?.load() ?? {};
+  }
+  /**
+   * The profile a call of this kind should run under, or undefined to run under the ambient login.
+   *
+   * Round-robin over the accounts that still have room, so two subscriptions drain together rather than one
+   * after the other. A spent one drops out of the rotation and rejoins the moment a reading says it can
+   * serve again.
+   */
+  pick(kind) {
+    const mine = this.accounts.filter((a) => a.kind === kind);
+    if (!mine.length) return void 0;
+    const live = mine.filter((a) => (this.readings[readingKey(kind, a.name)]?.spent ?? 0) < SPENT);
+    const pool = live.length ? live : mine;
+    const n = this.turn.get(kind) ?? 0;
+    this.turn.set(kind, n + 1);
+    return pool[n % pool.length];
+  }
+  /** Whose turn it is, per kind. Turns are per SOURCE: Claude's rotation says nothing about Codex's. */
+  turn = /* @__PURE__ */ new Map();
+  /**
+   * File a quota reading against a profile.
+   *
+   * The windows are taken at their worst: a seven-day limit that is nearly gone stops the profile just as
+   * surely as a five-hour one, and reading only the shorter window would keep sending calls to a
+   * subscription whose longer window ran out days ago.
+   */
+  record(kind, name, windows, now = Date.now()) {
+    const spent = Math.max(0, ...Object.values(windows));
+    this.readings = { ...this.readings, [readingKey(kind, name)]: { spent, at: now } };
+    this.store?.save(this.readings);
+  }
+  /** Every configured profile with its last reading, for a startup summary or a status line. */
+  usage() {
+    return this.accounts.map((a) => {
+      const r = this.readings[readingKey(a.kind, a.name)];
+      return { account: a, ...r ? { reading: r } : {} };
+    });
+  }
+  /** How many profiles are configured, in total or for one CLI. */
+  count(kind) {
+    return kind ? this.accounts.filter((a) => a.kind === kind).length : this.accounts.length;
+  }
+};
+function modelsPanel(usage2, models, kinds, inUse = [], now = Date.now()) {
+  const used = new Set(inUse);
+  const rows = [];
+  for (const kind of kinds) {
+    const mine = usage2.filter((u) => u.account.kind === kind);
+    const who = mine.length ? mine.map(({ account, reading }) => {
+      const name = account.email ?? account.plan ?? account.name;
+      return `${name}${reading ? ` \xB7 ${Math.round(reading.spent * 100)}% used ${ageOf(reading.at, now)} ago` : ""}`;
+    }).join(" \xB7 ") : "_not connected \u2014 these will fail every call_";
+    rows.push(`**${kind}** \u2014 ${who}`);
+    rows.push(`  ${models(kind).map((m) => `${used.has(m) ? "\u25CF" : "\xB7"} ${m}`).join("   ")}`);
+  }
+  const idle = kinds.filter((k) => usage2.some((u) => u.account.kind === k)).filter((k) => !models(k).some((m) => used.has(m)));
+  const note = idle.length ? `
+
+_\u25CF = a role is running it. ${idle.join(" and ")} ${idle.length > 1 ? "are" : "is"} connected but in no chain \u2014 \`/roles adjust\` assigns them._` : "\n\n_\u25CF = a role is running it._";
+  return `**Models** \u2014 what your connected subscriptions serve
+
+${rows.join("\n")}${note}`;
+}
+function ageOf(at, now) {
+  const mins = Math.max(0, Math.round((now - at) / 6e4));
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.round(mins / 60);
+  return hours < 48 ? `${hours}h` : `${Math.round(hours / 24)}d`;
+}
+function accountsLine(usage2, notSignedIn = [], now = Date.now()) {
+  const parts = usage2.map(({ account, reading }) => {
+    const who = `${account.email ?? account.plan ?? account.name}${account.email && account.plan ? ` (${account.plan})` : ""}`;
+    const left = reading ? ` ${Math.round(reading.spent * 100)}% used ${ageOf(reading.at, now)} ago` : "";
+    return `${account.kind} ${who}${left}`;
+  });
+  for (const kind of notSignedIn) parts.push(`${kind} NOT signed in \u2014 every ${kind} call will fail`);
+  return parts.length ? parts.join(" \xB7 ") : void 0;
+}
+
+// src/agents/add-provider.ts
+import { join as join2 } from "path";
+function freshDir(kind, home, taken) {
+  const used = new Set(taken.map((a) => a.configDir));
+  for (let n = 2; ; n++) {
+    const dir = join2(home, ".horsecode", "profiles", `${kind}-${n}`);
+    if (!used.has(dir)) return dir;
+  }
+}
+function nameFor(kind, status, dir) {
+  const base = dir.split("/").pop() ?? "profile";
+  return status.email ?? (base.startsWith(`${kind}-`) ? base : `${kind}-${base}`);
+}
+function withAmbient(kind, existing, ambient) {
+  if (kind === "zai") return [...existing];
+  if (existing.some((a) => a.kind === kind)) return [...existing];
+  if (!ambient.loggedIn) return [...existing];
+  return [
+    ...existing,
+    {
+      kind,
+      name: ambient.email ?? `${kind}-default`,
+      ...ambient.email ? { email: ambient.email } : {},
+      ...ambient.plan ? { plan: ambient.plan } : {}
+    }
+  ];
+}
+function accountsIn(config) {
+  const raw = config.accounts;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((a) => {
+    const e = a;
+    if (typeof a !== "object" || a === null) return false;
+    if (!CLI_KINDS.includes(e.kind)) return false;
+    return e.configDir === void 0 || typeof e.configDir === "string";
+  });
+}
+async function addProvider(kind, io) {
+  const config = io.readConfig();
+  const existing = accountsIn(config);
+  const accounts = withAmbient(kind, existing, io.check(kind));
+  if (accounts.length > existing.length) {
+    const a = accounts.at(-1);
+    io.log(`Recorded the ${kind} account you are already signed in as: ${a.email ?? a.name}${a.plan ? ` (${a.plan})` : ""}`);
+    io.log(`It stays first in line, so runs keep spending it before anything added now.`);
+  }
+  const dir = freshDir(kind, io.home, accounts);
+  if (kind === "zai") {
+    io.log(`
+z.ai has no sign-in \u2014 an account is an API key, and the profile at ${dir} will hold it.`);
+    io.log(`Take the key from your z.ai dashboard; it is written to that profile alone and nowhere else.
+`);
+  } else {
+    io.log(`
+Opening ${kind}'s own sign-in, for a NEW profile at ${dir}.`);
+    io.log(`Sign in with the account you want to add \u2014 not the one already connected.
+`);
+  }
+  const r = await io.login(kind, dir);
+  if (!r.ok) {
+    if (kind === "zai") {
+      io.log(`
+z.ai did not accept that key${r.error ? `: ${r.error}` : ""}. Nothing was changed.`);
+      io.log(`The key is checked by making one real call, because \`claude auth status\` reports any token as connected \u2014 valid or not.`);
+      io.log(`Nothing needs cleaning up: running this again reuses ${dir}.`);
+      return 1;
+    }
+    io.log(`
+${kind} sign-in did not complete${r.error ? `: ${r.error}` : ""}. Nothing was changed.`);
+    io.log(`If a browser page opened, its address holds the reason \u2014 an \`error=\` there is the account being refused, not this command failing.`);
+    io.log(`Nothing needs cleaning up: ${dir} holds no session, and running this again reuses it.`);
+    return 1;
+  }
+  const status = io.check(kind, dir);
+  if (!status.loggedIn) {
+    io.log(`
+${kind} still reports no session in ${dir}. Nothing was changed \u2014 run this again to retry.`);
+    return 1;
+  }
+  const already = status.email ? accounts.find((a) => a.kind === kind && a.email === status.email) : void 0;
+  if (already) {
+    io.log(`
+That is the account already connected as "${already.name}". Nothing was changed.`);
+    return 1;
+  }
+  const entry = {
+    kind,
+    name: nameFor(kind, status, dir),
+    configDir: dir,
+    ...status.email ? { email: status.email } : {},
+    ...status.plan ? { plan: status.plan } : {}
+  };
+  io.writeConfig({ ...config, accounts: [...accounts, entry] });
+  const mine = [...accounts, entry].filter((a) => a.kind === kind);
+  io.log(`
+Connected ${entry.email ?? entry.name}${entry.plan ? ` (${entry.plan})` : ""}.`);
+  io.log(`${mine.length} ${kind} account${mine.length === 1 ? "" : "s"} now connected. Runs take turns between them.`);
+  if (kind === "claude") io.log(`One nearly out of quota steps aside for the others.`);
+  else io.log(`${kind} reports no quota figures, so a spent account is discovered by being refused, not before.`);
+  if (kind === "zai" && mine.length > 1) {
+    io.log(`z.ai reports no account identity, so this cannot be checked: if that key is one already connected, remove the duplicate from ~/.horsecode/config.json.`);
+  }
+  return 0;
+}
+
+// src/agents/zai-profile.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var ZAI_BASE_URL = "https://api.z.ai/api/anthropic";
+function zaiSettings(token) {
+  return { env: { ANTHROPIC_BASE_URL: ZAI_BASE_URL, ANTHROPIC_AUTH_TOKEN: token } };
+}
+function settingsPath(dir) {
+  return join3(dir, "settings.json");
+}
+function writeZaiProfile(dir, token) {
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  writeFileSync2(settingsPath(dir), JSON.stringify(zaiSettings(token), null, 2) + "\n", { mode: 384 });
+}
+async function verifyZaiKey(token, model, timeoutMs = 3e4) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${ZAI_BASE_URL}/v1/messages`, {
+      method: "POST",
+      signal: ctl.signal,
+      headers: {
+        "content-type": "application/json",
+        // Both spellings: z.ai accepts the bearer form, and `x-api-key` is what the Anthropic wire format
+        // names. Sending each costs nothing and removes a guess about which one this endpoint reads.
+        authorization: `Bearer ${token}`,
+        "x-api-key": token,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({ model, max_tokens: 16, messages: [{ role: "user", content: "Reply with: ok" }] })
+    });
+    const body = await res.json().catch(() => void 0);
+    if (!res.ok) return { ok: false, error: zaiErrorText(body) ?? `the endpoint answered HTTP ${res.status}` };
+    const served = body?.model;
+    return { ok: true, ...served ? { served } : {} };
+  } catch (e) {
+    const aborted = e instanceof Error && e.name === "AbortError";
+    return {
+      ok: false,
+      error: aborted ? `${ZAI_BASE_URL} did not answer within ${Math.round(timeoutMs / 1e3)}s` : e instanceof Error ? e.message : String(e)
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function zaiErrorText(body) {
+  const msg = body?.error?.message;
+  return typeof msg === "string" && msg.trim() ? msg.trim() : void 0;
+}
+
+// src/agents/prompt.ts
+import { spawnSync } from "child_process";
+import { closeSync, openSync, readSync } from "fs";
+function promptLine() {
+  return readTty(false);
+}
+function promptSecret() {
+  return readTty(true);
+}
+function confirm(question) {
+  process.stdout.write(`${question} [y/N] `);
+  const answer = promptLine();
+  process.stdout.write("\n");
+  return /^y(es)?$/i.test((answer ?? "").trim());
+}
+function chooseFrom(question, options) {
+  process.stdout.write(`${question}
+`);
+  options.forEach((o, i) => process.stdout.write(`  ${i + 1}) ${o}
+`));
+  process.stdout.write(`Number (anything else cancels): `);
+  const line = promptLine();
+  process.stdout.write("\n");
+  const n = Number((line ?? "").trim());
+  return Number.isInteger(n) && n >= 1 && n <= options.length ? n - 1 : void 0;
+}
+function readTty(hidden) {
+  let fd;
+  try {
+    fd = openSync("/dev/tty", "r");
+  } catch {
+    return void 0;
+  }
+  const hushed = hidden && spawnSync("stty", ["-echo"], { stdio: ["inherit", "ignore", "ignore"] }).status === 0;
+  try {
+    const buf = Buffer.alloc(1);
+    let out = "";
+    for (; ; ) {
+      let n = 0;
+      try {
+        n = readSync(fd, buf, 0, 1, null);
+      } catch {
+        break;
+      }
+      if (n === 0) break;
+      const ch = buf.toString("utf8");
+      if (ch === "\n" || ch === "\r") break;
+      out += ch;
+    }
+    return out.trim() || void 0;
+  } finally {
+    if (hushed) spawnSync("stty", ["echo"], { stdio: ["inherit", "ignore", "ignore"] });
+    closeSync(fd);
+  }
+}
+
+// src/agents/remove-provider.ts
+function ownedProfile(home, dir) {
+  if (!dir) return false;
+  const root = `${home}/.horsecode/profiles/`;
+  return dir.startsWith(root) && dir.length > root.length && !dir.slice(root.length).includes("..");
+}
+function describeAccount(a) {
+  const who = a.email ?? a.name;
+  return `${a.kind} ${who}${a.plan ? ` (${a.plan})` : ""}${a.configDir ? "" : " \u2014 the signed-in default"}`;
+}
+function pickAccount(accounts, kind, name) {
+  const mine = accounts.filter((a) => a.kind === kind);
+  if (!mine.length) return { error: `no ${kind} account is connected` };
+  if (!name) return mine.length === 1 ? { account: mine[0] } : { choices: mine };
+  const found = mine.filter((a) => a.name === name || a.email === name);
+  if (!found.length) {
+    return {
+      error: `no ${kind} account called "${name}". Connected:
+` + mine.map((a) => `  ${a.name}${a.email && a.email !== a.name ? ` (${a.email})` : ""}`).join("\n")
+    };
+  }
+  if (found.length > 1) return { error: `"${name}" matches ${found.length} ${kind} accounts \u2014 remove one by its exact name` };
+  return { account: found[0] };
+}
+function removeProvider(kind, name, io) {
+  const config = io.readConfig();
+  const accounts = accountsIn(config);
+  const picked = pickAccount(accounts, kind, name);
+  if ("error" in picked) {
+    io.log(picked.error);
+    const others = accounts.filter((a) => a.kind !== kind);
+    if (!accounts.filter((a) => a.kind === kind).length && others.length) {
+      io.log(`
+Connected accounts:
+${others.map((a) => `  ${describeAccount(a)}`).join("\n")}`);
+    }
+    return { code: 1 };
+  }
+  let account;
+  if ("account" in picked) {
+    account = picked.account;
+  } else {
+    const chosen = io.choose(`Which ${kind} account should be removed?`, picked.choices.map(describeAccount));
+    if (chosen === void 0) {
+      io.log("Nothing was removed.");
+      return { code: 1 };
+    }
+    account = picked.choices[chosen];
+  }
+  const kept = accounts.filter((a) => a !== account);
+  io.writeConfig({ ...config, accounts: kept });
+  if (io.usage) {
+    const readings = io.usage.load();
+    const { [readingKey(kind, account.name)]: _dropped, ...rest } = readings;
+    io.usage.save(rest);
+  }
+  io.log(`Removed ${describeAccount(account)}.`);
+  if (!account.configDir) {
+    io.log(`That was the account you are signed into ${kind} with, not a profile horse-code created.`);
+    io.log(`It is still signed in, and a run will find it again. To stop using it, sign out of ${kind} itself.`);
+    return { code: 0, removed: account };
+  }
+  if (!ownedProfile(io.home, account.configDir)) {
+    io.log(`Its profile at ${account.configDir} was not created by horse-code, so it is left alone.`);
+    return { code: 0, removed: account };
+  }
+  const holds = kind === "zai" ? "the API key" : `the ${kind} sign-in`;
+  if (!io.confirm(`Also delete ${account.configDir}, which holds ${holds}?`)) {
+    io.log(`Left ${account.configDir} in place. Delete it by hand to remove ${holds}.`);
+    return { code: 0, removed: account };
+  }
+  io.removeDir(account.configDir);
+  io.log(`Deleted ${account.configDir}.`);
+  return { code: 0, removed: account };
+}
+function removeUsage(given) {
+  return `remove-provider needs a CLI to disconnect: ${CLI_KINDS.map((k) => `\`hcode remove-provider ${k}\``).join(", ")}${given ? ` (got "${given}")` : ""}`;
+}
+
 // src/skills/registry.ts
 import { readdir, readFile } from "fs/promises";
-import { join } from "path";
+import { join as join4 } from "path";
 var SkillRegistry = class {
   skills = /* @__PURE__ */ new Map();
   register(skill) {
@@ -119,7 +537,7 @@ var SkillRegistry = class {
       if (!e.isDirectory()) continue;
       let raw;
       try {
-        raw = await readFile(join(dir, e.name, "SKILL.md"), "utf8");
+        raw = await readFile(join4(dir, e.name, "SKILL.md"), "utf8");
       } catch {
         continue;
       }
@@ -127,17 +545,17 @@ var SkillRegistry = class {
       if (!name || !description) {
         throw new Error(`skill ${e.name}: missing frontmatter (name/description)`);
       }
-      this.register({ name, description, content: body, dir: join(dir, e.name) });
+      this.register({ name, description, content: body, dir: join4(dir, e.name) });
     }
   }
 };
 
 // src/skills/builtin.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import { dirname, join as join2, resolve } from "path";
+import { dirname as dirname2, join as join5, resolve } from "path";
 import { fileURLToPath } from "url";
 function candidates() {
-  const here = dirname(fileURLToPath(import.meta.url));
+  const here = dirname2(fileURLToPath(import.meta.url));
   return [
     resolve(here, "..", "skills"),
     // bundled: dist/… → <repo>/skills
@@ -155,14 +573,14 @@ async function registerBuiltinSkills(registry, dirs = candidates()) {
         if (!e.isDirectory()) continue;
         let raw;
         try {
-          raw = await readFile2(join2(dir, e.name, "SKILL.md"), "utf8");
+          raw = await readFile2(join5(dir, e.name, "SKILL.md"), "utf8");
         } catch {
           continue;
         }
         const { parseFrontmatter: parseFrontmatter2 } = await import("./frontmatter-UNIPNLLO.js");
         const { name, description, body } = parseFrontmatter2(raw);
         if (!name || !description) continue;
-        found.push({ name, description, content: body, dir: join2(dir, e.name) });
+        found.push({ name, description, content: body, dir: join5(dir, e.name) });
       }
       if (!found.length) continue;
       for (const s of found) registry.register(s);
@@ -177,12 +595,12 @@ async function registerBuiltinSkills(registry, dirs = candidates()) {
 // src/skills/external.ts
 import { mkdir, rm, readFile as readFile3, writeFile, readdir as readdir3, cp } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join3 } from "path";
+import { join as join6 } from "path";
 import { spawn } from "child_process";
 import { tmpdir } from "os";
 var PROVENANCE = ".horsecode-source.json";
 function externalSkillsDir(home) {
-  return join3(home, ".horsecode", "skills");
+  return join6(home, ".horsecode", "skills");
 }
 function validName(name) {
   return /^[A-Za-z0-9._-]+$/.test(name) && !name.includes("..");
@@ -226,7 +644,7 @@ async function resolveSha(src, deps) {
 }
 async function installedSource(home, name) {
   try {
-    return JSON.parse(await readFile3(join3(externalSkillsDir(home), name, PROVENANCE), "utf8"));
+    return JSON.parse(await readFile3(join6(externalSkillsDir(home), name, PROVENANCE), "utf8"));
   } catch {
     return void 0;
   }
@@ -236,27 +654,27 @@ async function installSkillSource(home, src, deps = {}) {
   if (!validRepo(src.repo)) throw new Error(`skill source repo must be "owner/repo": ${src.repo}`);
   if (src.path?.includes("..")) throw new Error(`skill source path may not contain "..": ${src.path}`);
   const sha = await resolveSha(src, deps);
-  const dest = join3(externalSkillsDir(home), src.name);
+  const dest = join6(externalSkillsDir(home), src.name);
   const current = await installedSource(home, src.name);
-  if (current?.sha === sha && existsSync(join3(dest, "SKILL.md"))) {
+  if (current?.sha === sha && existsSync(join6(dest, "SKILL.md"))) {
     return { name: src.name, sha, changed: false };
   }
-  const staging = join3(tmpdir(), `hc-skill-${src.name}-${sha.slice(0, 8)}`);
+  const staging = join6(tmpdir(), `hc-skill-${src.name}-${sha.slice(0, 8)}`);
   await rm(staging, { recursive: true, force: true });
   await mkdir(staging, { recursive: true });
   try {
     const url = `https://codeload.github.com/${src.repo}/tar.gz/${sha}`;
     const dl = await run("sh", ["-c", `curl -fsSL --max-time 120 ${JSON.stringify(url)} | tar xz -C ${JSON.stringify(staging)} --strip-components=1`]);
     if (dl.code !== 0) throw new Error(`download failed for ${src.repo}@${sha.slice(0, 8)}: ${dl.err.trim().slice(0, 200)}`);
-    const from = src.path ? join3(staging, src.path) : staging;
-    if (!existsSync(join3(from, "SKILL.md"))) {
+    const from = src.path ? join6(staging, src.path) : staging;
+    if (!existsSync(join6(from, "SKILL.md"))) {
       throw new Error(`${src.repo}${src.path ? `/${src.path}` : ""} has no SKILL.md`);
     }
     await rm(dest, { recursive: true, force: true });
     await mkdir(dest, { recursive: true });
     await cp(from, dest, { recursive: true });
     const record = { ...src, sha, installedAt: (deps.now ?? Date.now)() };
-    await writeFile(join3(dest, PROVENANCE), `${JSON.stringify(record, null, 2)}
+    await writeFile(join6(dest, PROVENANCE), `${JSON.stringify(record, null, 2)}
 `, "utf8");
     return { name: src.name, sha, changed: true };
   } finally {
@@ -546,8 +964,8 @@ var ProposalQueue = class {
 };
 
 // src/speckit/templates.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 var TEMPLATE_FILES = {
   spec: "spec-template.md",
   plan: "plan-template.md",
@@ -570,10 +988,10 @@ async function loadSpecKit(opts) {
     );
   }
   const fetchFn = opts.fetch ?? globalThis.fetch;
-  const cacheDir = join4(opts.home, ".horsecode", "spec-kit", opts.version, "templates");
+  const cacheDir = join7(opts.home, ".horsecode", "spec-kit", opts.version, "templates");
   const get = async (relPath) => {
-    const cachePath = join4(cacheDir, relPath);
-    if (existsSync2(cachePath)) return readFileSync(cachePath, "utf8");
+    const cachePath = join7(cacheDir, relPath);
+    if (existsSync2(cachePath)) return readFileSync3(cachePath, "utf8");
     const url = `${RAW_BASE}/${opts.version}/templates/${relPath}`;
     const res = await fetchFn(url);
     if (!res.ok) {
@@ -583,8 +1001,8 @@ Check your network or set specKit.version to a valid tag.`
       );
     }
     const text = await res.text();
-    mkdirSync(dirname2(cachePath), { recursive: true });
-    writeFileSync(cachePath, text, "utf8");
+    mkdirSync3(dirname3(cachePath), { recursive: true });
+    writeFileSync3(cachePath, text, "utf8");
     return text;
   };
   const templates = {};
@@ -600,7 +1018,7 @@ Check your network or set specKit.version to a valid tag.`
 
 // src/wiring.ts
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join8 } from "path";
 async function buildJobDeps(opts) {
   const { config } = opts;
   const roles = {};
@@ -612,6 +1030,15 @@ async function buildJobDeps(opts) {
     roles[name] = { ...cfg ?? { models: sessionChain }, ...skills.length ? { skills } : { skills: [] } };
   }
   const roleRegistry = new RoleRegistry(roles, DEFAULT_PROMPTS, opts.skillRegistry);
+  if (opts.accounts) {
+    const pool = opts.accounts;
+    roleRegistry.setSourceWeights(() => ({
+      claude: pool.count("claude"),
+      codex: pool.count("codex"),
+      grok: pool.count("grok"),
+      zai: pool.count("zai")
+    }));
+  }
   const fillModels = (r) => ({
     ...r,
     models: r.models.length > 0 ? r.models : config.roles[r.name]?.models ?? sessionChain
@@ -637,10 +1064,27 @@ async function buildJobDeps(opts) {
   const queue = new ProposalQueue();
   let kitPromise;
   const specKit = () => kitPromise ??= loadSpecKit({ version: config.specKit.version, home: opts.home, fetch: opts.fetch });
-  const fitness = new RoleFitness(join5(opts.home ?? homedir(), ".horsecode", "model-fitness.json"));
+  const fitness = new RoleFitness(join8(opts.home ?? homedir(), ".horsecode", "model-fitness.json"));
   roleRegistry.setFitness(fitness);
   return {
     provider: opts.provider,
+    /**
+     * Implementers run as the CLI, because with a CLI provider nothing else can write.
+     *
+     * A CLI answers with TEXT. It never emits a tool call — it ran its tools itself, in its own process — so
+     * an implementer driven through this process's loop would receive prose, execute nothing, and report
+     * `no_changes` for every task on the board. This is not a choice between two working paths.
+     *
+     * It belongs HERE and not inside `runJob`, because it is a property of the provider that was chosen. Set
+     * in the pipeline it would override every caller that injected one: the job tests hand in a mock and
+     * would have spawned the real binary instead, which is exactly how it was first written and exactly how
+     * the tests caught it.
+     *
+     * `claude` is the fallback, not the decision — `cliFor` reads each role's own chain head, so a role on a
+     * `gpt-*` model runs Codex.
+     */
+    ...opts.delegateTo === null ? {} : { delegateTo: opts.delegateTo ?? "claude" },
+    ...opts.accounts ? { accounts: opts.accounts } : {},
     roleRegistry,
     fitness,
     skillRegistry: opts.skillRegistry,
@@ -665,7 +1109,30 @@ async function buildJobDeps(opts) {
     timings: new Timings(),
     rounds: 3,
     maxParallel: opts.config.maxParallel ?? MAX_PARALLEL_TASKS,
-    askHuman: opts.askHuman
+    askHuman: opts.askHuman,
+    /**
+     * Cutting a stuck card up, asked of the role that owns breakdowns in the first place.
+     *
+     * Read-only tools: this is a planning question about a card that already exists, and a splitter with a
+     * writer's toolset would be tempted to start doing the work it is describing.
+     */
+    splitCard: async (card) => {
+      const resolved = roleRegistry.resolve("project-manager");
+      return proposeSplit({
+        provider: opts.provider,
+        ...resolved,
+        tools: new ToolRegistry(),
+        // a planning question about a card that exists; it needs no tools
+        messages: [],
+        permission,
+        approve: opts.approve,
+        cwd: process.cwd(),
+        signal: opts.signal,
+        // It reads a card and answers; anything longer is exploring, which is not what was asked.
+        maxTurns: 3,
+        perAttemptMs: SHORT_CALL_MS
+      }, card);
+    }
   };
 }
 
@@ -717,6 +1184,7 @@ async function* stream(inner, tel, req, signal) {
   let promptTokens;
   let completionTokens;
   let cachedTokens;
+  let cacheWriteTokens;
   let finish;
   let failure;
   let toolCalls = 0;
@@ -727,6 +1195,7 @@ async function* stream(inner, tel, req, signal) {
         promptTokens = ev.promptTokens;
         completionTokens = ev.completionTokens;
         cachedTokens = ev.cachedTokens;
+        cacheWriteTokens = ev.cacheWriteTokens;
       } else if (ev.type === "tool-call") toolCalls++;
       else if (ev.type === "text-delta") textChars += ev.text.length;
       else if (ev.type === "done") finish = ev.finishReason;
@@ -745,6 +1214,14 @@ async function* stream(inner, tel, req, signal) {
       "gen_ai.usage.input_tokens": promptTokens,
       "gen_ai.usage.output_tokens": completionTokens,
       "gen_ai.usage.cached_tokens": cachedTokens,
+      /**
+       * What the cache COST, beside what it saved.
+       *
+       * A read is billed at a fraction and a write at a premium, so a run that reports only reads reads as
+       * pure profit — the first turn of every agent, which fills the cache, would cost nothing on paper.
+       * The true prompt spend is fresh + read + write, and this is the third.
+       */
+      "gen_ai.usage.cache_write_tokens": cacheWriteTokens,
       "gen_ai.response.finish_reason": finish,
       "hc.duration_ms": Date.now() - started,
       "hc.tools_requested": toolCalls,
@@ -779,10 +1256,10 @@ function redactRecord(record) {
 }
 
 // src/obs/sink.ts
-import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
-import { join as join6 } from "path";
+import { createWriteStream, mkdirSync as mkdirSync4 } from "fs";
+import { join as join9 } from "path";
 function telemetryDir(home) {
-  return join6(home, ".horsecode", "telemetry");
+  return join9(home, ".horsecode", "telemetry");
 }
 var MAX_QUEUE = 1e4;
 var FileSink = class {
@@ -791,9 +1268,9 @@ var FileSink = class {
   dropped = 0;
   path;
   constructor(home, runId) {
-    this.path = join6(telemetryDir(home), `${runId}.jsonl`);
+    this.path = join9(telemetryDir(home), `${runId}.jsonl`);
     try {
-      mkdirSync2(telemetryDir(home), { recursive: true });
+      mkdirSync4(telemetryDir(home), { recursive: true });
       this.stream = createWriteStream(this.path, { flags: "a" });
       this.stream.on("error", () => {
         this.stream = void 0;
@@ -850,13 +1327,13 @@ var FileSink = class {
 };
 
 // src/cli-info.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname4, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function hcodeVersion() {
   try {
-    const here = dirname3(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(readFileSync2(join7(here, "..", "package.json"), "utf8"));
+    const here = dirname4(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(readFileSync4(join10(here, "..", "package.json"), "utf8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -883,6 +1360,9 @@ function usage() {
     "  hcode                      start the REPL",
     '  hcode "<request>"          run one request to completion, then report where the work landed',
     "  hcode init                 write .horsecode/ for this project and ask for the essentials",
+    "  hcode add-provider <cli>   connect one more claude, codex, grok or zai subscription",
+    "  hcode remove-provider <cli> [name]",
+    "                             disconnect one, and optionally delete the sign-in it holds",
     "",
     "OPTIONS",
     "  -b, --branch <name>        branch the session's worktree from this ref (default: current branch)",
@@ -910,6 +1390,18 @@ function nearestFlag(flag) {
 
 // src/cli.ts
 var HEAP_MB = 12288;
+async function connectZai(dir) {
+  process.stdout.write("z.ai API key (not shown as you type): ");
+  const token = promptSecret();
+  process.stdout.write("\n");
+  if (!token) return { ok: false, error: "no key was entered" };
+  console.log(`Asking ${ZAI_MODELS[0]} one question, to see whether the key works\u2026`);
+  const v = await verifyZaiKey(token, ZAI_MODELS[0]);
+  if (!v.ok) return { ok: false, error: v.error };
+  writeZaiProfile(dir, token);
+  console.log(`  answered by ${v.served ?? "the endpoint (which named no model)"}.`);
+  return { ok: true };
+}
 function parseArgs(argv) {
   let fromBranch;
   let jobName;
@@ -945,7 +1437,7 @@ function parseArgs(argv) {
   };
 }
 function whereItLanded(path) {
-  const base = sessionBase(dirname4(path));
+  const base = sessionBase(dirname5(path));
   if (base === void 0) {
     return "Written directly in your working tree: no branch, no worktree, nothing to merge. Review it and commit it when you are happy with it.";
   }
@@ -971,18 +1463,12 @@ function describeDelivery(d) {
     `Or inspect it first: \`git diff HEAD...${d.branch}\` \xB7 worktree: \`${d.worktree}\``
   ].filter((l) => l !== void 0).join("\n");
 }
-var DELIVERED_SHARE = 0.5;
 function describeOutcome(w) {
   if (w.status === "completed") return w.pr ? `PR: ${w.pr.url}` : "all tasks merged";
-  const stuck = w.failed.length + w.skipped.length;
-  const total = w.waves.flat().length || stuck;
-  const merged = Math.max(0, total - stuck);
-  const parts = [
-    w.failed.length ? `${w.failed.length} failed` : "",
-    w.skipped.length ? `${w.skipped.length} blocked behind them` : ""
-  ].filter(Boolean).join(", ");
-  const head = `${merged} of ${total} tasks merged`;
-  return merged / total < DELIVERED_SHARE ? `\u26A0\uFE0F ${head} \u2014 ${parts}. Most of the plan did not land; the feature is not built.` : `${head} \u2014 ${parts}.`;
+  const failed = w.failed.length;
+  const blocked = w.skipped.length;
+  const total = w.waves.flat().length || failed + blocked;
+  return describeTally({ merged: Math.max(0, total - failed - blocked), failed, blocked, unfinished: 0 });
 }
 function describeTraceFailures(failed) {
   if (!failed.length) return "";
@@ -1001,6 +1487,13 @@ ${shown.join("\n")}`;
   return `\u26A0\uFE0F ${failed.length} failed:
 ${rows.join("\n")}`;
 }
+async function poolWithConfigured(catalog, configured, probe) {
+  const known = new Set(catalog);
+  const orphaned = configured.filter((m) => !known.has(m));
+  if (!orphaned.length) return catalog;
+  const alive = await Promise.all(orphaned.map(async (m) => await probe(m) ? m : void 0));
+  return [...catalog, ...alive.filter((m) => m !== void 0)];
+}
 function renderResult(res) {
   if (res.kind === "chat") return stripThinking(res.response);
   if (res.kind === "rejected") return `Not approved (stopped at the ${res.stage} stage).`;
@@ -1067,14 +1560,14 @@ async function main(argv) {
         read: read2,
         readFile: (p) => {
           try {
-            return readFileSync3(p, "utf8");
+            return readFileSync5(p, "utf8");
           } catch {
             return void 0;
           }
         },
         writeFile: (p, c) => {
-          mkdirSync3(dirname4(p), { recursive: true });
-          writeFileSync2(p, c);
+          mkdirSync5(dirname5(p), { recursive: true });
+          writeFileSync4(p, c);
         },
         home: process.env.HOME ?? "",
         log: (s) => console.log(s)
@@ -1084,6 +1577,76 @@ async function main(argv) {
     }
     return;
   }
+  if (argv[0] === "add-provider") {
+    const kind = argv[1];
+    if (!kind || !CLI_KINDS.includes(kind)) {
+      console.error(`add-provider needs a CLI to connect: ${CLI_KINDS.map((k) => `\`hcode add-provider ${k}\``).join(", ")}${argv[1] ? ` (got "${argv[1]}")` : ""}`);
+      process.exitCode = 1;
+      return;
+    }
+    const path = `${process.env.HOME ?? ""}/.horsecode/config.json`;
+    process.exitCode = await addProvider(kind, {
+      home: process.env.HOME ?? "",
+      readConfig: () => {
+        try {
+          const parsed = JSON.parse(readFileSync5(path, "utf8"));
+          return typeof parsed === "object" && parsed !== null ? parsed : {};
+        } catch {
+          return {};
+        }
+      },
+      writeConfig: (c) => {
+        mkdirSync5(dirname5(path), { recursive: true });
+        writeFileSync4(path, JSON.stringify(c, null, 2) + "\n");
+      },
+      /**
+       * "Make this profile real" means two different things, and z.ai is the one that is not a sign-in.
+       *
+       * The other three hand the terminal to their own OAuth. z.ai has none — a profile is a settings file
+       * holding an endpoint and a key — so here the step is: ask for the key, write it, and then SPEND one
+       * call proving it works. That last part is not ceremony: `claude auth status` reports any token as
+       * connected, valid or not, so without a real call a mistyped key would be filed as a working account
+       * and fail every call of the next run.
+       */
+      login: (k, dir) => k === "zai" ? connectZai(dir ?? "") : runLogin(k, dir),
+      check: checkProfile,
+      log: (line) => console.log(line)
+    });
+    return;
+  }
+  if (argv[0] === "remove-provider") {
+    const kind = argv[1];
+    if (!kind || !CLI_KINDS.includes(kind)) {
+      console.error(removeUsage(argv[1]));
+      process.exitCode = 1;
+      return;
+    }
+    const path = `${process.env.HOME ?? ""}/.horsecode/config.json`;
+    const home2 = process.env.HOME ?? "";
+    process.exitCode = removeProvider(kind, argv[2], {
+      home: home2,
+      readConfig: () => {
+        try {
+          const parsed = JSON.parse(readFileSync5(path, "utf8"));
+          return typeof parsed === "object" && parsed !== null ? parsed : {};
+        } catch {
+          return {};
+        }
+      },
+      writeConfig: (c) => {
+        mkdirSync5(dirname5(path), { recursive: true });
+        writeFileSync4(path, JSON.stringify(c, null, 2) + "\n");
+      },
+      removeDir: (dir) => {
+        rmSync(dir, { recursive: true, force: true });
+      },
+      confirm,
+      choose: chooseFrom,
+      usage: fileUsageStore(home2),
+      log: (line) => console.log(line)
+    }).code;
+    return;
+  }
   const cwd = process.cwd();
   const config = loadConfig({
     cwd,
@@ -1091,7 +1654,7 @@ async function main(argv) {
     env: process.env,
     readFile: (p) => {
       try {
-        return readFileSync3(p, "utf8");
+        return readFileSync5(p, "utf8");
       } catch {
         return void 0;
       }
@@ -1099,13 +1662,13 @@ async function main(argv) {
   });
   const home = process.env.HOME ?? "";
   if (!process.env.HC_HEAP_SET && !process.env.NODE_OPTIONS) {
-    const { spawnSync } = await import("child_process");
+    const { spawnSync: spawnSync2 } = await import("child_process");
     if (process.stdin.isTTY) process.stdin.setRawMode(false);
     const ignore = () => {
     };
     const SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
     for (const sig of SIGNALS) process.on(sig, ignore);
-    const r = spawnSync(process.execPath, [`--max-old-space-size=${HEAP_MB}`, ...process.argv.slice(1)], {
+    const r = spawnSync2(process.execPath, [`--max-old-space-size=${HEAP_MB}`, ...process.argv.slice(1)], {
       stdio: "inherit",
       /**
        * `NODE_ENV=production` is set here because it must be set BEFORE React is imported.
@@ -1141,12 +1704,28 @@ async function main(argv) {
     process.once("SIGTERM", flush);
   }
   const telemetryNote = sink ? `\u{1F4C8} Telemetry \u2192 \`${sink.path}\` (one JSON object per line)` : void 0;
-  const raw = new OmniRouteProvider({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+  const ambientLogins = CLI_KINDS.filter((k) => k !== "zai" && !config.accounts.some((a) => a.kind === k)).map((kind) => ({ kind, status: checkProfile(kind) }));
+  const accounts = new AccountPool(
+    [
+      ...config.accounts,
+      ...ambientLogins.filter((a) => a.status.loggedIn).map(({ kind, status }) => ({
+        kind,
+        name: status.email ?? `${kind}-default`,
+        ...status.email ? { email: status.email } : {},
+        ...status.plan ? { plan: status.plan } : {}
+      }))
+    ],
+    fileUsageStore(home)
+  );
+  const notSignedIn = ambientLogins.filter((a) => !a.status.loggedIn).map((a) => a.kind);
+  const accountsNote = () => accountsLine(accounts.usage(), notSignedIn);
+  const modelsPanelNote = (inUse) => modelsPanel(accounts.usage(), modelsFor, CLI_KINDS, inUse);
+  const raw = new CliProvider({ readOnly: false, accounts });
   const provider = config.telemetry ? telemetryProvider(raw, telemetry()) : raw;
   const skillRegistry = new SkillRegistry();
   await registerBuiltinSkills(skillRegistry);
   await skillRegistry.loadFromDir(externalSkillsDir(home));
-  const skillsDir = join8(cwd, ".horsecode", "skills");
+  const skillsDir = join11(cwd, ".horsecode", "skills");
   if (existsSync3(skillsDir)) await skillRegistry.loadFromDir(skillsDir);
   const worktreeHome = await mainWorktreeRoot(defaultGitRunner, cwd);
   if (worktreeHome !== cwd) {
@@ -1168,6 +1747,7 @@ async function main(argv) {
     manager,
     prAdapter,
     rules,
+    accounts,
     // Autonomous by default: a task that exhausts the escalation ladder is auto-retried (then abandoned) so
     // an unattended run finishes on its own instead of blocking on an interactive per-failure human prompt.
     askHuman: autonomousAskHuman(),
@@ -1178,25 +1758,12 @@ async function main(argv) {
   const useTui = shouldUseTui(!!process.stdin.isTTY, !!process.stdout.isTTY, !!args.noTui);
   if (!args.prompt) {
     if (useTui) {
-      const { runTuiRepl } = await import("./app-LAJN3TWC.js");
-      const { fetchCatalog, makeProbe, discoverSources } = await import("./discover-5URG7C4J.js");
+      const { runTuiRepl } = await import("./app-5FXHE7GX.js");
+      const { fetchCatalog, makeProbe, discoverSources } = await import("./discover-G2Z6XC3O.js");
       const { loadSourceCache, saveSourceCache } = await import("./source-cache-XEK5WN7I.js");
       const manualSources = config.modelSources.length > 0;
       const sourcesRef = { current: manualSources ? config.modelSources : loadSourceCache(home, config.baseUrl) ?? [] };
       const configuredModels = () => [...new Set(Object.values(config.roles).flatMap((r) => r.models ?? []))].filter((m) => m && m !== "default");
-      const listModels = async () => {
-        const catalog = await listOmniRouteModels({ baseUrl: config.baseUrl, apiKey: config.apiKey, sources: sourcesRef.current });
-        const known = new Set(catalog);
-        return [...catalog, ...configuredModels().filter((m) => !known.has(m))];
-      };
-      const refreshSources = async () => {
-        const catalog = await fetchCatalog({ baseUrl: config.baseUrl, apiKey: config.apiKey });
-        const found = await discoverSources({ catalog, probe: makeProbe({ baseUrl: config.baseUrl, apiKey: config.apiKey }) });
-        sourcesRef.current = found;
-        saveSourceCache(home, config.baseUrl, found);
-        return found;
-      };
-      const sourcesInfo = () => ({ sources: sourcesRef.current, manual: manualSources, needsDiscovery: !manualSources && sourcesRef.current.length === 0 });
       const probeModel = async (model) => {
         try {
           const res = await fetch(`${config.baseUrl.replace(/\/$/, "")}/api/v1/chat/completions`, {
@@ -1210,6 +1777,16 @@ async function main(argv) {
           return false;
         }
       };
+      const routableModel = makeProbe({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+      const listModels = async () => cliCatalog();
+      const refreshSources = async () => {
+        const catalog = await fetchCatalog({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+        const found = await discoverSources({ catalog, probe: makeProbe({ baseUrl: config.baseUrl, apiKey: config.apiKey }) });
+        sourcesRef.current = found;
+        saveSourceCache(home, config.baseUrl, found);
+        return found;
+      };
+      const sourcesInfo = () => ({ sources: sourcesRef.current, manual: manualSources, needsDiscovery: !manualSources && sourcesRef.current.length === 0 });
       const effectiveRoleSkills = (skill) => Object.keys(DEFAULT_ROLE_SKILLS).concat(Object.keys(config.roles)).filter((r, i, a) => a.indexOf(r) === i).filter((r) => (config.roles[r]?.skills ?? DEFAULT_ROLE_SKILLS[r] ?? []).includes(skill));
       const listSkills = () => skillRegistry.list().map((s) => ({
         ...s,
@@ -1232,7 +1809,7 @@ _Expected something like \`https://github.com/owner/repo\` or a link to the dire
 _Discoverable by every agent. \`/roles adjust\` assigns it to the roles it fits; \`/skills update\` re-installs it from upstream._`;
       };
       const reloadProjectSkills = async () => {
-        const dir = join8(cwd, ".horsecode", "skills");
+        const dir = join11(cwd, ".horsecode", "skills");
         if (existsSync3(dir)) await skillRegistry.loadFromDir(dir);
       };
       const updateSkills = async () => {
@@ -1322,6 +1899,8 @@ _Committed with the repo, so every clone starts with them. Agents read one with
       await runTuiRepl({
         buildDeps,
         memStore,
+        accountsNote,
+        modelsPanel: modelsPanelNote,
         listSkills,
         updateSkills,
         addSkill,
@@ -1341,7 +1920,8 @@ _Committed with the repo, so every clone starts with them. Agents read one with
         ...sink ? { telemetryPath: sink.path } : {},
         refreshSources,
         sourcesInfo,
-        probeModel
+        probeModel,
+        routableModel
       });
       return;
     }
@@ -1358,7 +1938,7 @@ _Committed with the repo, so every clone starts with them. Agents read one with
     ...args.revisionRounds !== void 0 && { revisionRounds: args.revisionRounds }
   };
   if (useTui) {
-    const { runTui } = await import("./app-LAJN3TWC.js");
+    const { runTui } = await import("./app-5FXHE7GX.js");
     const res = await runTui({ buildDeps, job });
     console.log(renderResult(res));
     return;
@@ -1405,12 +1985,12 @@ if (isMainModule()) {
   });
 }
 export {
-  DELIVERED_SHARE,
   describeDelivery,
   describeOutcome,
   describeTraceFailures,
   main,
   parseArgs,
+  poolWithConfigured,
   renderResult,
   shouldUseTui,
   whereItLanded