@hizliemre/horse-code 0.1.1 → 0.2.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-2DGO2BUB.js";
-import {
-  listOmniRouteModels
-} from "./chunk-O74BDQKS.js";
-import "./chunk-F2IALVBU.js";
+} from "./chunk-23CLQ2KO.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,
   buildCouncilRegistry,
   buildTeamRegistry,
+  checkProfile,
+  cliCatalog,
   mainWorktreeRoot,
+  runLogin,
   toSlug
-} from "./chunk-3XVZXTB6.js";
+} from "./chunk-7JMWPTJ5.js";
 import "./chunk-QF4MP6BS.js";
-import "./chunk-HBSC2HT2.js";
-import "./chunk-FGVJFMK5.js";
+import "./chunk-UGESK765.js";
+import "./chunk-ZSQ24YDJ.js";
 import {
   parseFrontmatter
 } from "./chunk-BY4DP7IE.js";
@@ -45,7 +48,7 @@ import {
   UNSET_MODEL,
   loadConfig,
   saveSkillSource
-} from "./chunk-4EWK7HWQ.js";
+} from "./chunk-KKWZBZYK.js";
 import "./chunk-H2FDGPVW.js";
 import {
   buildBrief,
@@ -53,50 +56,234 @@ 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-TOPZL5SU.js";
-import "./chunk-2SVAHH5N.js";
+} from "./chunk-LLL7QWXB.js";
+import "./chunk-63E73TGI.js";
 import {
   Telemetry,
+  ToolRegistry,
   clearPerfMarks,
   sampleMemory,
   setTelemetry,
   stripThinking,
   telemetry,
   writeHeapSnapshot
-} from "./chunk-YILDXPSI.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 readFileSync4, existsSync as existsSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, realpathSync } from "fs";
+import { join as join10, 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 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) {
+  return status.email ?? `${kind}-${dir.split("/").pop() ?? "profile"}`;
+}
+function withAmbient(kind, existing, ambient) {
+  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 (e.kind !== "claude" && e.kind !== "codex") return false;
+    return e.configDir === void 0 || typeof e.configDir === "string";
+  });
+}
+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);
+  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 = io.login(kind, dir);
+  if (!r.ok) {
+    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 use them in order, spilling to the next when one is nearly out.`);
+  return 0;
+}
+
 // src/skills/registry.ts
 import { readdir, readFile } from "fs/promises";
-import { join } from "path";
+import { join as join3 } from "path";
 var SkillRegistry = class {
   skills = /* @__PURE__ */ new Map();
   register(skill) {
@@ -119,7 +306,7 @@ var SkillRegistry = class {
       if (!e.isDirectory()) continue;
       let raw;
       try {
-        raw = await readFile(join(dir, e.name, "SKILL.md"), "utf8");
+        raw = await readFile(join3(dir, e.name, "SKILL.md"), "utf8");
       } catch {
         continue;
       }
@@ -127,17 +314,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: join3(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 join4, 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 +342,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(join4(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: join4(dir, e.name) });
       }
       if (!found.length) continue;
       for (const s of found) registry.register(s);
@@ -177,12 +364,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 join5 } 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 join5(home, ".horsecode", "skills");
 }
 function validName(name) {
   return /^[A-Za-z0-9._-]+$/.test(name) && !name.includes("..");
@@ -226,7 +413,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(join5(externalSkillsDir(home), name, PROVENANCE), "utf8"));
   } catch {
     return void 0;
   }
@@ -236,27 +423,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 = join5(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(join5(dest, "SKILL.md"))) {
     return { name: src.name, sha, changed: false };
   }
-  const staging = join3(tmpdir(), `hc-skill-${src.name}-${sha.slice(0, 8)}`);
+  const staging = join5(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 ? join5(staging, src.path) : staging;
+    if (!existsSync(join5(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(join5(dest, PROVENANCE), `${JSON.stringify(record, null, 2)}
 `, "utf8");
     return { name: src.name, sha, changed: true };
   } finally {
@@ -546,8 +733,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 mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 var TEMPLATE_FILES = {
   spec: "spec-template.md",
   plan: "plan-template.md",
@@ -570,10 +757,10 @@ async function loadSpecKit(opts) {
     );
   }
   const fetchFn = opts.fetch ?? globalThis.fetch;
-  const cacheDir = join4(opts.home, ".horsecode", "spec-kit", opts.version, "templates");
+  const cacheDir = join6(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 = join6(cacheDir, relPath);
+    if (existsSync2(cachePath)) return readFileSync2(cachePath, "utf8");
     const url = `${RAW_BASE}/${opts.version}/templates/${relPath}`;
     const res = await fetchFn(url);
     if (!res.ok) {
@@ -583,8 +770,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");
+    mkdirSync2(dirname3(cachePath), { recursive: true });
+    writeFileSync2(cachePath, text, "utf8");
     return text;
   };
   const templates = {};
@@ -600,7 +787,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 join7 } from "path";
 async function buildJobDeps(opts) {
   const { config } = opts;
   const roles = {};
@@ -612,6 +799,10 @@ 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") }));
+  }
   const fillModels = (r) => ({
     ...r,
     models: r.models.length > 0 ? r.models : config.roles[r.name]?.models ?? sessionChain
@@ -637,10 +828,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(join7(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 +873,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 +948,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 +959,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 +978,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 +1020,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 mkdirSync3 } from "fs";
+import { join as join8 } from "path";
 function telemetryDir(home) {
-  return join6(home, ".horsecode", "telemetry");
+  return join8(home, ".horsecode", "telemetry");
 }
 var MAX_QUEUE = 1e4;
 var FileSink = class {
@@ -791,9 +1032,9 @@ var FileSink = class {
   dropped = 0;
   path;
   constructor(home, runId) {
-    this.path = join6(telemetryDir(home), `${runId}.jsonl`);
+    this.path = join8(telemetryDir(home), `${runId}.jsonl`);
     try {
-      mkdirSync2(telemetryDir(home), { recursive: true });
+      mkdirSync3(telemetryDir(home), { recursive: true });
       this.stream = createWriteStream(this.path, { flags: "a" });
       this.stream.on("error", () => {
         this.stream = void 0;
@@ -825,16 +1066,18 @@ var FileSink = class {
     return this.dropped;
   }
   /**
-   * A stream that failed to open never calls `end`'s callback, and this awaited it forever.
+   * `flush()` is awaited as a run finishes, so whatever happens here decides whether the run can end.
    *
-   * `createWriteStream` does not throw when the path cannot be opened — it emits `error` on a later tick. So
+   * `createWriteStream` does not throw when the path cannot be opened — it emits `error` on a later tick, so
    * the constructor's `catch` does not run, `stream` is set, and whether the error handler has cleared it by
-   * the time anything flushes is a race with the event loop. Lose that race and `end(cb)` is called on a
-   * broken stream, the callback is never invoked, and the promise has nothing left to resolve it.
+   * the time anything flushes is a race with the event loop. Losing that race means `end(cb)` is called on a
+   * stream that never opened.
    *
-   * The observer then outlives what it observes: `flush()` is awaited as a run finishes, so a machine that
-   * cannot write the log cannot finish the run either. The `error` listener is the second exit, and either
-   * one is enough.
+   * The `error` listener is a second exit for that case. It was added believing the callback would otherwise
+   * never fire and hang the run — an honest guess that has since been TESTED and did not hold: with the
+   * listener removed, an EISDIR stream still resolves (test/obs/telemetry.test.ts). It stays because it
+   * costs one line and closes a path nothing else covers, not because a hang was ever reproduced through it.
+   * The 3h42m CI hang this was written during had a different cause, in the tests themselves.
    */
   async flush() {
     const s = this.stream;
@@ -848,13 +1091,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 readFileSync3 } from "fs";
+import { dirname as dirname4, join as join9 } 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(readFileSync3(join9(here, "..", "package.json"), "utf8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -881,6 +1124,7 @@ 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 or codex subscription, through that CLI's own sign-in",
     "",
     "OPTIONS",
     "  -b, --branch <name>        branch the session's worktree from this ref (default: current branch)",
@@ -943,7 +1187,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.";
   }
@@ -959,12 +1203,8 @@ function whereItLanded(path) {
   return `Written on ${branch ? `branch \`${branch}\`` : "its own branch"}, in the worktree at \`${base}\`. Review it there, then merge it in.`;
 }
 function describeDelivery(d) {
-  if (d.mergedInto) {
-    return `Merged into \`${d.mergedInto}\` \u2014 the files are in your working copy.`;
-  }
   return [
     `**The work is on branch \`${d.branch}\`** \u2014 not in your working copy yet.`,
-    d.notMerged ? `Not merged: ${d.notMerged}.` : "",
     "",
     "To bring it in:",
     "```",
@@ -973,6 +1213,37 @@ function describeDelivery(d) {
     `Or inspect it first: \`git diff HEAD...${d.branch}\` \xB7 worktree: \`${d.worktree}\``
   ].filter((l) => l !== void 0).join("\n");
 }
+function describeOutcome(w) {
+  if (w.status === "completed") return w.pr ? `PR: ${w.pr.url}` : "all tasks merged";
+  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 "";
+  const byError = /* @__PURE__ */ new Map();
+  for (const f of failed) byError.set(f.error, [...byError.get(f.error) ?? [], f.file]);
+  if (byError.size === 1) {
+    const [error, files] = [...byError][0];
+    const shown = files.slice(0, 3).map((f) => `- \`${f}\``);
+    if (files.length > shown.length) shown.push(`- \u2026and ${files.length - shown.length} more`);
+    return `\u26A0\uFE0F ${failed.length} failed, all for the same reason \u2014 ${error}
+${shown.join("\n")}`;
+  }
+  const rows = [...byError].sort((a, b) => b[1].length - a[1].length).slice(0, 5).map(([error, files]) => `- ${files.length}\xD7 ${error} (e.g. \`${files[0]}\`)`);
+  const rest = byError.size - rows.length;
+  if (rest > 0) rows.push(`- \u2026and ${rest} further cause(s)`);
+  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).`;
@@ -984,7 +1255,7 @@ function renderResult(res) {
 
 _${whereItLanded(res.path)}_` : `The constitution phase finished without writing \`${res.path}\` \u2014 nothing was changed.`;
   }
