@hizliemre/horse-code 0.3.0 → 0.3.1

package/dist/chunk-YULQ4URQ.js

@@ -0,0 +1,1220 @@
+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/prompts.ts
+var REQUIRED_ROLES = [
+  "refiner",
+  "coach",
+  "brainstormer",
+  "analyst",
+  "planner",
+  "judge",
+  "project-manager",
+  "team-lead",
+  "router",
+  "coder",
+  "designer",
+  "senior-coder",
+  "senior-designer",
+  "architect",
+  "code-reviewer",
+  "task-auditor",
+  "principal-coder",
+  "operational",
+  "memory-keeper",
+  "tracer",
+  "tester"
+];
+var DEFAULT_ROLE_SKILLS = {
+  brainstormer: ["brainstorming"],
+  // The roles that WRITE code get the test discipline inlined, rather than having the code-tests lens reject
+  // vacuous tests after the fact. Rejecting is more expensive than getting it right the first time.
+  coder: ["test-driven-development"],
+  "senior-coder": ["test-driven-development"],
+  // The task list is where a plan becomes something an implementer can actually execute. spec-kit's template
+  // supplies the SHAPE (phases, story grouping, [P] markers); it says almost nothing about what makes an
+  // individual task executable. That is what this skill adds.
+  "project-manager": ["writing-plans"],
+  // The UI roles get design direction inlined for the same reason the coders get TDD: the code-accessibility
+  // and code-maintainability lenses can reject a templated, default-looking interface, but they cannot teach
+  // one. This skill is self-contained (no sibling reference files), which is what makes it safe to inline.
+  designer: ["frontend-design"],
+  "senior-designer": ["frontend-design"]
+  // NB: systematic-debugging is shipped but attached to NO role — it is only needed when something is stuck,
+  // so it stays in the discoverable listing every role already receives and is fetched with the `skill` tool.
+};
+var DEFAULT_PROMPTS = {
+  tracer: "You write the reference note that every other agent reads before it touches a file it did not write. A wrong note is worse than none: an agent will act on it, so accuracy outranks fluency and admitting you cannot tell outranks a plausible guess. State only what the code and the given relationships show; if the business purpose is not evident from them, describe what the file does technically and say nothing about why. Never speculate about intent, history or requirements.",
+  /**
+   * The role that exercises work already built and writes down what actually happened.
+   *
+   * Every rule below is here because its absence produces the one output worse than no testing at all: a
+   * report that says PASSED about something nobody ran. Such a report is not merely empty — it manufactures
+   * confidence, and the next person spends it.
+   */
+  tester: "You verify software that already exists, by running its scenarios and recording what they actually did. You are not here to build, fix or improve anything: the code under test is finished, and changing it would mean the thing you verified is not the thing that shipped.\n\nEVIDENCE IS THE WHOLE JOB. A scenario's outcome is what you OBSERVED \u2014 a database row, a log line, an HTTP response, a screen the user confirmed. Record the evidence beside every result: the query you ran and what it returned, the log event id and its line, the response body. A result you cannot show is not a result.\n\nIF A STEP WRITES TO THE DATABASE, THE RESPONSE IS NOT THE EVIDENCE. A 201 or a 204 says the request was accepted; it does not say what was stored, and a screen showing the new state does not either \u2014 both can be right while the row is wrong. For every step that creates or changes a record: query the database for that row and put the query AND the rows it returned in the report, and query the logs for the event that step should have emitted and put the query AND the line it returned there too. Absence is evidence as well: when a step must NOT emit an event \u2014 a no-op, a rejected change \u2014 show the query returning nothing. Without both, the scenario is NOT EXECUTED, however convincing the response looked.\n\nNever mark a scenario PASSED that you did not execute and observe. If you could not run it \u2014 the data does not exist, the surface is unreachable, the case is destructive against a live system \u2014 label it NOT EXECUTED and say exactly why. FAILED means you ran it and the behaviour was wrong; say what you expected, what happened, and the evidence for both. Guessing from the source is not executing: where you reasoned from code alone, say so in those words.\n\nWrite each result into the report BEFORE moving on to the next scenario. The report is a living document, not something assembled at the end: a run that stops halfway must leave behind everything it learned up to that point.\n\n\u2026and say each verdict OUT LOUD as you reach it, in one or two sentences: which scenario, what it did, and the single piece of evidence that settled it \u2014 the row, the log line, the status code. The full evidence still goes in the report; this is so the person watching the run knows what you found without opening a file. Say the failures and the NOT EXECUTED ones the same way, and with the same brevity: a result nobody hears is one they have to go looking for.\n\nNever start or stop the development environment \u2014 application hosts, dev servers, containers, databases. Those are the developer's to run. When you need something up, say which command they should run and wait for them to confirm it is ready.\n\nYou do NOT write product code. When you find something wrong that is not the verdict of the scenario you are running \u2014 a missing label, prose rendered as raw markup, a wrong format, or something the developer points out in passing \u2014 call `report_finding`. Another role fixes it and you are told when it is done, so you can re-check what it affected. Do not fix it yourself: changing the product mid-verification means the thing you verified is not the thing that shipped. And do not fail a scenario over it \u2014 a scenario fails when the scenario itself does not pass, not because something else was noticed while running it.\n\nIf the project's own rules (its constitution) say more about how verification is done here, they govern over this description \u2014 read them and follow them.",
+  refiner: "Your #1 rule: `refinedPrompt` MUST ALWAYS be in ENGLISH. If the user wrote in another language (Turkish, German, Spanish, \u2026), TRANSLATE their intent into English \u2014 never echo their language back. This is non-negotiable: a Turkish input like 'bir todo app geli\u015Ftir, \xF6nce backend' MUST come out as English 'Build a todo app; implement the backend first.'\n\nRewrite the user's message down to the raw core intent the AI needs to act on \u2014 clear, direct, and structured. Strip all politeness, emotional, and filler words (please, thanks, kindly, 'could you', 'would you', 'I'd like', etc.) and anything that carries no instruction. Do NOT add words, qualifiers, or scope the user did not state (e.g. do not add 'always'). Keep the user's own perspective and form \u2014 a question stays a question, an instruction stays an instruction; do NOT describe the user in the third person and do NOT answer the request. Example: a polite request like 'would you please answer me in language X?' becomes just 'respond in language X' (drop 'please'; do not add 'always' or any scope the user didn't state). Also classify the intent: 'chat' (conversation/question), 'feature' (new feature/work), 'bugfix' (bug fix), 'govern' (establish or amend the project's OWN standing rules and principles \u2014 writing or revising the constitution, the coding conventions, the project's rules; work whose entire output is a governing document, with no source code changed). Judge by what the request PRODUCES, not by what it mentions: 'write the project constitution from CLAUDE.md' is govern, and so is 'update our commit-message rules'; 'make the code follow the constitution' changes source and is feature. Also 'verify' \u2014 the user wants work that ALREADY EXISTS exercised and its behaviour confirmed with evidence: running a pull request's test scenarios, doing a smoke test of a feature that is already built, producing a test report. Judge by what it PRODUCES: a record of what the software DID is verify; changing what it does is feature or bugfix. 'Run the smoke tests for PR 677 and mark them passed' is verify, and so is 'check that the wizard works end to end'. 'The wizard is broken, fix it' is bugfix. Finally 'undo' \u2014 the user is asking you to REVERSE what the previous turn did, not to do anything new: 'undo that', 'revert your changes', 'go back to the previous version', 'that was wrong, put it back'. Classify by whether the request refers to work already done: undoing is never a rewrite, and asking for a different result ('rewrite it shorter') is not an undo. Also detect the natural language the user wrote in and return its English name as `language` (e.g. 'Turkish', 'English', 'German') \u2014 this is separate from refinedPrompt, which stays English. Also produce `title`: what the work is ABOUT, as a 2-5 word English kebab-case noun phrase suitable for a git branch name \u2014 the SUBJECT, not the action. 'build a luxury todo app' is 'luxury-todo-app'; 'add a login page' is 'login-page'; 'fix the null crash on retry' is 'null-crash-on-retry'. Do not open with a verb (build/add/fix/implement/update): the tool is already doing it, so the verb says nothing and crowds out the words that identify the work. Lowercase, dash-joined, no punctuation. Return the result via submit as {refinedPrompt, intent, language, title}. Remember: refinedPrompt in English, always.",
+  brainstormer: "You run the BRAINSTORM stage: you turn a raw request into a decided design, before anything is specified.\n\nThe `brainstorming` skill above is the authority on HOW to do this \u2014 follow it. What follows is only how it binds to this pipeline, because the skill names conventions from a different habitat:\n\n- OUTPUT: write the design brief to the file named in your message (specs/NNN-slug/brainstorm.md). Ignore the skill's `docs/superpowers/specs/\u2026` path.\n- NEXT STAGE: the SPEC is written from your brief, by another agent, immediately after you. There is no `writing-plans` skill to invoke here \u2014 finishing the brief IS the terminal step.\n- QUESTIONS: ask through the `ask_user` tool. For a choice between approaches use its rich option form ({label, description, preview}) so the trade-offs sit beside the list; lead with your recommendation. The user may attach a note to their answer \u2014 treat it as binding.\n- NOT AVAILABLE: the visual companion (there is no browser) and the per-checklist task list. Skip both.\n\nWrite what was DECIDED, not a transcript: the chosen approach, why it beat the others, the rejected alternatives with their reason, the constraints the spec must honour, and what is out of scope. Keep it short \u2014 it is the brief the spec is written from, not the spec itself, and it carries no implementation detail beyond the architectural choice.\n\nScale to the request: a small, obvious change deserves a paragraph and no questions at all.",
+  coach: "You are horse-code, a terminal-based AI coding agent. Your product identity is always horse-code \u2014 never claim to be Claude Code, Gemini CLI, Antigravity, or any other product, even though the underlying language model powering you may be Claude, Gemini, or another model. Answer the user's technical questions about their repository and code. If needed, inspect the repository with read_file/grep/glob.\n\nWork out loud while you do it. Before a batch of tool calls, say in ONE line what you are looking for and why; when something you read changes your mind, say that too. This is not a summary at the end \u2014 the user is watching an empty screen while you search, and a run that reads thirty files in silence is indistinguishable from one that is stuck, and impossible to redirect before the tokens are spent. Keep each line short: a sentence, not a paragraph.\n\nBe concise, direct, and helpful.",
+  // analyst + planner are spec-kit-driven (their system prompt comes from the fetched spec-kit command
+  // prompts — see src/speckit/phases.ts); they carry no default prompt here, only a model (peekModel).
+  judge: "Synthesize the council evaluations and make a single decision: 'pass' (sufficient), 'revise' (fix it, with reasons), or 'ask-human' (a question to ask the user). Return {decision, feedback, question} via submit.",
+  "project-manager": 'Read the given plan and break it into real, actionable tasks (id, short title, deps). Each task should be a single, clear piece of work. Return {tasks} via submit.\n\nThe `writing-plans` skill above governs WHAT MAKES A TASK EXECUTABLE \u2014 take that from it and nothing else. Two bindings, because the skill describes a different habitat:\n- STRUCTURE comes from the spec-kit tasks template you are given (phases, story grouping, [P] markers), NOT from the skill\'s own document layout. Ignore its `docs/superpowers/plans/\u2026` path, its required-sub-skill header, and its execution-handoff section: this pipeline already owns worktrees, dispatch and review.\n- What you DO take: exact file paths per task, a real test cycle rather than a vague "add tests" step, no placeholders (no TBD/TODO/"similar to task N"), and interfaces named explicitly so a task whose implementer never sees the others still knows the signatures it must produce and consume.\n- SIZING is the third rebinding, and the one that costs most when it is missed. The skill says "bite-sized", "one action, 2-5 minutes", "the smallest unit worth a reviewer\'s gate" \u2014 sound advice where a gate is one reader glancing at a diff. Here a card is not a line in a document: it is its own worktree, its own implementer, a full review TEAM of lenses, a council when they disagree, an acceptance gate and a merge. That overhead is paid per CARD and barely varies with the card\'s size, so splitting work finer does not divide the cost, it multiplies it.\nSize a card to a coherent piece of BEHAVIOUR a reviewer can judge whole, not to a file. An entity, its configuration, its migration and its tests are one card, because nobody can review one without the others and nothing is deliverable until all of them exist. Split only for a reason that survives being said out loud: the parts can be reviewed and merged independently, or they must run in parallel in different worktrees. "They are different files" is not such a reason. Fold setup and scaffolding into the card whose deliverable needs them.',
+  "task-auditor": "You are the last check on a task breakdown before any of it is built. Every hour of implementation after you is spent executing this list, and a bad list does not fail \u2014 the tasks pass their reviews and the wrong work is delivered correctly. Its structure has already been checked mechanically; you are here for the part only a reader can answer: does the breakdown deliver what the plan requires, and would a task's acceptance criteria still hold for an implementation that missed the point? Do not propose better work than the plan asked for \u2014 scope you invent here becomes hours someone spends. Flag any task whose only deliverable is an answer \u2014 verifying, inspecting, confirming \u2014 because an implementer reads the code as part of doing the work, and a task that ends with the repository unchanged has spent a review round on nothing. Flag OVER-SPLITTING for the same reason, and it is the more expensive mistake: every card carries a full review team, a council and an acceptance gate whatever its size, so a breakdown that gives a class and its configuration separate cards pays that overhead twice for work no one can review apart. Say which cards should be one. A clean breakdown is the normal case; say so. Return {missing, weak} via submit.",
+  "team-lead": "You audit a task breakdown before any of it runs. The schedule itself is computed from the declared dependencies and is not yours to write; what nothing has checked is whether those dependencies are RIGHT. You are given the tasks with the files each one writes and what must be true when it is done, plus the groups that would run at the same time in separate worktrees. Find the task that cannot actually start yet because it needs a type, function, table or config key another task in its own group creates \u2014 and say which declared dependencies hold work back for no reason. Both answers are usually empty; say so rather than inventing an edge. Return {missing, spurious} via submit.",
+  router: "Look at the task title and choose the implementer role: 'designer' for UI/UX work, 'coder' for other code work. Return {role} via submit.",
+  coder: "Implement the given task in the worktree. If it is a new task, start from scratch; if it is a returning task, address the reviewer notes. Work with read/write/edit/grep/glob/shell and run the tests.\n\nThe `test-driven-development` skill above is how you write code here: the failing test comes first, and it must fail for the RIGHT reason before you make it pass. A test that asserts nothing is worse than no test \u2014 it reports success forever. Bindings for this pipeline: your worktree is already prepared (do not create one), every file you write is committed as you write it, and there is no separate agent to hand off to \u2014 you take the task to green yourself.",
+  designer: "Implement the UI/UX task in the worktree. Focus on the user interface and experience; work with read/write/edit.\n\nThe `frontend-design` skill above governs the LOOK: aesthetic direction, typography, and choices that do not read as templated defaults. Follow the project's existing visual language where there is one \u2014 a distinctive design that fights the surrounding product is worse than a plain one that fits it.",
+  "senior-coder": "Take over the task the coder got stuck on; implement it with a more careful approach. Take the reviewer notes and previous attempts into account.\n\nYou are here because a previous attempt failed, so start by understanding WHY rather than rewriting: the `systematic-debugging` skill is available (fetch it with the `skill` tool) and is the right tool when a test fails or behaviour is unexplained. The `test-driven-development` skill above still governs how you write the fix \u2014 reproduce the failure in a test first, then make it pass.",
+  "senior-designer": "Take over the UI/UX task the designer got stuck on; implement it more carefully.\n\nA previous attempt already failed, so establish WHY before redesigning \u2014 the `systematic-debugging` skill is available via the `skill` tool when the failure is behavioural rather than visual. The `frontend-design` skill above still governs the look.",
+  architect: "Analyze the root cause of a repeatedly failing task or a merge conflict, and produce a concrete solution plan. Return {rootCause, plan} via submit.\n\nFetch the `systematic-debugging` skill with the `skill` tool and follow it: your job is the ROOT CAUSE, and the failure mode to avoid is proposing a plausible fix for a cause you never established. Say what the evidence is, not what it might be.",
+  "code-reviewer": "Review the worktree changes of the task in REVIEW (correctness, tests, quality). Return {verdict: pass|fail, notes} via submit \u2014 your decision is final.",
+  "principal-coder": "Holistically review all changes in the PR (base worktree). If sufficient, approve; otherwise request-changes with concrete comments. In the final decision round, give accept or ask-human (a question to ask the user).",
+  "memory-keeper": "You are the ONLY writer into this project's long-term memory. Everything else \u2014 every review lens, the council, the judge \u2014 can merely PROPOSE; you decide.\n\nTreat every proposal as an UNVERIFIED CLAIM from a narrow, single-angle agent that saw one slice of one job, not as text to store. Most proposals are wrong in a specific way: they generalize a one-off into a rule, they restate the finding the agent was reviewing, or they record general programming advice any model already knows. Discard all of those. When a claim does survive, REWRITE it in your own words \u2014 never store an agent's sentence verbatim. Merge proposals that say the same thing into one memory.\n\nA memory qualifies ONLY if it is (a) durable \u2014 still true next month, (b) project-specific, and (c) actionable \u2014 it would change what an agent does. Write conventions, constraints, gotchas and root causes. A `lesson` must state what went wrong AND what to do instead. Set `audience` only when the memory is genuinely useful to specific roles and useless to the rest; leave it out otherwise.\n\nNEVER write transient run detail (task ids, attempt counts, what happened today), never restate the request, never duplicate a memory that already exists, and never include credentials, tokens, keys, or anything resembling a secret. Each memory is one self-contained sentence that makes sense with no other context.\n\nReturn at most 5 memories via submit as {memories}. Returning NONE is the most common correct answer \u2014 prefer an empty list over a weak memory, because a bad memory is injected into every future run.",
+  operational: "You handle version control for the project. Given a git diff of work just completed, write a single Conventional Commits message: `type(scope): subject`. Types: feat, fix, docs, refactor, test, chore, style, perf, build, ci. Choose the scope from the touched area (e.g. spec, plan, tasks, or a module name) or omit it. The subject is imperative, lowercase, \u226472 chars, no trailing period. Add a short body only if the change genuinely needs explanation. Commit messages are always in English. Return {message} via submit."
+};
+var SPEC_TEAM = [
+  { name: "spec-completeness", perspective: "coverage of the REQUESTED scope: capabilities the user asked for that are missing, or behavior left unspecified", models: [] },
+  { name: "spec-clarity", perspective: "ambiguity: requirements that can be read two ways, vague wording, unresolved NEEDS CLARIFICATION markers", models: [] },
+  { name: "spec-consistency", perspective: "internal contradictions between requirements, acceptance scenarios, and success criteria", models: [] },
+  { name: "spec-scope", perspective: "scope discipline: requirements the user never asked for, gold-plating, scope creep beyond the request", models: [] },
+  { name: "spec-abstraction-leak", perspective: "implementation detail that has leaked into the spec (languages, frameworks, APIs, storage mechanics, code structure) \u2014 a spec must stay technology-agnostic", models: [] },
+  { name: "spec-verifiability", perspective: "are success criteria measurable and technology-agnostic, and can each acceptance scenario be tested without knowing the implementation", models: [] },
+  { name: "spec-user-value", perspective: "do the user stories deliver the value the user actually asked for, and is the priority ordering sensible", models: [] },
+  { name: "spec-domain-model", perspective: "key entities, their attributes and relationships \u2014 coherent and complete at the domain level, with no implementation detail", models: [] },
+  { name: "spec-privacy", perspective: "requirement-level data handling: what data is stored, who may see it, what must never leak or be retained", models: [] }
+];
+var PLAN_TEAM = [
+  { name: "plan-spec-conformance", perspective: "traceability to the approved spec: every requirement covered by the plan, and nothing planned that the spec never asked for", models: [] },
+  { name: "plan-architecture", perspective: "layering, module boundaries, dependency direction, overall structural coherence", models: [] },
+  { name: "plan-data-model", perspective: "schema and entity design, relationships, migrations, integrity constraints", models: [] },
+  { name: "plan-api-contracts", perspective: "interface and contract design, naming, backward compatibility, ergonomics", models: [] },
+  { name: "plan-security", perspective: "threat model, authentication/authorization design, input validation, secret handling, injection surfaces", models: [] },
+  { name: "plan-concurrency", perspective: "race conditions, atomicity, ordering, multi-writer/multi-tab safety, shared-state design", models: [] },
+  { name: "plan-resilience", perspective: "failure modes, error propagation, recovery, retries, partial-failure behavior", models: [] },
+  { name: "plan-performance", perspective: "algorithmic complexity, hot paths, resource bounds, scalability of the chosen design", models: [] },
+  { name: "plan-test-strategy", perspective: "how the design will be proven: seams, dependency injection, contract/integration test layers, what each test actually establishes", models: [] },
+  { name: "plan-simplicity", perspective: "YAGNI: over-engineering, unnecessary abstraction, complexity the requested scope does not justify", models: [] },
+  { name: "plan-dependencies", perspective: "third-party choices, supply-chain risk, versioning, licensing", models: [] },
+  { name: "plan-observability", perspective: "logging, metrics, tracing, debuggability, actionable failure signals", models: [] },
+  { name: "plan-structure", perspective: "project structure: directory/file layout, build setup, adherence to existing repo conventions", models: [] },
+  { name: "plan-feasibility", perspective: "can this be built and maintained as described, in reasonable increments, with the effort the request warrants", models: [] }
+];
+var CODE_TEAM = [
+  { name: "code-plan-conformance", perspective: "does the code implement what the task required \u2014 nothing missing, and no extra scope beyond the task", models: [] },
+  { name: "code-correctness", perspective: "logical correctness, edge cases, off-by-one and boundary conditions, invariants", models: [] },
+  { name: "code-security", perspective: "injection, secret leakage, missing authorization checks, unsafe APIs, unvalidated input", models: [] },
+  { name: "code-error-handling", perspective: "swallowed errors, propagation, cleanup on failure, partial-failure behavior", models: [] },
+  { name: "code-concurrency", perspective: "race conditions, deadlocks, atomicity, shared mutable state", models: [] },
+  { name: "code-tests", perspective: "is the new behavior covered, and do the tests actually assert something meaningful (no vacuous tests)", models: [] },
+  { name: "code-data-integrity", perspective: "persistence correctness, transactions, validation at boundaries, migration safety", models: [] },
+  { name: "code-performance", perspective: "hot paths, unnecessary allocation/work, N+1 patterns, obvious inefficiency", models: [] },
+  { name: "code-maintainability", perspective: "naming, structure, complexity, readability, future tech-debt", models: [] },
+  { name: "code-simplicity", perspective: "dead code, duplication, unnecessary abstraction, complexity the task does not justify", models: [] },
+  { name: "code-api-surface", perspective: "public interface shape, backward compatibility, accidental API exposure", models: [] },
+  { name: "code-accessibility", perspective: "accessibility of UI code: keyboard operation, ARIA/semantics, contrast, i18n readiness", models: [] },
+  { name: "code-observability", perspective: "logging/metrics where a failure would otherwise be undiagnosable", models: [] },
+  { name: "code-dependencies", perspective: "newly introduced dependencies: justified, correctly versioned, no supply-chain or licensing problem", models: [] },
+  { name: "code-conventions", perspective: "consistency with the surrounding codebase's idioms, patterns, and style", models: [] }
+];
+var DEFAULT_COUNCIL = [
+  { name: "correctness-judge", perspective: "Is the work under review correct, coherent and internally consistent? Weigh the team's correctness/logic/data findings.", models: [] },
+  { name: "risk-judge", perspective: "What is the real blast radius of shipping this as-is? Weigh security, failure modes, concurrency, and data-integrity findings against likelihood and severity.", models: [] },
+  { name: "completeness-judge", perspective: "Is what was asked for fully and unambiguously covered? Weigh the team's completeness, gap, and contract findings.", models: [] },
+  { name: "user-value-judge", perspective: "Does this deliver the user's actual intent well? Weigh usability, accessibility, and whether the scope serves the request without gold-plating.", models: [] },
+  { name: "feasibility-judge", perspective: "Can this be built and maintained as described? Weigh architecture, simplicity, dependencies, and maintainability findings against effort.", models: [] }
+];
+function placedSkills() {
+  return [...new Set(Object.values(DEFAULT_ROLE_SKILLS).flat())];
+}
+
+// src/providers/anthropic.ts
+function isAnthropicModel(model) {
+  return /(^|\/)(claude|fable|mythos)/i.test(model) || /claude/i.test(model);
+}
+
+// src/tui/role-models.ts
+var WEAK_RE = /\b(flash|mini|nano|haiku|lite|small|turbo|fast|\d{1,2}b)\b/i;
+var FLAGSHIP_ROLES = ["judge", "principal-coder"];
+var COUNCIL_ROLES = DEFAULT_COUNCIL.map((c) => c.name);
+var SPEC_LENS_ROLES = SPEC_TEAM.map((c) => c.name);
+var PLAN_LENS_ROLES = PLAN_TEAM.map((c) => c.name);
+var CODE_LENS_ROLES = CODE_TEAM.map((c) => c.name);
+var STRONG_ROLES = [
+  "brainstormer",
+  "analyst",
+  "planner",
+  "architect",
+  "senior-coder",
+  "senior-designer",
+  ...COUNCIL_ROLES,
+  ...PLAN_LENS_ROLES,
+  ...CODE_LENS_ROLES
+];
+var MID_ROLES = ["coach", "coder", "designer", "code-reviewer", "operational", "memory-keeper", "task-auditor", ...SPEC_LENS_ROLES];
+var FAST_ROLES = ["refiner", "router", "project-manager", "team-lead"];
+var CAPABLE_ROLES = /* @__PURE__ */ new Set([...FLAGSHIP_ROLES, ...STRONG_ROLES, ...MID_ROLES]);
+var ROLE_PROFILES = {
+  tracer: "Writes the per-file reference note every other agent reads before changing unfamiliar code \u2014 high volume, but its output is a COMMITTED FILE, not a turn in a conversation: a shallow note is believed by every agent that opens that file, forever, and nothing later corrects it. Give it the MOST capable non-[flagship] model in the catalogue, not merely one that qualifies as [strong]. Volume is not a reason to go cheaper here.",
+  refiner: "Classifies intent and rewrites the prompt every turn \u2014 highest call volume, trivial task \u2192 a fast, cheap model.",
+  router: "Picks coder-vs-designer for a task \u2014 tiny and frequent \u2192 fast, cheap.",
+  "project-manager": "Turns a task list into board items \u2014 light and structured \u2192 fast, cheap.",
+  "task-auditor": "The only check on the task breakdown before hours of implementation are spent executing it \u2014 reads the plan against the task list and finds what was dropped. Low volume, and everything downstream depends on it \u2192 a capable model, never the cheapest.",
+  "team-lead": "Coordinates implementation waves \u2014 light orchestration \u2192 fast, cheap.",
+  coach: "Your main interactive assistant, used constantly all session (highest interaction volume) \u2192 a capable but EFFICIENT model, never the costly flagship.",
+  brainstormer: "Turns a raw request into a decided design before the spec: explores the repo, weighs 2-3 approaches, gets the user to choose. Low volume, sets the direction for everything downstream \u2192 a strong reasoning model.",
+  analyst: "Authors the spec and constitution \u2192 a strong reasoning model (Opus-tier).",
+  planner: "Designs the implementation plan \u2192 a strong reasoning model (Opus-tier).",
+  architect: "Diagnoses stuck tasks and produces recovery plans \u2014 serious design work \u2192 a strong model.",
+  judge: "Critiques specs/plans and makes the final review call \u2014 low volume, high stakes \u2192 the most capable flagship model.",
+  coder: "Writes the bulk of the implementation \u2014 very high work volume \u2192 a good high-throughput coding model (Sonnet-tier), NOT the flagship (wasteful at this volume).",
+  "senior-coder": "Reviews and revises above the coder \u2014 must be MORE capable than the coder (Opus-tier).",
+  "principal-coder": "Final code decision-maker \u2014 low volume, high stakes \u2192 the flagship is appropriate.",
+  designer: "Builds UI \u2014 high volume \u2192 a capable coding/design model, not the flagship.",
+  "senior-designer": "Senior UI reviewer \u2014 more capable than the designer.",
+  "code-reviewer": "Reviews diffs \u2014 moderate volume \u2192 a solid capable model.",
+  "memory-keeper": "Decides what a finished job taught the project and writes it to durable memory \u2014 low volume, but a bad memory poisons every later run \u2192 a capable, efficient model, never the cheapest.",
+  operational: "Handles version control: writes conventional commit messages and (later) drives merges/conflicts \u2014 high volume \u2192 a capable, efficient model."
+};
+for (const [stage, lenses, heft] of [
+  ["spec", SPEC_TEAM, "a capable, efficient model (a spec is a short business-level doc)"],
+  ["plan", PLAN_TEAM, "a strong model (technical design judgment)"],
+  ["code", CODE_TEAM, "a strong model (reads real implementations)"]
+]) {
+  for (const l of lenses) ROLE_PROFILES[l.name] = `${stage.toUpperCase()}-review lens \u2014 ${l.perspective}. Low volume, quality-critical \u2192 ${heft}.`;
+}
+for (const c of DEFAULT_COUNCIL) {
+  ROLE_PROFILES[c.name] = `Review COUNCIL decider \u2014 ${c.perspective} Casts the binding pass/revise vote on contested work \u2192 a strong model.`;
+}
+var ROLE_ADVICE = ROLE_PROFILES;
+function filterModelsForRole(role, all, exclude = []) {
+  const advice = ROLE_ADVICE[role];
+  const 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);
+}
+function pickFallbacks(primary, pool, n) {
+  const chosen = [];
+  const usedModels = /* @__PURE__ */ new Set([baseModel(primary)]);
+  const usedSources = /* @__PURE__ */ new Set([sourceOf(primary)]);
+  const byHeft = pool.map((m, i) => ({ m, i })).sort((a, b) => bandDistance(primary, a.m) - bandDistance(primary, b.m) || a.i - b.i).map((x) => x.m);
+  for (const m of byHeft) {
+    if (chosen.length >= n) break;
+    if (usedModels.has(baseModel(m)) || usedSources.has(sourceOf(m))) continue;
+    chosen.push(m);
+    usedModels.add(baseModel(m));
+    usedSources.add(sourceOf(m));
+  }
+  for (const m of byHeft) {
+    if (chosen.length >= n) break;
+    if (usedModels.has(baseModel(m))) continue;
+    chosen.push(m);
+    usedModels.add(baseModel(m));
+  }
+  return chosen;
+}
+var FALLBACK_COUNT = 2;
+function adjustRoleModels(roles, models, unfit) {
+  if (models.length === 0) return [];
+  const recognised = models.filter(isKnownModel);
+  const pick = recognised.length ? recognised : models;
+  const capable = dedupBest(pick.filter((m) => !WEAK_RE.test(m)));
+  const fast = dedupBest(pick.filter((m) => WEAK_RE.test(m)));
+  const capablePool = capable.length ? capable : fast;
+  const fastPool = fast.length ? fast : capable;
+  const primaryPool = latestFirst(capablePool);
+  const primaryFast = latestFirst(fastPool);
+  const nonFlagship = primaryPool.filter((m) => modelBand(m) !== "flagship");
+  const strongPool = primaryPool.filter((m) => modelBand(m) === "strong");
+  const midPool = primaryPool.filter((m) => modelBand(m) === "mid");
+  const wanted = new Set(roles);
+  const forRole = (role, pool) => {
+    if (!unfit) return pool;
+    const fit = pool.filter((m) => !unfit(role, m));
+    return fit.length ? fit : pool;
+  };
+  const known = /* @__PURE__ */ new Set([...FLAGSHIP_ROLES, ...STRONG_ROLES, ...MID_ROLES, ...FAST_ROLES]);
+  const primary = /* @__PURE__ */ new Map();
+  const flagSrc = primaryPool;
+  FLAGSHIP_ROLES.filter((r) => wanted.has(r)).forEach((r, i) => {
+    const src = forRole(r, flagSrc);
+    primary.set(r, src[i % src.length]);
+  });
+  const strongSrc = interleaveBySource(strongPool.length ? strongPool : nonFlagship.length ? nonFlagship : primaryPool);
+  STRONG_ROLES.filter((r) => wanted.has(r)).concat(roles.filter((r) => !known.has(r))).forEach((r, i) => {
+    const src = forRole(r, strongSrc);
+    primary.set(r, src[i % src.length]);
+  });
+  const midSrc = interleaveBySource(midPool.length ? midPool : nonFlagship.length ? nonFlagship : primaryPool);
+  MID_ROLES.filter((r) => wanted.has(r)).forEach((r, i) => {
+    const src = forRole(r, midSrc);
+    primary.set(r, src[i % src.length]);
+  });
+  FAST_ROLES.filter((r) => wanted.has(r)).forEach((r, i) => {
+    const src = forRole(r, primaryFast);
+    primary.set(r, src[i % src.length]);
+  });
+  return roles.map((role) => {
+    const head = primary.get(role) ?? primaryPool[0];
+    const capForFb = MID_ROLES.includes(role) ? capablePool.filter((m) => modelBand(m) !== "flagship") : capablePool;
+    const pool = FAST_ROLES.includes(role) ? [...fastPool, ...capForFb] : [...capForFb, ...fastPool];
+    return { role, models: newestPrimary([head, ...pickFallbacks(head, forRole(role, pool), FALLBACK_COUNT)], models) };
+  });
+}
+
+// src/skills/apply.ts
+import { readFile } from "fs/promises";
+import { readdirSync } from "fs";
+import { resolve, sep } from "path";
+import { z } from "zod";
+function applySkills(basePrompt, mandatory, registry) {
+  const parts = [basePrompt];
+  if (mandatory.length) {
+    const sections = mandatory.map((name) => {
+      const skill = registry.get(name);
+      if (!skill) throw new Error(`applySkills: undefined skill: ${name}`);
+      const where = skill.dir ? `
+_Skill base directory: ${skill.dir}_
+` : "";
+      return `## ${skill.name}${where}
+${skill.content}`;
+    });
+    parts.push(`# Mandatory Skills
+${sections.join("\n\n")}`);
+  }
+  const mandatorySet = new Set(mandatory);
+  const available = registry.list().filter((s) => !mandatorySet.has(s.name));
+  if (available.length) {
+    const lines = available.map((s) => `- ${s.name}: ${s.description}`);
+    parts.push(`# Discoverable Skills (call the skill tool to fetch its content)
+${lines.join("\n")}`);
+  }
+  return parts.join("\n\n");
+}
+var skillParams = z.object({
+  name: z.string().describe("The skill's name, exactly as it is listed."),
+  /**
+   * A supporting document inside the skill's own directory, e.g. "reference/critique.md".
+   *
+   * Described, because an undescribed optional string gets filled in. Measured: four consecutive calls sent
+   * `file: ""` and every one of them failed — the skill was there, its content was one branch away, and an
+   * empty string took the other branch.
+   */
+  file: z.string().optional().describe('Optional. A supporting document inside the skill, e.g. "reference/critique.md". Omit it to read the skill itself \u2014 do not pass an empty string.')
+});
+var DOCS_SHOWN = 12;
+function docsIn(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.name !== "SKILL.md" && !e.name.startsWith(".")).map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort().slice(0, DOCS_SHOWN);
+  } catch {
+    return [];
+  }
+}
+var MAX_SKILL_DOC_CHARS = 3e4;
+var MAX_SKILLS_LISTED = 12;
+function noSuchSkill(name, available) {
+  const shape = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const same = available.filter((s) => shape(s) === shape(name));
+  if (same.length === 1) {
+    return `skill not found: ${name} \u2014 did you mean \`${same[0]}\`? Call it with that exact name.`;
+  }
+  if (!available.length) return `skill not found: ${name}. This project has no skills installed, so carry on without one.`;
+  const near = available.filter((s) => shape(s).includes(shape(name)) || shape(name).includes(shape(s)));
+  if (near.length && near.length <= MAX_SKILLS_LISTED) {
+    return `skill not found: ${name}. Closest by name: ${near.map((s) => `\`${s}\``).join(", ")}. Call one of those exactly if it is what you meant, or carry on without a skill.`;
+  }
+  const shown = available.slice(0, MAX_SKILLS_LISTED);
+  const rest = available.length - shown.length;
+  return `skill not found: ${name}. Available: ${shown.join(", ")}${rest > 0 ? `, and ${rest} more \u2014 the full list is in your system prompt` : ""}. Use one of these exactly, or carry on without a skill \u2014 do not guess another name.`;
+}
+function buildSkillTool(registry) {
+  return {
+    name: "skill",
+    description: 'Fetch a skill\'s content by name. Some skills are dispatchers whose SKILL.md points at supporting documents (e.g. "see reference/critique.md"); pass `file` with that relative path to read one. Fetch a document only when the skill actually sends you to it.',
+    permissionLevel: "safe",
+    parameters: skillParams,
+    run: async (rawArgs) => {
+      const parsed = skillParams.safeParse(rawArgs);
+      if (!parsed.success) {
+        return { content: `skill: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
+      }
+      const { name, file } = parsed.data;
+      const skill = registry.get(name);
+      if (!skill) return { content: noSuchSkill(name, registry.list().map((s) => s.name)), isError: true };
+      if (file === void 0 || !file.trim()) {
+        const where = skill.dir ? `_Skill base directory: ${skill.dir}_
+
+` : "";
+        return { content: `${where}${skill.content}`, isError: false };
+      }
+      if (!skill.dir) return { content: `skill ${name}: has no supporting documents`, isError: true };
+      const target = resolve(skill.dir, file);
+      const root = resolve(skill.dir);
+      if (target !== root && !target.startsWith(root + sep)) {
+        return { content: `skill ${name}: ${file} is outside the skill directory`, isError: true };
+      }
+      let raw;
+      try {
+        raw = await readFile(target, "utf8");
+      } catch {
+        const has = docsIn(skill.dir);
+        return {
+          content: `skill ${name}: no such document: ${file}` + (has.length ? `. It has: ${has.join(", ")}` : `. It has no supporting documents.`),
+          isError: true
+        };
+      }
+      if (raw.length <= MAX_SKILL_DOC_CHARS) return { content: raw, isError: false };
+      return {
+        content: `${raw.slice(0, MAX_SKILL_DOC_CHARS)}
+
+[skill ${name}/${file}: truncated at ${MAX_SKILL_DOC_CHARS} of ${raw.length} chars]`,
+        isError: false
+      };
+    }
+  };
+}
+
+// src/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,
+  REQUIRED_ROLES,
+  DEFAULT_ROLE_SKILLS,
+  DEFAULT_PROMPTS,
+  SPEC_TEAM,
+  PLAN_TEAM,
+  CODE_TEAM,
+  DEFAULT_COUNCIL,
+  placedSkills,
+  ROLE_PROFILES,
+  filterModelsForRole,
+  effortFor,
+  isKnownModel,
+  capabilityScore,
+  mostCapable,
+  modelBand,
+  DURABLE_ROLES,
+  strongestPrimary,
+  newestPrimary,
+  sourceOf,
+  adjustRoleModels,
+  applySkills,
+  buildSkillTool,
+  RoleRegistry,
+  traceableFiles,
+  coverageFor,
+  TRACE_CONCURRENCY,
+  describePlan,
+  SpentSources,
+  runTraces,
+  planFor,
+  buildBrief
+};