@hizliemre/horse-code 0.3.0 → 0.4.0

package/dist/chunk-ACTVFJRW.js

@@ -0,0 +1,989 @@
+import {
+  CODE_TEAM,
+  DEFAULT_COUNCIL,
+  PLAN_TEAM,
+  SPEC_TEAM,
+  applySkills
+} from "./chunk-MZM24M5M.js";
+import {
+  CLI_KINDS
+} from "./chunk-G45RWL7S.js";
+import {
+  defaultGitRunner
+} from "./chunk-LPQU436C.js";
+import {
+  briefForPrompt,
+  briefPrompt,
+  briefStatus,
+  gatherBriefInput,
+  saveBrief
+} from "./chunk-6S4WWQMN.js";
+import {
+  ensureGitignore,
+  loadTraceIndex,
+  planTraces,
+  pruneTraces,
+  saveTrace,
+  saveTraceIndex,
+  traceCoverage,
+  tracePrompt,
+  traceRootRel,
+  traceable
+} from "./chunk-ZPJP2VH5.js";
+import {
+  loadGraph
+} from "./chunk-4M6LXNG2.js";
+
+// src/agents/cli-models.ts
+var CLAUDE_MODELS = ["fable", "opus", "sonnet", "haiku"];
+var CODEX_MODELS = ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.6-luna"];
+var CODEX_DEFAULT = "gpt-5.6-terra";
+var GROK_MODELS = ["grok-4.6", "grok-4.5"];
+function grokEffort(effort) {
+  const e = effort.toLowerCase();
+  if (e === "xhigh" || e === "high" || e === "medium" || e === "low") return e;
+  if (e === "max" || e === "ultra") return "xhigh";
+  if (e === "minimal") return "low";
+  return void 0;
+}
+var ZAI_MODELS = ["glm-5.3", "glm-5.3-flash"];
+function modelsFor(kind) {
+  if (kind === "claude") return CLAUDE_MODELS;
+  if (kind === "codex") return CODEX_MODELS;
+  if (kind === "grok") return GROK_MODELS;
+  return ZAI_MODELS;
+}
+function cliCatalog() {
+  return CLI_KINDS.flatMap((k) => [...modelsFor(k)]);
+}
+function cliFor(model) {
+  const m = model.toLowerCase().replace(/^no-think\//, "").replace(/^(cc|claude|cx|codex)\//, "");
+  if (/^(fable|opus|sonnet|haiku)\b/.test(m) || m.startsWith("claude")) return "claude";
+  if (/^(codex|gpt|o[0-9])\b/.test(m)) return "codex";
+  if (/^grok(-|$)/.test(m)) return "grok";
+  if (/^glm(-|$)/.test(m)) return "zai";
+  return void 0;
+}
+function cliInvocation(model) {
+  const bare = model.replace(/^no-think\//, "").replace(/^(cc|claude|cx|codex)\//, "");
+  const effort = /-(ultra|max|xhigh|high|medium|low|minimal)$/.exec(bare)?.[1];
+  const name = effort ? bare.slice(0, -(effort.length + 1)) : bare;
+  const resolved = name === "codex" ? CODEX_DEFAULT : name;
+  return {
+    ...resolved ? { model: resolved } : {},
+    ...effort ? { effort } : {}
+  };
+}
+
+// src/providers/anthropic.ts
+function isAnthropicModel(model) {
+  return /(^|\/)(claude|fable|mythos)/i.test(model) || /claude/i.test(model);
+}
+
+// src/tui/role-models.ts
+var WEAK_RE = /\b(flash|mini|nano|haiku|lite|small|turbo|fast|\d{1,2}b)\b/i;
+var FLAGSHIP_ROLES = ["judge", "principal-coder"];
+var COUNCIL_ROLES = DEFAULT_COUNCIL.map((c) => c.name);
+var SPEC_LENS_ROLES = SPEC_TEAM.map((c) => c.name);
+var PLAN_LENS_ROLES = PLAN_TEAM.map((c) => c.name);
+var CODE_LENS_ROLES = CODE_TEAM.map((c) => c.name);
+var STRONG_ROLES = [
+  "brainstormer",
+  "analyst",
+  "planner",
+  "architect",
+  "senior-coder",
+  "senior-designer",
+  ...COUNCIL_ROLES,
+  ...PLAN_LENS_ROLES,
+  ...CODE_LENS_ROLES
+];
+var MID_ROLES = ["coach", "coder", "designer", "code-reviewer", "operational", "memory-keeper", "task-auditor", ...SPEC_LENS_ROLES];
+var FAST_ROLES = ["refiner", "router", "project-manager", "team-lead"];
+var CAPABLE_ROLES = /* @__PURE__ */ new Set([...FLAGSHIP_ROLES, ...STRONG_ROLES, ...MID_ROLES]);
+var ROLE_PROFILES = {
+  tracer: "Writes the per-file reference note every other agent reads before changing unfamiliar code \u2014 high volume, but its output is a COMMITTED FILE, not a turn in a conversation: a shallow note is believed by every agent that opens that file, forever, and nothing later corrects it. Give it the MOST capable non-[flagship] model in the catalogue, not merely one that qualifies as [strong]. Volume is not a reason to go cheaper here.",
+  refiner: "Classifies intent and rewrites the prompt every turn \u2014 highest call volume, trivial task \u2192 a fast, cheap model.",
+  router: "Picks coder-vs-designer for a task \u2014 tiny and frequent \u2192 fast, cheap.",
+  "project-manager": "Turns a task list into board items \u2014 light and structured \u2192 fast, cheap.",
+  "task-auditor": "The only check on the task breakdown before hours of implementation are spent executing it \u2014 reads the plan against the task list and finds what was dropped. Low volume, and everything downstream depends on it \u2192 a capable model, never the cheapest.",
+  "team-lead": "Coordinates implementation waves \u2014 light orchestration \u2192 fast, cheap.",
+  coach: "Your main interactive assistant, used constantly all session (highest interaction volume) \u2192 a capable but EFFICIENT model, never the costly flagship.",
+  brainstormer: "Turns a raw request into a decided design before the spec: explores the repo, weighs 2-3 approaches, gets the user to choose. Low volume, sets the direction for everything downstream \u2192 a strong reasoning model.",
+  analyst: "Authors the spec and constitution \u2192 a strong reasoning model (Opus-tier).",
+  planner: "Designs the implementation plan \u2192 a strong reasoning model (Opus-tier).",
+  architect: "Diagnoses stuck tasks and produces recovery plans \u2014 serious design work \u2192 a strong model.",
+  judge: "Critiques specs/plans and makes the final review call \u2014 low volume, high stakes \u2192 the most capable flagship model.",
+  coder: "Writes the bulk of the implementation \u2014 very high work volume \u2192 a good high-throughput coding model (Sonnet-tier), NOT the flagship (wasteful at this volume).",
+  "senior-coder": "Reviews and revises above the coder \u2014 must be MORE capable than the coder (Opus-tier).",
+  "principal-coder": "Final code decision-maker \u2014 low volume, high stakes \u2192 the flagship is appropriate.",
+  designer: "Builds UI \u2014 high volume \u2192 a capable coding/design model, not the flagship.",
+  "senior-designer": "Senior UI reviewer \u2014 more capable than the designer.",
+  "code-reviewer": "Reviews diffs \u2014 moderate volume \u2192 a solid capable model.",
+  "memory-keeper": "Decides what a finished job taught the project and writes it to durable memory \u2014 low volume, but a bad memory poisons every later run \u2192 a capable, efficient model, never the cheapest.",
+  operational: "Handles version control: writes conventional commit messages and (later) drives merges/conflicts \u2014 high volume \u2192 a capable, efficient model."
+};
+for (const [stage, lenses, heft] of [
+  ["spec", SPEC_TEAM, "a capable, efficient model (a spec is a short business-level doc)"],
+  ["plan", PLAN_TEAM, "a strong model (technical design judgment)"],
+  ["code", CODE_TEAM, "a strong model (reads real implementations)"]
+]) {
+  for (const l of lenses) ROLE_PROFILES[l.name] = `${stage.toUpperCase()}-review lens \u2014 ${l.perspective}. Low volume, quality-critical \u2192 ${heft}.`;
+}
+for (const c of DEFAULT_COUNCIL) {
+  ROLE_PROFILES[c.name] = `Review COUNCIL decider \u2014 ${c.perspective} Casts the binding pass/revise vote on contested work \u2192 a strong model.`;
+}
+var ROLE_ADVICE = ROLE_PROFILES;
+function filterModelsForRole(role, all, exclude = []) {
+  const advice = ROLE_ADVICE[role];
+  const 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 (/grok/.test(s)) return 78 + versionBump(s, "grok");
+  if (/glm/.test(s)) return 78 + versionBump(s, "glm");
+  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\//, "");
+  return cliFor(s) ?? s.split("/")[0];
+}
+function interleaveBySource(pool) {
+  const bySource = /* @__PURE__ */ new Map();
+  for (const m of pool) {
+    const s = sourceOf(m);
+    const q = bySource.get(s);
+    if (q) q.push(m);
+    else bySource.set(s, [m]);
+  }
+  const queues = [...bySource.values()];
+  const out = [];
+  for (let more = true; more; ) {
+    more = false;
+    for (const q of queues) {
+      const m = q.shift();
+      if (m !== void 0) {
+        out.push(m);
+        more = true;
+      }
+    }
+  }
+  return out;
+}
+var BAND_ORDER = { fast: 0, mid: 1, strong: 2, flagship: 3 };
+function bandDistance(primary, candidate) {
+  const p = BAND_ORDER[modelBand(primary)];
+  const c = BAND_ORDER[modelBand(candidate)];
+  return Math.abs(c - p) * 2 + (c < p ? 1 : 0);
+}
+var MAX_BAND_DROP = 1;
+function isPeer(primary, candidate) {
+  return BAND_ORDER[modelBand(primary)] - BAND_ORDER[modelBand(candidate)] <= MAX_BAND_DROP;
+}
+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;
+    if (!isPeer(primary, m)) continue;
+    chosen.push(m);
+    usedModels.add(baseModel(m));
+    usedSources.add(sourceOf(m));
+  }
+  return chosen;
+}
+function bestPerSource(pool, exclude = []) {
+  const skip = new Set(exclude.map(baseModel));
+  const best = /* @__PURE__ */ new Map();
+  for (const m of pool) {
+    if (skip.has(baseModel(m))) continue;
+    const src = sourceOf(m);
+    const held = best.get(src);
+    if (!held || capabilityScore(m) > capabilityScore(held)) best.set(src, m);
+  }
+  return interleaveBySource([...best.values()].sort((a, b) => capabilityScore(b) - capabilityScore(a)));
+}
+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 = bestPerSource(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 = bestPerSource(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/agent/roles.ts
+function isTransientFailure(reason) {
+  const r = reason.toLowerCase();
+  if (/\b(429|rate.?limit|quota|exhaust|insufficient|billing|credit)\b/.test(r)) return false;
+  return /overload|529|50[0234]|timeout|timed out|deadline|econnreset|epipe|socket hang up|stream ended|temporar|unavailable|try again/.test(r);
+}
+function isSourceCapacity(reason) {
+  return /capacity is (?:temporarily unavailable|busy)/i.test(reason);
+}
+function sourcePrefix(model) {
+  const s = model.replace(/^no-think\//, "");
+  const cli = cliFor(s);
+  if (cli) return cli;
+  const i = s.indexOf("/");
+  return i > 0 ? s.slice(0, i) : void 0;
+}
+function weightedCycle(sources, weights) {
+  const queues = sources.map((s) => Array(Math.max(1, weights[s] ?? 1)).fill(s));
+  const out = [];
+  for (let more = true; more; ) {
+    more = false;
+    for (const q of queues) {
+      const m = q.shift();
+      if (m !== void 0) {
+        out.push(m);
+        more = true;
+      }
+    }
+  }
+  return out;
+}
+function canonicalSource(name) {
+  const s = name.toLowerCase().replace(/^no-think\//, "");
+  if (s === "cc" || s === "claude") return "claude";
+  if (s === "cx") return "codex";
+  return sourcePrefix(s) ?? s;
+}
+function providerOutage(reason) {
+  return /no active credentials for provider:?\s*([\w.-]+)/i.exec(reason)?.[1] ?? /provider\s+'?([\w.-]+)'?\s+is not configured/i.exec(reason)?.[1] ?? /all\s+([\w.-]+)\s+accounts have exhausted their quota/i.exec(reason)?.[1] ?? /shared egress ip quota exhausted\s*\(([\w.-]+)\)/i.exec(reason)?.[1] ?? /^\s*(claude|codex|grok|zai)\s+CLI:\s*rejected\b/i.exec(reason)?.[1]?.toLowerCase();
+}
+function quotaResetAt(reason) {
+  const iso = /\(resets\s+([0-9T:.\-]+Z)\)/i.exec(reason)?.[1];
+  const t = iso ? Date.parse(iso) : NaN;
+  return Number.isFinite(t) ? t : void 0;
+}
+var RoleRegistry = class _RoleRegistry {
+  // durable behavioral rules → appended to EVERY role's prompt
+  constructor(roles, defaultPrompts = {}, skillRegistry) {
+    this.roles = roles;
+    this.defaultPrompts = defaultPrompts;
+    this.skillRegistry = skillRegistry;
+  }
+  roles;
+  defaultPrompts;
+  skillRegistry;
+  modelOverride;
+  roleOverrides = /* @__PURE__ */ new Map();
+  // per-role model CHAIN override (highest priority)
+  effortOverrides = /* @__PURE__ */ new Map();
+  // Models that failed retryably (429/5xx/quota) → skipped in every chain until released. Kept WITH the
+  // reason and the time so a coordinator can report them and later re-probe whether the limit has reset.
+  quarantine = /* @__PURE__ */ new Map();
+  notify;
+  // fallback UI note sink (wired once the controller exists)
+  onQuarantine;
+  /** What each model has actually managed to do in each ROLE — see setFitness. */
+  fitness;
+  // Models that answered in prose instead of calling the submit tool. Not a transport error, so nothing ever
+  // benched them: the chain quietly slid to the fallback on EVERY call, forever, in every role that held them.
+  strikes = /* @__PURE__ */ new Map();
+  rulesProvider;
+  /** Every configured role name — used to validate a role reference produced by a model (memory audiences). */
+  names() {
+    return [.../* @__PURE__ */ new Set([...Object.keys(this.roles), ...Object.keys(this.defaultPrompts)])];
+  }
+  /** Wire the fallback-note sink (called after the controller exists). */
+  setNotify(fn) {
+    this.notify = fn;
+  }
+  /** Wire the durable-rules source (memory). Rules are appended to every role's system prompt (always honored). */
+  setRules(fn) {
+    this.rulesProvider = fn;
+  }
+  /** The rule block to append to a role's prompt — empty when there are no rules. Public so prompt-supplying
+   *  callers (spec-kit phases build their own prompt) can append it too. */
+  ruleSuffix() {
+    const rules = this.rulesProvider?.() ?? [];
+    return rules.length ? `
+
+User rules (ALWAYS honor these):
+${rules.map((r) => `- ${r}`).join("\n")}` : "";
+  }
+  /** Live-swap the model used by every role (session-only; clears on undefined/empty). */
+  setModelOverride(model) {
+    this.modelOverride = model && model.length > 0 ? model : void 0;
+  }
+  /** Live-swap the model CHAIN of ONE role (session-only; wins over the global override). Clears on empty. */
+  setRoleModel(roleName, models) {
+    const chain = (typeof models === "string" ? [models] : models ?? []).filter((m) => m.length > 0);
+    if (chain.length) this.roleOverrides.set(roleName, chain);
+    else this.roleOverrides.delete(roleName);
+  }
+  /**
+   * How hard this role should work, set alongside its chain.
+   *
+   * An override on the live registry rather than a config re-read, for the same reason `setRoleModel` is one:
+   * `/roles adjust` has to take effect in the session that ran it, not only in the next one.
+   *
+   * `undefined` REMOVES it — a role reassigned from a Claude model to one whose effort cannot be set must
+   * stop carrying a level, or the config keeps a number that no longer applies to anything.
+   */
+  setRoleEffort(roleName, effort) {
+    if (effort) this.effortOverrides.set(roleName, effort);
+    else this.effortOverrides.delete(roleName);
+  }
+  /**
+   * Wire the record of what each model has actually managed to do in each role.
+   *
+   * Without it a chain is only a list of names from a catalogue. With it, a model that has twice answered
+   * this role in prose instead of doing its work stops being offered to this role — while staying available
+   * to every other role, where it may be perfectly good.
+   */
+  setFitness(f) {
+    this.fitness = f;
+  }
+  /** Wire the quarantine hook: whatever benches a model, every role still holding it must be re-assigned. */
+  setOnQuarantine(fn) {
+    this.onQuarantine = fn;
+  }
+  /** Mark a model spent — every chain skips it from now on, until it is released. */
+  markExhausted(model, reason = "unavailable", now = Date.now(), until) {
+    if (!model || this.isQuarantined(model)) return;
+    const ends = until ?? (isTransientFailure(reason) ? now + _RoleRegistry.TRANSIENT_BENCH_MS : void 0);
+    this.quarantine.set(model, { at: now, reason, ...ends !== void 0 && { until: ends } });
+    this.onQuarantine?.(model, reason, ends);
+  }
+  /** Every model any role's chain names — the pool this registry can actually reach for. */
+  knownModels() {
+    return [...new Set(Object.values(this.roles).flatMap((r) => r.models ?? []))];
+  }
+  /**
+   * Benches every model of one provider, for a failure that is about the provider itself.
+   *
+   * Returns what it took out, so the caller can say so once instead of six times. Falls back to benching the
+   * single model when the pool names none of that provider — an unknown provider is still a real failure.
+   */
+  markProviderExhausted(provider, model, reason, now = Date.now()) {
+    const want = canonicalSource(provider);
+    const hit = this.knownModels().filter((m) => sourcePrefix(m) === want);
+    const until = quotaResetAt(reason);
+    for (const m of hit) this.markExhausted(m, reason, now, until);
+    if (!hit.length) {
+      this.markExhausted(model, reason, now);
+      return [model];
+    }
+    return hit;
+  }
+  /**
+   * How long a BEHAVIOURAL bench lasts before the model is tried again.
+   *
+   * A model that is out of quota is out until the quota returns, and nothing here can shorten that. A model
+   * that answered in prose is a different case entirely: the transport was fine, and the next prompt may not
+   * be the one it stumbled on. Benching it for the rest of a multi-hour run costs every role that held it —
+   * measured live, one such bench re-assigned SIXTEEN roles away from the best model available.
+   */
+  static STRUCTURAL_BENCH_MS = 10 * 6e4;
+  /**
+   * How long a TRANSPORT bench lasts — the busy server, not the spent subscription.
+   *
+   * The argument above, one door over. A model that answered in prose gets ten minutes because the transport
+   * was fine; a model whose transport said "Overloaded" for one second is the same case in its purest form,
+   * and it was the one getting benched for the whole session.
+   *
+   * Measured live, in the middle of a feature run: `cc/claude-opus-5` served five calls in the preceding two
+   * minutes (23.8s, 2.9s, 3.1s, 25.3s, 38.7s, all ok), then one 529 in 1.7 seconds — and 18 roles were moved
+   * off the best model in the fleet for the rest of the session. A 529 is the textbook transient condition;
+   * the API's own guidance for it is to retry with backoff.
+   *
+   * Two minutes: long enough that a genuinely struggling gateway is not hammered, short enough that a
+   * one-second blip costs a couple of turns rather than an afternoon.
+   */
+  static TRANSIENT_BENCH_MS = 2 * 6e4;
+  /**
+   * How many structured failures a model gets before it is benched. One miss can be a genuinely hard prompt;
+   * a pattern is the model. Low, because every strike costs a full wasted pass in every role that holds it.
+   */
+  static STRUCTURAL_STRIKES = 2;
+  /**
+   * Records that a model finished a turn WITHOUT producing the structured result it was asked for (prose
+   * instead of a tool call). This is not "unavailable" — the transport was fine — so it never reached the
+   * retryable path that benches a model, and the chain slid to the fallback on every single call instead.
+   * Returns the strike count; at the threshold the model is quarantined like any other spent one.
+   */
+  markStructuralFailure(model, reason = "no valid structured result", role) {
+    if (!model) return 0;
+    const key = role ? `${model}::${role}` : model;
+    const n = (this.strikes.get(key) ?? 0) + 1;
+    this.strikes.set(key, n);
+    if (n < _RoleRegistry.STRUCTURAL_STRIKES) return n;
+    if (role) {
+      this.fitness?.record?.(role, model, reason);
+      const rolesFailed = [...this.strikes.entries()].filter(([k, v]) => k.startsWith(`${model}::`) && v >= _RoleRegistry.STRUCTURAL_STRIKES).length;
+      if (rolesFailed >= _RoleRegistry.STRUCTURAL_ROLES_BEFORE_BENCH) {
+        this.markExhausted(
+          model,
+          `${reason} (in ${rolesFailed} roles)`,
+          Date.now(),
+          Date.now() + _RoleRegistry.STRUCTURAL_BENCH_MS
+        );
+      }
+      return n;
+    }
+    this.markExhausted(model, reason, Date.now(), Date.now() + _RoleRegistry.STRUCTURAL_BENCH_MS);
+    return n;
+  }
+  /**
+   * How many DISTINCT roles must reject a model this way before it is benched outright.
+   *
+   * Two, because one role can have a prompt that a good model reads badly — and the fitness record already
+   * takes it out of that role. A second, unrelated role failing the same way is the first evidence that the
+   * model, not the prompt, is the problem.
+   */
+  static STRUCTURAL_ROLES_BEFORE_BENCH = 2;
+  /** Models currently quarantined, with why and when — surfaced to the user and re-probed before an adjust. */
+  quarantined() {
+    return [...this.quarantine].map(([model, q]) => ({ model, ...q }));
+  }
+  isQuarantined(model, now = Date.now()) {
+    const q = this.quarantine.get(model);
+    if (!q) return false;
+    if (q.until !== void 0 && now >= q.until) {
+      this.quarantine.delete(model);
+      this.strikes.clear();
+      return false;
+    }
+    return true;
+  }
+  /** Put a model back in play (its quota reset, or the user forced it). */
+  release(model) {
+    this.strikes.delete(model);
+    return this.quarantine.delete(model);
+  }
+  /**
+   * Roles whose CURRENT chain still contains `model`. When a model is quarantined these are the roles that
+   * would otherwise keep resolving to a dead chain, so they are exactly the ones to re-assign.
+   */
+  rolesUsing(model) {
+    return this.names().filter((r) => this.rawChain(r).includes(model));
+  }
+  /**
+   * The role's chain BEFORE quarantine filtering — what was actually assigned to it.
+   *
+   * The order is the documented one and nothing precedes it: per-role override, then the session model, then
+   * the config. It used to bail on an empty CONFIG chain before either override was consulted, which made a
+   * role the config had never heard of impossible to assign — the one case where assigning is the whole
+   * point. Measured with `tester`, added in a version the user's config predated: `/roles adjust` set the
+   * override, the override was skipped, and the role stayed broken for the rest of the session while the
+   * error message recommended running `/roles adjust`.
+   */
+  rawChain(roleName) {
+    const perRole = this.roleOverrides.get(roleName);
+    if (perRole && perRole.length) return perRole;
+    if (this.modelOverride && roleName !== "refiner") return [this.modelOverride];
+    return this.roles[roleName]?.models ?? [];
+  }
+  /** True when every model assigned to this role is quarantined — the chain has collapsed and needs replacing. */
+  chainCollapsed(roleName) {
+    const raw = this.rawChain(roleName);
+    return raw.length > 0 && raw.every((m) => this.isQuarantined(m));
+  }
+  /** The full model chain for a role by priority: per-role override → global override (non-refiner) → config. */
+  chain(roleName) {
+    const base = this.rawChain(roleName);
+    if (!base.length) return [];
+    const live = base.filter((m) => !this.isQuarantined(m));
+    const usable = live.length ? live : base;
+    const fit = this.fitness ? usable.filter((m) => !this.fitness.unfit(roleName, m)) : usable;
+    return fit.length ? fit : usable;
+  }
+  /**
+   * The role's chain ROTATED by `slot`. Parallel workers share one role — five implementers in a wave are all
+   * `coder` — so every one of them resolved to the same chain head and hammered a single subscription until it
+   * rate-limited. Rotating gives each worker a different lead model while keeping its FULL fallback set, so
+   * spreading the load costs no resilience.
+   */
+  chainFor(roleName, slot = 0) {
+    const c = this.chain(roleName);
+    if (c.length < 2) return c;
+    const order = [];
+    for (const m of c) {
+      const s = sourceOf(m);
+      if (!order.includes(s)) order.push(s);
+    }
+    const cycle = weightedCycle(order, this.sourceWeights?.() ?? {});
+    if (cycle.length) {
+      const want = cycle[(slot % cycle.length + cycle.length) % cycle.length];
+      const i = c.findIndex((m) => sourceOf(m) === want);
+      if (i > 0) return [c[i], ...c.filter((_, j) => j !== i)];
+      if (i === 0) return c;
+    }
+    const k = (slot % c.length + c.length) % c.length;
+    return k === 0 ? c : [...c.slice(k), ...c.slice(0, k)];
+  }
+  /** How many accounts each source has connected — set at the composition root; equal weights without it. */
+  sourceWeights;
+  /** Wire the account weights (called once the pool exists). */
+  setSourceWeights(fn) {
+    this.sourceWeights = fn;
+  }
+  /** The model a role would use next (chain head), for UI display only. */
+  peekModel(roleName) {
+    return this.chain(roleName)[0] ?? "";
+  }
+  /**
+   * The chain (primary + fallbacks) and session-fallback hooks for a role, WITHOUT its system prompt —
+   * for callers that supply their own prompt (e.g. spec-kit phases). resolve() layers the prompt on top.
+   */
+  fallbackOpts(roleName) {
+    const chain = this.chain(roleName);
+    const notify = this.notify;
+    const effort = this.effortOverrides.get(roleName) ?? this.roles[roleName]?.effort;
+    return {
+      // Travels with the chain, not with the prompt: the seven callers that take only the chain are exactly
+      // the ones whose work is heaviest (the tester, the analyst, the spec-kit phases).
+      ...effort ? { effort } : {},
+      /**
+       * The name belongs to the CHAIN, not to the prompt.
+       *
+       * It was put on `resolve()` alone, on the assumption that every caller spreads a resolved role. Seven
+       * do not: they take the chain from here and supply their own prompt (the spec-kit phases, the tester,
+       * the analyst, the question normalizer). Measured on the first run after the change — 19 tool calls,
+       * one of them attributed. Everything the attribution was for happens in those seven.
+       */
+      role: roleName,
+      model: chain[0] ?? "",
+      fallbacks: chain.slice(1),
+      onExhausted: (m, reason) => {
+        const why = reason ?? "unavailable";
+        const source = providerOutage(why) ?? (isSourceCapacity(why) ? sourcePrefix(m) : void 0);
+        if (source) this.markProviderExhausted(source, m, why);
+        else this.markExhausted(m, why);
+      },
+      onStructuralFailure: (m, reason) => this.markStructuralFailure(m, reason, roleName),
+      onFallback: notify ? (from, to, reason) => notify(`\u2935 \`${from}\` \u2192 \`${to}\` \u2014 ${reason}`) : void 0
+    };
+  }
+  /** The skills already attached to a role — what task-level routing must not inline a second time. */
+  skillsFor(roleName) {
+    return this.roles[roleName]?.skills ?? [];
+  }
+  resolve(roleName) {
+    const role = this.roles[roleName];
+    if (!role) throw new Error(`undefined role: ${roleName}`);
+    if (!this.rawChain(roleName).length) {
+      throw new Error(
+        `role '${roleName}' has no model defined \u2014 set one with \`/roles setmodel\`, run \`/roles adjust\`, or choose a session model with \`/model\`.`
+      );
+    }
+    let systemPrompt = role.systemPrompt ?? this.defaultPrompts[roleName];
+    if (systemPrompt === void 0) throw new Error(`role '${roleName}' has no systemPrompt`);
+    if (this.skillRegistry) {
+      try {
+        systemPrompt = applySkills(systemPrompt, role.skills ?? [], this.skillRegistry);
+      } catch (e) {
+        throw new Error(`role '${roleName}' skill error: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    return { ...this.fallbackOpts(roleName), systemPrompt: systemPrompt + this.ruleSuffix() };
+  }
+};
+
+// src/engine/trace-run.ts
+async function traceableFiles(cwd, opts) {
+  const r = await defaultGitRunner(["ls-files", "--cached", "--others", "--exclude-standard"], cwd);
+  return traceable(r.stdout.split("\n").filter(Boolean), opts);
+}
+async function coverageFor(cwd) {
+  return traceCoverage(cwd, await traceableFiles(cwd), await loadTraceIndex(cwd));
+}
+var TRACE_CONCURRENCY = 6;
+var INDEX_CHECKPOINT = 25;
+function describePlan(plan, models) {
+  if (!plan.jobs.length) {
+    return plan.upToDate ? `All ${plan.upToDate} traces are current \u2014 nothing to write, nothing to spend.` : "No files to trace.";
+  }
+  const kIn = Math.round(plan.estimatedInputTokens / 1e3);
+  const kOut = Math.round(plan.estimatedOutputTokens / 1e3);
+  const skipped = plan.skipped.length ? `
+
+${plan.skipped.length} file(s) skipped as too large to trace economically (e.g. ${plan.skipped.slice(0, 3).map((s) => `\`${s.file}\``).join(", ")}${plan.skipped.length > 3 ? ", \u2026" : ""}).` : "";
+  const cached = plan.upToDate ? `
+${plan.upToDate} file(s) already have a current trace and will be left alone.` : "";
+  const [head, ...rest] = models;
+  const chain = `\`${head}\`${rest.length ? `, falling back to ${rest.map((m) => `\`${m}\``).join(" then ")}` : ""}`;
+  return `**Tracing ${plan.jobs.length} file(s)** with ${chain}.
+
+This is the part of understanding your project that costs tokens \u2014 the graph was free, this is not. Each file is read once and described in ~150 words.
+
+Rough cost: **~${kIn}k input + ~${kOut}k output tokens**.${cached}${skipped}`;
+}
+var ChatFailure = class extends Error {
+  constructor(message, retryable) {
+    super(message);
+    this.retryable = retryable;
+  }
+  retryable;
+};
+var BLIND_BENCH_MS = 60 * 60 * 1e3;
+var SpentSources = class {
+  until = /* @__PURE__ */ new Map();
+  /** Files a refusal against its subscription. Returns the source, when the message named one. */
+  record(reason, now = Date.now()) {
+    const source = providerOutage(reason);
+    if (!source) return void 0;
+    this.until.set(source, quotaResetAt(reason) ?? now + BLIND_BENCH_MS);
+    return source;
+  }
+  /** Whether a source is still standing down. A lapsed bench is forgotten as it is read. */
+  spent(source, now = Date.now()) {
+    const t = this.until.get(source);
+    if (t === void 0) return false;
+    if (now >= t) {
+      this.until.delete(source);
+      return false;
+    }
+    return true;
+  }
+  /** The links of a chain still worth trying. A model no CLI serves is nobody's subscription, so it stays. */
+  live(chain, now = Date.now()) {
+    return chain.filter((m) => {
+      const s = cliFor(m);
+      return !s || !this.spent(s, now);
+    });
+  }
+};
+async function traceOne(provider, chain, job, signal, spent, brief) {
+  if (!spent.live(chain).length) {
+    throw new Error(`every subscription in the chain is out of quota (${chain.join(", ")})`);
+  }
+  let last;
+  for (const model of chain) {
+    const source = cliFor(model);
+    if (source && spent.spent(source)) continue;
+    try {
+      return { body: await askOne(provider, model, job, signal, brief), model };
+    } catch (e) {
+      if (!(e instanceof ChatFailure)) throw e;
+      if (!e.retryable) throw e;
+      last = e;
+      spent.record(e.message);
+    }
+  }
+  throw last ?? new Error("no model could write this trace");
+}
+async function askOne(provider, model, job, signal, brief) {
+  const req = {
+    model,
+    messages: [
+      { role: "system", content: "You write terse, factual reference notes about source files. You never speculate." },
+      { role: "user", content: tracePrompt(job, brief) }
+    ],
+    tools: []
+  };
+  let out = "";
+  for await (const ev of provider.chat(req, signal)) {
+    if (ev.type === "text-delta") out += ev.text;
+    else if (ev.type === "error") throw new ChatFailure(ev.message, ev.retryable === true);
+  }
+  const body = out.replace(/<\/?think>/gi, "").trim();
+  if (!body) throw new ChatFailure("empty response", true);
+  return body;
+}
+async function runTraces(opts) {
+  const { cwd, plan } = opts;
+  const signal = opts.signal ?? new AbortController().signal;
+  const index = await loadTraceIndex(cwd);
+  const brief = briefForPrompt(cwd);
+  const failed = [];
+  const spent = new SpentSources();
+  let written = 0;
+  let done = 0;
+  const queue = [...plan.jobs];
+  const worker = async () => {
+    for (; ; ) {
+      const job = queue.shift();
+      if (!job || signal.aborted) return;
+      let wroteTo;
+      let words;
+      let error;
+      try {
+        const { body, model } = await traceOne(opts.provider, opts.models, job, signal, spent, brief);
+        const rec = await saveTrace(cwd, job, body, model);
+        index.traces[job.file] = rec;
+        wroteTo = `${traceRootRel()}/${job.file}.md`;
+        words = body.split(/\s+/).filter(Boolean).length;
+        written++;
+        if (written % INDEX_CHECKPOINT === 0) await saveTraceIndex(cwd, index);
+      } catch (e) {
+        if (signal.aborted) return;
+        error = e instanceof Error ? e.message : String(e);
+        failed.push({ file: job.file, error });
+      }
+      opts.onProgress?.({
+        done: ++done,
+        total: plan.jobs.length,
+        file: job.file,
+        ...wroteTo !== void 0 && { wroteTo },
+        ...words !== void 0 && { words },
+        ...error !== void 0 && { error }
+      });
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(TRACE_CONCURRENCY, queue.length) }, worker));
+  const pruned = opts.liveFiles ? await pruneTraces(cwd, opts.liveFiles, index) : [];
+  await saveTraceIndex(cwd, index);
+  const wroteGitignore = written > 0 && await ensureGitignore(cwd);
+  return { written, failed, pruned, upToDate: plan.upToDate, cancelled: signal.aborted, wroteGitignore };
+}
+async function planFor(cwd, files) {
+  return planTraces(cwd, files, await loadGraph(cwd), await loadTraceIndex(cwd));
+}
+async function buildBrief(opts) {
+  if (!opts.force) {
+    const st = await briefStatus(opts.cwd, opts.files);
+    if (st.built && !st.stale) {
+      return { ok: true, skipped: true, message: `Project brief is current (${st.sources.length} document(s)) \u2014 not rewritten.` };
+    }
+  }
+  const input = await gatherBriefInput(opts.cwd, opts.files);
+  if (!input) {
+    return { ok: false, message: "No documentation found (README, docs/, specs/) \u2014 traces will describe the code without product context." };
+  }
+  const signal = opts.signal ?? new AbortController().signal;
+  const spent = new SpentSources();
+  let body = "";
+  let wroteWith = "";
+  let last = "";
+  for (const model of spent.live(opts.models)) {
+    const req = {
+      model,
+      messages: [
+        { role: "system", content: "You write factual project briefings from documentation. You never invent facts the documents do not state." },
+        { role: "user", content: briefPrompt(input) }
+      ],
+      tools: []
+    };
+    let out = "";
+    try {
+      for await (const ev of opts.provider.chat(req, signal)) {
+        if (ev.type === "text-delta") out += ev.text;
+        else if (ev.type === "error") throw new ChatFailure(ev.message, ev.retryable === true);
+      }
+    } catch (e) {
+      if (e instanceof ChatFailure && !e.retryable) return { ok: false, message: `Project brief failed (${e.message}) \u2014 tracing can still run without it.` };
+      last = e instanceof Error ? e.message : String(e);
+      if (e instanceof ChatFailure) spent.record(e.message);
+      continue;
+    }
+    const text = out.replace(/<\/?think>/gi, "").trim();
+    if (text) {
+      body = text;
+      wroteWith = model;
+      break;
+    }
+    last = "the brief came back empty";
+  }
+  if (!body) return { ok: false, message: `Project brief failed (${last || "no model answered"}) \u2014 tracing can still run without it.` };
+  await saveBrief(opts.cwd, body, { hash: input.hash, sources: input.sources.map((s) => s.file), writtenAt: Date.now(), model: wroteWith });
+  return { ok: true, message: `**Project brief** written from ${input.sources.length} document(s): ${input.sources.slice(0, 6).map((s) => `\`${s.file}\``).join(", ")}` };
+}
+
+export {
+  grokEffort,
+  ZAI_MODELS,
+  modelsFor,
+  cliCatalog,
+  cliFor,
+  cliInvocation,
+  ROLE_PROFILES,
+  filterModelsForRole,
+  effortFor,
+  isKnownModel,
+  capabilityScore,
+  mostCapable,
+  modelBand,
+  DURABLE_ROLES,
+  strongestPrimary,
+  newestPrimary,
+  sourceOf,
+  isPeer,
+  adjustRoleModels,
+  RoleRegistry,
+  traceableFiles,
+  coverageFor,
+  TRACE_CONCURRENCY,
+  describePlan,
+  SpentSources,
+  runTraces,
+  planFor,
+  buildBrief
+};