@hizliemre/horse-code 0.1.2 → 0.2.0

package/dist/{app-LAJN3TWC.js → app-2GPGCDX6.js}

@@ -4,45 +4,52 @@ import {
 import {
   MAX_PARALLEL_TASKS,
   MemoryStore,
-  isAnthropicModel,
   isUnknownModelError,
   makeAskUser,
   restoreOnExit,
   restoreTerminal,
   runJob,
   sttySane
-} from "./chunk-K2VERI5Q.js";
-import "./chunk-3UYA3KUG.js";
+} from "./chunk-23CLQ2KO.js";
+import "./chunk-M2RKCIGV.js";
 import {
-  CODE_TEAM,
-  DEFAULT_COUNCIL,
-  PLAN_TEAM,
+  DURABLE_ROLES,
   REQUIRED_ROLES,
+  ROLE_PROFILES,
   RoleFitness,
-  SPEC_TEAM,
+  adjustRoleModels,
   asChoice,
+  capabilityScore,
   describeUnfinished,
+  effortFor,
+  filterModelsForRole,
+  isKnownModel,
+  modelBand,
+  mostCapable,
+  newestPrimary,
+  sourceOf,
+  strongestPrimary,
   toSlug,
   unfinishedSessions
-} from "./chunk-RPVAIS3P.js";
+} from "./chunk-7JMWPTJ5.js";
 import "./chunk-QF4MP6BS.js";
-import "./chunk-EQX7BQYN.js";
-import "./chunk-FGVJFMK5.js";
+import "./chunk-UGESK765.js";
+import "./chunk-ZSQ24YDJ.js";
 import {
   saveRoleSkills
-} from "./chunk-4EWK7HWQ.js";
+} from "./chunk-KKWZBZYK.js";
 import {
   objectField,
   patchConfig
 } from "./chunk-H2FDGPVW.js";
-import "./chunk-NNTIACT4.js";
-import "./chunk-IW2KBAVZ.js";
+import "./chunk-MRZVA5JB.js";
+import "./chunk-LPQU436C.js";
 import {
   memoryNote,
   memoryState,
   walkFiles
-} from "./chunk-DRZSUQ7Q.js";
-import "./chunk-2SVAHH5N.js";
+} from "./chunk-LLL7QWXB.js";
+import "./chunk-63E73TGI.js";
 import {
   estimateFreezeSeconds,
   fmtDuration,
@@ -50,319 +57,24 @@ import {
   redactSecrets,
   relTime,
   stripThinking,
+  telemetry,
   writeHeapSnapshot
-} from "./chunk-VPAWRRHL.js";
-import "./chunk-DTWKSZXY.js";
+} from "./chunk-AE36LLL2.js";
+import "./chunk-6OSEQOYY.js";
 import {
   traceRootRel
-} from "./chunk-FFYBY2NA.js";
+} from "./chunk-KAGKX2YT.js";
 import {
   buildProjectGraph,
   graphStatus
-} from "./chunk-PGOYDOI4.js";
-import "./chunk-SSDLHWSF.js";
+} from "./chunk-XEGQT5EN.js";
 import {
   writeAtomic
-} from "./chunk-B67BK5GQ.js";
+} from "./chunk-6W4UH2BQ.js";
 
 // src/tui/app.tsx
 import { render } from "ink";
 