-  const outcome = res.wave.status === "completed" ? res.wave.pr ? `PR: ${res.wave.pr.url}` : "all tasks completed" : `Partial: ${res.wave.failed.length} failed, ${res.wave.skipped.length} skipped`;
+  const outcome = describeOutcome(res.wave);
   const rev = res.revision ? `
 revision: ${res.revision.status}` : "";
   return `${stripThinking(res.report)}
@@ -1039,14 +1310,14 @@ async function main(argv) {
         read: read2,
         readFile: (p) => {
           try {
-            return readFileSync3(p, "utf8");
+            return readFileSync4(p, "utf8");
           } catch {
             return void 0;
           }
         },
         writeFile: (p, c) => {
-          mkdirSync3(dirname4(p), { recursive: true });
-          writeFileSync2(p, c);
+          mkdirSync4(dirname5(p), { recursive: true });
+          writeFileSync3(p, c);
         },
         home: process.env.HOME ?? "",
         log: (s) => console.log(s)
@@ -1056,6 +1327,34 @@ async function main(argv) {
     }
     return;
   }
+  if (argv[0] === "add-provider") {
+    const kind = argv[1];
+    if (kind !== "claude" && kind !== "codex") {
+      console.error(`add-provider needs a CLI to connect: \`hcode add-provider claude\` or \`hcode add-provider codex\`${kind ? ` (got "${kind}")` : ""}`);
+      process.exitCode = 1;
+      return;
+    }
+    const path = `${process.env.HOME ?? ""}/.horsecode/config.json`;
+    process.exitCode = addProvider(kind, {
+      home: process.env.HOME ?? "",
+      readConfig: () => {
+        try {
+          const parsed = JSON.parse(readFileSync4(path, "utf8"));
+          return typeof parsed === "object" && parsed !== null ? parsed : {};
+        } catch {
+          return {};
+        }
+      },
+      writeConfig: (c) => {
+        mkdirSync4(dirname5(path), { recursive: true });
+        writeFileSync3(path, JSON.stringify(c, null, 2) + "\n");
+      },
+      login: runLogin,
+      check: checkProfile,
+      log: (line) => console.log(line)
+    });
+    return;
+  }
   const cwd = process.cwd();
   const config = loadConfig({
     cwd,
@@ -1063,7 +1362,7 @@ async function main(argv) {
     env: process.env,
     readFile: (p) => {
       try {
-        return readFileSync3(p, "utf8");
+        return readFileSync4(p, "utf8");
       } catch {
         return void 0;
       }
@@ -1113,12 +1412,27 @@ 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 = ["claude", "codex"].filter((k) => !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 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 = join10(cwd, ".horsecode", "skills");
   if (existsSync3(skillsDir)) await skillRegistry.loadFromDir(skillsDir);
   const worktreeHome = await mainWorktreeRoot(defaultGitRunner, cwd);
   if (worktreeHome !== cwd) {
@@ -1140,6 +1454,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(),
@@ -1150,25 +1465,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-UGFQKMLX.js");
-      const { fetchCatalog, makeProbe, discoverSources } = await import("./discover-5URG7C4J.js");
+      const { runTuiRepl } = await import("./app-2GPGCDX6.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`, {
@@ -1182,6 +1484,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,
@@ -1204,7 +1516,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 = join10(cwd, ".horsecode", "skills");
         if (existsSync3(dir)) await skillRegistry.loadFromDir(dir);
       };
       const updateSkills = async () => {
@@ -1284,19 +1596,17 @@ _Every agent can query it: \`graph_impact\` (blast radius), \`graph_trace\`, \`g
         if (res.upToDate) bits.push(`${res.upToDate} already current`);
         if (res.pruned.length) bits.push(`${res.pruned.length} removed for deleted files`);
         if (res.wroteGitignore) bits.push("\n\n_Added .gitignore rules: traces are committed, the AST cache is not._");
-        if (res.failed.length) {
-          bits.push(`
+        const failures = describeTraceFailures(res.failed);
+        return `${bits.join(" \xB7 ")}${failures ? `
 
-\u26A0\uFE0F ${res.failed.length} failed:
-${res.failed.slice(0, 5).map((f) => `- \`${f.file}\` \u2014 ${f.error}`).join("\n")}`);
-        }
-        return `${bits.join(" \xB7 ")}
+${failures}` : ""}
 
 _Committed with the repo, so every clone starts with them. Agents read one with \`graph_trace\`._`;
       };
       await runTuiRepl({
         buildDeps,
         memStore,
+        accountsNote,
         listSkills,
         updateSkills,
         addSkill,
@@ -1316,7 +1626,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;
     }
@@ -1333,7 +1644,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-UGFQKMLX.js");
+    const { runTui } = await import("./app-2GPGCDX6.js");
     const res = await runTui({ buildDeps, job });
     console.log(renderResult(res));
     return;
@@ -1381,8 +1692,11 @@ if (isMainModule()) {
 }
 export {
   describeDelivery,
+  describeOutcome,
+  describeTraceFailures,
   main,
   parseArgs,
+  poolWithConfigured,
   renderResult,
   shouldUseTui,
   whereItLanded