-// 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 excluded = new Set(exclude);
-  const avail = all.filter((m) => !excluded.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 key = modelFamily(m);
-    const cur = best.get(key);
-    if (!cur || capabilityScore(m) > capabilityScore(cur)) best.set(key, 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 key = versionlessId(head);
-  let best = head;
-  for (const m of pool) {
-    if (versionlessId(m) !== key) 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 key = baseModel(m);
-    const cur = best.get(key);
-    if (!cur || capabilityScore(m) > capabilityScore(cur)) best.set(key, m);
-  }
-  return [...best.values()].sort((a, b) => capabilityScore(b) - capabilityScore(a));
-}
-function sourceOf(model) {
-  const s = model.toLowerCase().replace(/^no-think\//, "");
-  const p = s.split("/")[0];
-  return p === "cc" ? "claude" : p === "cx" ? "codex" : p;
-}
-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/engine/role-tuner.ts
 function describeCatalog(models) {
   const bySource = /* @__PURE__ */ new Map();
@@ -4798,6 +4510,8 @@ var ModelHealth = class {
   fitness;
   listModels;
   probe;
+  /** Routability, not recovery — see ModelHealthOpts.routable. */
+  routable;
   note;
   now;
   /** Serializes healing: a whole review team failing at once must not trigger 14 concurrent re-assignments. */
@@ -4873,6 +4587,7 @@ var ModelHealth = class {
     this.port = opts.port;
     this.listModels = opts.listModels;
     this.probe = opts.probe;
+    this.routable = opts.routable;
     this.note = opts.note ?? (() => {
     });
     this.now = opts.now ?? (() => Date.now());
@@ -4893,7 +4608,38 @@ var ModelHealth = class {
   mark(model, reason) {
     for (const r of this.port.registries()) r.markExhausted(model, reason, this.now());
   }
-  /** Models that may be assigned right now: the catalog minus everything quarantined. */
+  /**
+   * Models that may be assigned right now: the catalog, minus everything quarantined, minus what no role has
+   * ever been configured with.
+   *
+   * The catalog is what the gateway LISTS, which is not what it will route to. Measured across a whole run:
+   * `opencode-go/muse-spark-1.2-contributor-xhigh` is in the catalog of 726 and answers every request with
+   * "not available in the active live catalog". It was in nobody's chain — `/roles adjust` had already
+   * dropped it — and re-assignment handed it out anyway, to twenty-three parallel slots at once. It took the
+   * ladders of twenty-one tasks and, through their dependencies, ninety-seven more.
+   *
+   * The configured set is the curated one: every model in it was chosen for a role and has been reached at
+   * least once. Preferring it costs nothing, because the wider catalog is still there when the curated pool
+   * is spent — which is the only situation that ever needed the breadth.
+   *
+   * That fallback is the door the herd came back through, so nothing walks through it unproven. Measured on
+   * the run after the preference was added: the curated pool emptied for about a minute, the catalog came
+   * back whole, and `muse-spark-1.2-contributor-xhigh` — ranked top by name alone — was handed to every role
+   * being re-assigned at the same instant. 204 calls left before the first answer could bench it. Its eight
+   * siblings each cost exactly ONE call, which is the bench working; the difference is only that they were
+   * not the head of the ranking.
+   *
+   * A probe is the cheapest thing that can tell "listed" from "routable", it runs only on this rare path, and
+   * `poolWithConfigured` already proves the same pattern at startup. It must be the ROUTABILITY probe (see
+   * `routable`): asking the recovery probe instead rejects everything the moment the fleet is busy, which is
+   * exactly when this path runs.
+   *
+   * And a probe that clears nothing does not get to strand every role. Measured live: "probed 78 catalog
+   * model(s) and dropped 78", then `No healthy model left to reassign code-data-integrity` — the lens kept
+   * its spent chain and returned UNVERIFIED, blocking the review. Handing back the unproven catalog risks
+   * one wasted call per model, which the bench ends and the ladder no longer charges for; handing back
+   * nothing leaves a role with no way to run at all. The first is recoverable, so it wins.
+   */
   async healthyModels() {
     const dead = new Set(this.quarantined().map((q) => q.model));
     let all;
@@ -4902,7 +4648,46 @@ var ModelHealth = class {
     } catch {
       return [];
     }
-    return all.filter((m) => !dead.has(m));
+    const live = all.filter((m) => !dead.has(m));
+    const configured = new Set(this.port.registries().flatMap((r) => r.knownModels()));
+    const curated = live.filter((m) => configured.has(m));
+    telemetry().event("decision.pool", {
+      "hc.decision": "pool",
+      "hc.pool.catalog": all.length,
+      "hc.pool.live": live.length,
+      "hc.pool.configured": configured.size,
+      "hc.pool.curated": curated.length,
+      "hc.pool.source": curated.length ? "curated" : "fallback"
+    });
+    if (curated.length) return curated;
+    const routable = this.routable;
+    if (!routable || !live.length) {
+      telemetry().event("decision.pool", {
+        "hc.decision": "pool",
+        "hc.pool.source": "unscreened",
+        "hc.pool.live": live.length,
+        "hc.pool.reason": routable ? "no live models" : "no routability probe"
+      });
+      return live;
+    }
+    const checked = await Promise.all(live.map(async (m) => ({ m, ok: await routable(m).catch(() => false) })));
+    const usable = checked.filter((c) => c.ok).map((c) => c.m);
+    if (!usable.length) {
+      this.note(`\u{1F50E} The configured models are all spent, and none of the ${checked.length} catalog model(s) answered a probe \u2014 offering them anyway rather than leaving roles with nothing.`);
+      return live;
+    }
+    const refused = checked.length - usable.length;
+    telemetry().event("decision.pool", {
+      "hc.decision": "pool",
+      "hc.pool.source": "probed",
+      "hc.pool.probed": checked.length,
+      "hc.pool.refused": refused,
+      "hc.pool.usable": usable.length
+    });
+    if (refused) {
+      this.note(`\u{1F50E} The configured models are all spent \u2014 probed ${checked.length} catalog model(s) and dropped ${refused} the gateway would not route to.`);
+    }
+    return usable;
   }
   /**
    * Re-probes the quarantine and releases whatever answers again. A 429 is a temporary limit, not a permanent
@@ -4970,6 +4755,12 @@ var ModelHealth = class {
       const reg = this.port.registryFor(role);
       const before = [...reg.rawChain(role)];
       reg.setRoleModel(role, chain);
+      telemetry().event("decision.rechain", {
+        "hc.decision": "rechain",
+        "hc.role": role,
+        "hc.chain": chain.join(","),
+        "hc.chain.before": before.join(",")
+      });
       out.push({ role, chain, before });
     }
     return out;
@@ -5373,6 +5164,12 @@ function startupSummary(f) {
     `- Rules: ${f.rules} active${f.rules ? " (`/memories` to read them)" : ""}`,
     `- Memory: ${plural(m.total, "entry", "entries")}${kinds ? ` \u2014 ${kinds}` : ""}`,
     `- Skills: ${plural(f.skills, "available", "available")}`,
+    /**
+     * The one line about what the work will be CHARGED to, so it sits with the rest of what the session has
+     * to work with. It was previously printed with `console.log` before this panel rendered — which the TUI
+     * then cleared, so a person with two working logins was shown nothing at all.
+     */
+    ...f.accounts ? [`- Accounts: ${f.accounts}`] : [],
     /**
      * "traces" is named precisely, because the word is taken.
      *
@@ -5460,6 +5257,12 @@ async function runTuiRepl(opts) {
     // STRICTER than source discovery, which counts 429 as "routed": a rate-limited model is exactly what was
     // quarantined, so only a real answer may release it.
     ...opts.probeModel ? { probe: opts.probeModel } : {},
+    /**
+     * …and the 429-tolerant one for the other question. `healthyModels` asks whether the gateway will ROUTE
+     * to a model, not whether a benched one has recovered, and it asks precisely when the fleet is busiest.
+     * Given the strict probe it dropped all 78 catalog models at once — see ModelHealthOpts.routable.
+     */
+    ...opts.routableModel ? { routable: opts.routableModel } : {},
     note: (m) => controller.note(m)
   });
   health.watch();
@@ -5570,7 +5373,7 @@ Question: ${question}` }
   };
   const addMcp = async (input) => {
     const { parseCommand, parseConfigBlock, extractFromPage, verify } = await import("./install-O34KMWJB.js");
-    const { saveMcpServer } = await import("./save-skills-NSLBU33X.js");
+    const { saveMcpServer } = await import("./save-skills-X7U3KCPU.js");
     let cand = parseCommand(input) ?? parseConfigBlock(input);
     if (!cand) {
       const url = input.trim();
@@ -5619,7 +5422,7 @@ _Restart to connect it._`;
   const baseRef = { current: opts.jobBase.fromBranch };
   const continueFromClaude = async (arg) => {
     const { adoptClaudeWorktree, describeAdoption, AdoptError, listClaudeWorktrees } = await import("./worktree-F7TWLWLN.js");
-    const { defaultGitRunner } = await import("./git-VTSZALSR.js");
+    const { defaultGitRunner } = await import("./git-QZTDZSJY.js");
     const git = defaultGitRunner;
     try {
       const w = await adoptClaudeWorktree(git, process.cwd(), arg, baseRef.current);
@@ -5642,7 +5445,7 @@ _This project has no worktrees under \`.claude/worktrees\`._`}`);
   const migrate = async () => {
     if (!opts.memStore) return "Migration needs the memory store, which is not available in this session.";
     const progressLines = /* @__PURE__ */ new Map();
-    const { runMigration, describeResult } = await import("./run-LQOZ5I7Z.js");
+    const { runMigration, describeResult } = await import("./run-P6ZYL5JL.js");
     const r = await runMigration({
       cwd: process.cwd(),
       home: homedir2(),
@@ -5871,6 +5674,10 @@ _${saved ? `Saved to your config \u2014 future sessions start with these. ` : ""
       constitution: existsSync(join6(process.cwd(), ".specify", "memory", "constitution.md")),
       graph: { built: false, nodes: 0 },
       traceRoot: traceRootRel(),
+      ...(() => {
+        const a = opts.accountsNote?.();
+        return a ? { accounts: a } : {};
+      })(),
       ...unfinished.length ? { unfinished } : {},
       ...startupExtra
     };
@@ -5899,12 +5706,12 @@ _${saved ? `Saved to your config \u2014 future sessions start with these. ` : ""
   paintSummary();
   void (async () => {
     try {
-      const { defaultGitRunner } = await import("./git-VTSZALSR.js");
+      const { defaultGitRunner } = await import("./git-QZTDZSJY.js");
       const { recordedMainBranch, detectMainBranch } = await import("./main-branch-KGWUINYQ.js");
       const cwd = process.cwd();
       const main = await recordedMainBranch(cwd) ?? await detectMainBranch(cwd, defaultGitRunner);
       if (!main) return;
-      const { ongoingWork, chooseOngoing } = await import("./ongoing-XP6WXNI7.js");
+      const { ongoingWork, chooseOngoing } = await import("./ongoing-WHYXPW24.js");
       const open = await ongoingWork(defaultGitRunner, cwd, main);
       if (!open.length) return;
       const picked = await chooseOngoing(deps, read, open[0]?.language, open);
@@ -5923,11 +5730,11 @@ _${saved ? `Saved to your config \u2014 future sessions start with these. ` : ""
   })();
   void (async () => {
     try {
-      const { loadTraceIndex } = await import("./trace-ZMB7LT7W.js");
+      const { loadTraceIndex } = await import("./trace-X6TU3AG6.js");
       let index = await loadTraceIndex(process.cwd());
       startupExtra.traces = Object.keys(index.traces).length;
       paintSummary();
-      const { graphStatus: graphStatus2 } = await import("./project-graph-IOPCSZUA.js");
+      const { graphStatus: graphStatus2 } = await import("./project-graph-5HNPRFQG.js");
       const g = await graphStatus2(process.cwd());
       startupExtra.graph = { built: g.built, nodes: g.nodes, stale: g.stale };
       if (!g.built || g.stale) {
@@ -5936,11 +5743,11 @@ _${saved ? `Saved to your config \u2014 future sessions start with these. ` : ""
         const after = await graphStatus2(process.cwd());
         startupExtra.graph = { built: after.built, nodes: after.nodes, stale: after.stale };
       }
-      const g0 = await import("./project-graph-IOPCSZUA.js").then((m) => m.loadGraphSync(process.cwd()));
+      const g0 = await import("./project-graph-5HNPRFQG.js").then((m) => m.loadGraphSync(process.cwd()));
       if (g0) {
         const files = /* @__PURE__ */ new Set();
         for (const n of g0.nodes) if (n.source_file) files.add(n.source_file);
-        const { adoptDocs, indexAdoption, describeAdoption } = await import("./trace-adopt-C6TUWFJL.js");
+        const { adoptDocs, indexAdoption, describeAdoption } = await import("./trace-adopt-URECQWJV.js");
         const adoption = await adoptDocs(process.cwd(), files);
         const { readFile: readFile5 } = await import("fs/promises");
         const r = await indexAdoption(
@@ -5956,8 +5763,8 @@ _${saved ? `Saved to your config \u2014 future sessions start with these. ` : ""
       }
       startupExtra.traces = Object.keys(index.traces).length;
       paintSummary();
-      const { traceableFiles } = await import("./trace-run-F23MFTY4.js");
-      const { traceCoverage } = await import("./trace-ZMB7LT7W.js");
+      const { traceableFiles } = await import("./trace-run-7U4WJZ3V.js");
+      const { traceCoverage } = await import("./trace-X6TU3AG6.js");
       startupExtra.coverage = await traceCoverage(process.cwd(), await traceableFiles(process.cwd()), index);
       paintSummary();
     } catch {