@hizliemre/horse-code 0.1.0

package/dist/chunk-3XVZXTB6.js

@@ -0,0 +1,4469 @@
+import {
+  checkpointKey,
+  checkpointMtime,
+  isContinuePrompt,
+  readCheckpoint
+} from "./chunk-FGVJFMK5.js";
+import {
+  planFor,
+  runTraces
+} from "./chunk-NNTIACT4.js";
+import {
+  defaultGitRunner
+} from "./chunk-IW2KBAVZ.js";
+import {
+  BATCH_TOOLS_NOTE,
+  contextTools,
+  emitBatchInjection,
+  globTool,
+  grepTool,
+  memoryHints,
+  projectToolsNote,
+  readFileTool,
+  reinforceTouched,
+  reinforceUsed
+} from "./chunk-TOPZL5SU.js";
+import {
+  ToolRegistry,
+  handedOver,
+  runStructuredRole,
+  runToCompletion,
+  telemetry,
+  truncateSafe
+} from "./chunk-YILDXPSI.js";
+import {
+  loadTraceIndex,
+  pruneTraces,
+  saveTraceIndex,
+  sharedDerived,
+  traceRootRel,
+  traceable
+} from "./chunk-FFYBY2NA.js";
+import {
+  buildProjectGraph,
+  loadGraphSync,
+  pruneAreaNames
+} from "./chunk-PGOYDOI4.js";
+import {
+  writableStateRoot
+} from "./chunk-SSDLHWSF.js";
+
+// src/worktree/slug.ts
+var MAX_SLUG = 60;
+var MAX_WORDS = 5;
+var LEADING_VERBS = /* @__PURE__ */ new Set([
+  "add",
+  "build",
+  "create",
+  "implement",
+  "make",
+  "write",
+  "develop",
+  "design",
+  "generate",
+  "introduce",
+  "fix",
+  "update",
+  "change",
+  "modify",
+  "refactor",
+  "rewrite",
+  "improve",
+  "enhance",
+  "optimize",
+  "clean",
+  "setup",
+  "configure",
+  "install",
+  "remove",
+  "delete",
+  "drop",
+  "rename",
+  "migrate",
+  "move",
+  "port",
+  "support",
+  "enable",
+  "disable",
+  "finalize",
+  "complete",
+  "finish",
+  "expand",
+  "extend",
+  "set",
+  "apply"
+]);
+var FILLERS = /* @__PURE__ */ new Set(["a", "an", "the"]);
+function dropLeadingAction(words3) {
+  let i = 0;
+  if (words3.length && LEADING_VERBS.has(words3[0])) {
+    i = 1;
+    while (i < words3.length && FILLERS.has(words3[i])) i++;
+  } else {
+    while (i < words3.length && FILLERS.has(words3[i])) i++;
+  }
+  return i < words3.length ? words3.slice(i) : words3;
+}
+function toSlug(name) {
+  const words3 = name.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  const named = dropLeadingAction(words3).slice(0, MAX_WORDS);
+  const s = named.join("-").slice(0, MAX_SLUG).replace(/-+$/g, "");
+  return s || "job";
+}
+function uniqueSlug(base, taken) {
+  if (!taken(base)) return base;
+  let n = 2;
+  while (taken(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+
+// src/worktree/manager.ts
+import { mkdir as mkdir2, writeFile, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync2, readdirSync, realpathSync } from "fs";
+import { join as join2, resolve, dirname as dirname2, basename } from "path";
+
+// src/worktree/inherit.ts
+import { cp, mkdir, rm, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, join, sep } from "path";
+var INHERITED_ASSETS = [
+  join("graphify-out", "graph.json"),
+  // The community names beside it: without them a session's graph tools fall back to numbers, which is the
+  // difference between "this touches Wallet Member & Balance" and "this touches community 47".
+  join("graphify-out", ".graphify_labels.json"),
+  join(".horsecode", "memory.jsonl"),
+  join(".horsecode", "skills"),
+  join(".specify", "memory", "constitution.md"),
+  join(".horsecode", "migrated.json")
+];
+var NEVER = [join(".horsecode", "worktrees")];
+var excluded = (rel) => NEVER.some((n) => rel === n || rel.startsWith(n + sep) || rel.startsWith(n + "/"));
+function nestedCheckout(repoRoot, rel, cache) {
+  const parts = rel.split(/[\\/]/).slice(0, -1);
+  let acc = "";
+  for (const part of parts) {
+    acc = acc ? `${acc}/${part}` : part;
+    let hit = cache.get(acc);
+    if (hit === void 0) {
+      hit = existsSync(join(repoRoot, acc, ".git"));
+      cache.set(acc, hit);
+    }
+    if (hit) return true;
+  }
+  return false;
+}
+var MAX_UNTRACKED = 5e3;
+async function copyPath(from, to) {
+  await mkdir(dirname(to), { recursive: true });
+  await cp(from, to, { recursive: true, dereference: true, force: true });
+}
+async function inheritFromRoot(git, repoRoot, baseWorktree) {
+  const out = { modified: [], untracked: [], assets: [], deleted: [], skipped: 0 };
+  if (repoRoot === baseWorktree) return out;
+  const changed = await git(["diff", "--name-status", "HEAD"], repoRoot);
+  if (changed.code === 0) {
+    for (const line of changed.stdout.split("\n")) {
+      const [status, ...rest] = line.trim().split(/\t/);
+      const rel = rest.join("	");
+      if (!status || !rel || excluded(rel)) continue;
+      try {
+        if (status.startsWith("D")) {
+          await rm(join(baseWorktree, rel), { force: true });
+          out.deleted.push(rel);
+        } else {
+          await copyPath(join(repoRoot, rel), join(baseWorktree, rel));
+          out.modified.push(rel);
+        }
+      } catch {
+      }
+    }
+  }
+  const others = await git(["ls-files", "--others", "--exclude-standard"], repoRoot);
+  if (others.code === 0) {
+    const nested = /* @__PURE__ */ new Map();
+    for (const rel of others.stdout.split("\n").map((l) => l.trim()).filter(Boolean)) {
+      if (excluded(rel) || nestedCheckout(repoRoot, rel, nested)) {
+        out.skipped++;
+        continue;
+      }
+      if (out.untracked.length >= MAX_UNTRACKED) {
+        out.skipped++;
+        continue;
+      }
+      try {
+        await copyPath(join(repoRoot, rel), join(baseWorktree, rel));
+        out.untracked.push(rel);
+      } catch {
+      }
+    }
+  }
+  for (const rel of INHERITED_ASSETS) {
+    const from = join(repoRoot, rel);
+    if (!existsSync(from)) continue;
+    try {
+      await stat(from);
+      await copyPath(from, join(baseWorktree, rel));
+      out.assets.push(rel);
+    } catch {
+    }
+  }
+  return out;
+}
+function describeInherited(i) {
+  const parts = [];
+  const n = i.modified.length + i.deleted.length;
+  if (n) parts.push(`${n} uncommitted change(s)`);
+  if (i.untracked.length) parts.push(`${i.untracked.length} untracked file(s)`);
+  if (i.skipped) parts.push(`${i.skipped} left behind (another checkout, or past the ${MAX_UNTRACKED} bound)`);
+  if (i.assets.length) parts.push(i.assets.map((a) => `\`${a}\``).join(", "));
+  return parts.length ? `\u{1F4E5} Carried into this session: ${parts.join(" \xB7 ")}.` : void 0;
+}
+async function topUpInherited(repoRoot, baseWorktree) {
+  const added = [];
+  if (repoRoot === baseWorktree) return added;
+  for (const rel of INHERITED_ASSETS) {
+    const from = join(repoRoot, rel);
+    const to = join(baseWorktree, rel);
+    if (!existsSync(from) || existsSync(to)) continue;
+    try {
+      await copyPath(from, to);
+      added.push(rel);
+    } catch {
+    }
+  }
+  return added;
+}
+function describeTopUp(added) {
+  if (!added.length) return void 0;
+  return `\u{1F4E5} This session was opened before ${added.map((a) => `\`${a}\``).join(", ")} existed \u2014 carried in now.`;
+}
+
+// src/worktree/manager.ts
+var MAX_DIFF_CHARS = 12e4;
+var DOC_SPECS = ["*.md", "*.txt"];
+function excludeOwnState() {
+  const roots = [".horsecode", "graphify-out", traceRootRel()].filter(Boolean);
+  return [...new Set(roots)].map((r) => `:(exclude)${r}/**`);
+}
+async function mainWorktreeRoot(git, cwd) {
+  const abs = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd);
+  const r = abs.code === 0 ? abs : await git(["rev-parse", "--git-common-dir"], cwd);
+  if (r.code !== 0 || !r.stdout.trim()) return cwd;
+  const common = resolve(cwd, r.stdout.trim());
+  return basename(common) === ".git" ? dirname2(common) : cwd;
+}
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var DAYS = ["SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY"];
+function sessionName(now, taken) {
+  const day = `${String(now.getDate()).padStart(2, "0")}-${MONTHS[now.getMonth()]}-${now.getFullYear()}-${DAYS[now.getDay()]}`;
+  for (let n = 1; n < 1e3; n++) {
+    const name = `${day}_${String(n).padStart(2, "0")}`;
+    if (!taken(name)) return name;
+  }
+  return `${day}_${Date.now()}`;
+}
+var WorktreeManager = class {
+  repoRoot;
+  /** The project checkout this manager was built for — where per-project settings and the remote live. */
+  get projectRoot() {
+    return this.repoRoot;
+  }
+  /**
+   * Where sessions are kept, which is the REPOSITORY's business and not the caller's checkout.
+   *
+   * Measured from a live run: started inside another tool's worktree, horse-code opened its session at
+   * `…/.claude/worktrees/product-create-wizard/.horsecode/worktrees/…/base` — its own worktree nested inside
+   * someone else's, inside the repository. That works and is a place nobody will look: `/clean-worktrees` at
+   * the repository root cannot see it, and removing the outer checkout takes it with it.
+   *
+   * Distinct from `repoRoot` on purpose. What a session INHERITS — the code graph, the memory, the project
+   * config — is whatever the user is standing in, and that is frequently not the main checkout.
+   */
+  worktreeHome;
+  git;
+  /** Injectable clock: a session's NAME is the day it opened, so a test has to be able to say which day. */
+  now;
+  constructor(deps) {
+    this.repoRoot = deps.repoRoot;
+    this.worktreeHome = deps.worktreeHome ?? deps.repoRoot;
+    this.git = deps.runGit ?? defaultGitRunner;
+    this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  /** Runs git; nonzero exit → throws a clear error. Returns output (stdout). */
+  async run(args, cwd) {
+    const r = await this.git(args, cwd);
+    if (r.code !== 0) {
+      throw new Error(`git ${args.join(" ")} failed (${r.code}): ${(r.stderr || r.stdout).trim()}`);
+    }
+    return r.stdout;
+  }
+  /** `git init` the repo if the directory isn't one yet (the user may not have run git init) + ensure an
+   *  identity so the first commit doesn't fail on a machine with no global git config. */
+  async ensureRepo() {
+    const inside = await this.git(["rev-parse", "--is-inside-work-tree"], this.repoRoot);
+    if (inside.code === 0 && inside.stdout.trim() === "true") return;
+    await this.run(["init", "-b", "main"], this.repoRoot);
+    const email = await this.git(["config", "user.email"], this.repoRoot);
+    if (email.code !== 0 || !email.stdout.trim()) {
+      await this.git(["config", "user.email", "horse-code@local"], this.repoRoot);
+      await this.git(["config", "user.name", "horse-code"], this.repoRoot);
+    }
+  }
+  /**
+   * A worktree must branch off a commit. First ensure the directory IS a git repo (auto `git init` if not).
+   * A freshly `git init`-ed repo has an unborn HEAD (no commits), so `git worktree add … <branch>` fails with
+   * "invalid reference". Bootstrap one empty commit so horse-code works in a brand-new / non-git directory.
+   */
+  async ensureBaseCommit() {
+    await this.ensureRepo();
+    const head = await this.git(["rev-parse", "--verify", "--quiet", "HEAD"], this.repoRoot);
+    if (head.code === 0) return;
+    await this.run(["commit", "--allow-empty", "-m", "hc: initial commit"], this.repoRoot);
+  }
+  /**
+   * The ref to base the session's worktree on. Uses `fromBranch` when it resolves; otherwise falls back to
+   * HEAD. This covers the common fresh-repo mismatch: horse-code guesses "main" but the repo's actual
+   * (default/unborn) branch is "master", so "main" never resolves even after the bootstrap commit.
+   */
+  async resolveBase(fromBranch) {
+    const ok = await this.git(["rev-parse", "--verify", "--quiet", fromBranch], this.repoRoot);
+    return ok.code === 0 ? fromBranch : "HEAD";
+  }
+  async openSession(fromBranch, jobName) {
+    await this.ensureBaseCommit();
+    const base = await this.resolveBase(fromBranch);
+    const worktreesDir = join2(this.worktreeHome, ".horsecode", "worktrees");
+    await mkdir2(worktreesDir, { recursive: true });
+    await writeFile(join2(worktreesDir, ".gitignore"), "*\n", "utf8");
+    const listed = await this.git(["for-each-ref", "--format=%(refname:short)", "refs/heads/hc/"], this.repoRoot);
+    const branches = new Set(listed.stdout.split("\n").map((s) => s.trim()).filter(Boolean));
+    const jobSlug = sessionName(this.now(), (s) => existsSync2(join2(worktreesDir, s)) || branches.has(`hc/${s}/base`));
+    const root = join2(worktreesDir, jobSlug);
+    const baseWorktree = join2(root, "base");
+    const baseBranch = `hc/${jobSlug}/base`;
+    await mkdir2(join2(root, "tasks"), { recursive: true });
+    await this.run(["worktree", "add", "-b", baseBranch, baseWorktree, base], this.repoRoot);
+    const inherited = await inheritFromRoot((args, cwd) => this.git(args, cwd), this.repoRoot, baseWorktree);
+    return { jobSlug, root, baseWorktree, baseBranch, inherited };
+  }
+  /** Absolute paths of the worktrees git currently tracks (from `git worktree list --porcelain`). */
+  async registeredWorktrees() {
+    const r = await this.git(["worktree", "list", "--porcelain"], this.repoRoot);
+    const paths = /* @__PURE__ */ new Set();
+    for (const line of r.stdout.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        const p = line.slice("worktree ".length).trim();
+        try {
+          paths.add(realpathSync(p));
+        } catch {
+          paths.add(p);
+        }
+      }
+    }
+    return paths;
+  }
+  /**
+   * Resume support: find a preserved worktree from an earlier interrupted run. Scans every
+   * `.horsecode/worktrees/<slug>/checkpoint.json` and only considers a session whose `base` worktree is still
+   * live in git (a pruned/stale dir can't be safely reused). A bare "continue" request (`isContinuePrompt`)
+   * matches any preserved work — the user needn't retype the original request — and among those, the one with
+   * ACTUAL PROGRESS wins over the merely most recent. Otherwise the prompt must match a checkpoint's stored
+   * `rawPrompt` (case/space-tolerant). Returns null when there is nothing to resume.
+   */
+  async findResumable(rawPrompt) {
+    const worktreesDir = join2(this.worktreeHome, ".horsecode", "worktrees");
+    if (!existsSync2(worktreesDir)) return null;
+    const inside = await this.git(["rev-parse", "--is-inside-work-tree"], this.repoRoot);
+    if (inside.code !== 0) return null;
+    const anyContinue = isContinuePrompt(rawPrompt);
+    const key2 = checkpointKey(rawPrompt);
+    const registered = await this.registeredWorktrees();
+    const candidates = [];
+    for (const slug of readdirSync(worktreesDir)) {
+      const root = join2(worktreesDir, slug);
+      const cp2 = readCheckpoint(root);
+      if (!cp2) continue;
+      if (!anyContinue && checkpointKey(cp2.rawPrompt) !== key2) continue;
+      const baseWorktree = join2(root, "base");
+      let real;
+      try {
+        real = realpathSync(baseWorktree);
+      } catch {
+        continue;
+      }
+      if (!registered.has(real)) continue;
+      candidates.push({
+        session: { jobSlug: slug, root, baseWorktree, baseBranch: `hc/${slug}/base`, resumed: true },
+        mtime: checkpointMtime(root),
+        progress: cp2.done.length
+      });
+    }
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => (b.progress > 0 ? 1 : 0) - (a.progress > 0 ? 1 : 0) || b.mtime - a.mtime);
+    const picked = candidates[0].session;
+    const added = await topUpInherited(this.repoRoot, picked.baseWorktree);
+    return added.length ? { ...picked, toppedUp: added } : picked;
+  }
+  /**
+   * The worktree for a task — REUSED when the task already has one.
+   *
+   * It used to mint a fresh slug every time, so a task got `…-1`, `…-2`, `…-9` and each run began from base
+   * with the previous run's work stranded in a directory nobody would open again. Measured live: 321
+   * worktrees on disk, TEN of them for one task, and the newest empty while `…-9` held 8 commits and 7.6 KB
+   * of finished work.
+   *
+   * It also made the pipeline lie. The deadline warning tells the implementer "whatever it wrote is committed
+   * and kept — continue from there rather than starting over", and across runs that was simply false: a task
+   * needing more than one run's worth of work could never accumulate any.
+   *
+   * A fresh slug is still minted when the existing directory is not a usable worktree for this task's branch,
+   * because a broken one must not stop the task.
+   */
+  async deriveTask(session, taskName) {
+    const tasksDir = join2(session.root, "tasks");
+    const slug = toSlug(taskName);
+    const branch = `hc/${session.jobSlug}/t/${slug}`;
+    const existing = join2(tasksDir, slug);
+    if (existsSync2(existing)) {
+      const ok = await this.git(["rev-parse", "--abbrev-ref", "HEAD"], existing);
+      if (ok.code === 0 && ok.stdout.trim() === branch) return { taskSlug: slug, worktree: existing, branch };
+    }
+    const taskSlug = uniqueSlug(slug, (s) => existsSync2(join2(tasksDir, s)));
+    const wt = join2(tasksDir, taskSlug);
+    const br = `hc/${session.jobSlug}/t/${taskSlug}`;
+    await this.run(["worktree", "add", "-b", br, wt, session.baseBranch], this.repoRoot);
+    return { taskSlug, worktree: wt, branch: br };
+  }
+  /**
+   * Retires a task's worktree and branch so the next derive starts from the CURRENT base.
+   *
+   * Reusing a task's worktree between attempts stopped the "start from scratch every run" waste, but it also
+   * FROZE the branch's root. Measured on a real board: the export/import task's branch was rooted two and a
+   * half days back and the base had moved 68 commits past it, while the throwaway worktrees it replaced had
+   * been rooted 29-30 commits back. Its merge then had to reconcile a drift that wide across seven files, and
+   * the resolver ran out of turns every time — twice on a review that had already PASSED.
+   *
+   * Past a few of those, re-implementing on today's base is cheaper than reconciling the drift, and it is the
+   * only move that actually removes the cause.
+   *
+   * The old branch is RENAMED, not deleted. It holds work that passed review; throwing it away to save a
+   * branch name would destroy the only copy of it.
+   */
+  async restartTask(session, task) {
+    let retired = `${task.branch}-stale`;
+    for (let n = 2; (await this.git(["rev-parse", "--verify", "--quiet", retired], this.repoRoot)).code === 0; n++) {
+      retired = `${task.branch}-stale-${n}`;
+    }
+    await this.run(["worktree", "remove", "--force", task.worktree], this.repoRoot);
+    await this.run(["branch", "-m", task.branch, retired], this.repoRoot);
+    return retired;
+  }
+  async mergeTask(session, task) {
+    return this.mergeRef(session, task.branch);
+  }
+  /**
+   * Merges any ref into the session base — a task branch coming home, or the project's main branch coming in.
+   *
+   * A resumed session picks up a branch that was cut days ago, and everything the team merged in the meantime
+   * is missing from it: it continues against code that no longer exists. Bringing main IN is the same
+   * operation as bringing a task in, which is why it is the same method and the same conflict path.
+   */
+  async mergeRef(session, ref) {
+    const r = await this.git(["merge", ref], session.baseWorktree);
+    if (r.code === 0) return { status: "merged" };
+    const diff = await this.git(
+      ["diff", "--name-only", "--diff-filter=U"],
+      session.baseWorktree
+    );
+    const files = diff.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+    if (files.length > 0) return { status: "conflict", files };
+    throw new Error(`git merge ${ref} failed (${r.code}): ${(r.stderr || r.stdout).trim()}`);
+  }
+  /**
+   * Brings one branch up to date from the remote. Best-effort: no remote, no network, no such branch — the
+   * merge then runs against the local copy, which is still better than not syncing at all.
+   *
+   * Returns the ref to merge: `origin/<branch>` when the fetch landed, the plain branch name otherwise.
+   */
+  async fetchBranch(branch) {
+    const r = await this.git(["fetch", "origin", branch], this.repoRoot);
+    if (r.code !== 0) return branch;
+    const remote = await this.git(["rev-parse", "--verify", `origin/${branch}`], this.repoRoot);
+    return remote.code === 0 ? `origin/${branch}` : branch;
+  }
+  /** Whether the session base already contains `ref` — nothing to merge, and nothing to say about it. */
+  async containsRef(session, ref) {
+    const r = await this.git(["merge-base", "--is-ancestor", ref, "HEAD"], session.baseWorktree);
+    return r.code === 0;
+  }
+  /** How many commits `ref` has that the session base does not — what a sync is about to bring in. */
+  async commitsBehind(session, ref) {
+    const r = await this.git(["rev-list", "--count", `HEAD..${ref}`], session.baseWorktree);
+    return r.code === 0 ? Number(r.stdout.trim()) || 0 : 0;
+  }
+  /** Files git marks as unmerged (conflicted) in the base worktree. */
+  async unmergedFiles(session) {
+    const r = await this.git(["diff", "--name-only", "--diff-filter=U"], session.baseWorktree);
+    return r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  /**
+   * Resolves one conflicted path by taking the BASE's copy, for files that are regenerated rather than merged.
+   *
+   * `--ours` during a merge means the branch being merged INTO — the session base, where the other tasks'
+   * work has already landed. For a lockfile that is the right side: it already carries every dependency the
+   * merged tasks installed, and the incoming branch's own addition is re-derived by running the package
+   * manager, not by choosing lines from a machine-written file.
+   */
+  async resolveWithBase(session, file) {
+    await this.git(["checkout", "--ours", "--", file], session.baseWorktree);
+    await this.git(["add", "--", file], session.baseWorktree);
+  }
+  /**
+   * One side of a conflicted file, as git holds it: stage 2 is the base's, stage 3 is the incoming branch's.
+   *
+   * Needed by the resolutions that COMBINE the two sides rather than choosing one — reading the working-tree
+   * copy would only give the version with the markers in it.
+   */
+  async conflictSide(session, file, side) {
+    const r = await this.git(["show", `:${side === "ours" ? 2 : 3}:${file}`], session.baseWorktree);
+    return r.code === 0 ? r.stdout : void 0;
+  }
+  /** Stages content the caller merged itself, settling that file's conflict. */
+  async resolveWith(session, file, content) {
+    await writeFile(join2(session.baseWorktree, file), content, "utf8");
+    await this.git(["add", "--", file], session.baseWorktree);
+  }
+  /** Unified diff of changes in the base worktree against the base branch (the PR diff). */
+  /**
+   * The code first, then what was written about it.
+   *
+   * Git orders a diff by path, so on a run whose work lives under `toucan/` every specification, plan,
+   * checklist and brainstorm sorts ahead of the source. Measured on PR #765 with horse-code's own state
+   * already excluded: the first 60,000 characters held nine files, all of them markdown, and not one line of
+   * the code the review existed to read. Ordering is the fix — a budget spent on prose is a budget the
+   * source never sees, however large it is.
+   */
+  async diff(session, base) {
+    const range = `${base}...${session.baseBranch}`;
+    const notDocs = DOC_SPECS.map((d) => `:(exclude)${d}`);
+    const code = await this.git(["diff", range, "--", ".", ...excludeOwnState(), ...notDocs], session.baseWorktree);
+    const docs = await this.git(["diff", range, "--", ...DOC_SPECS, ...excludeOwnState()], session.baseWorktree);
+    const out = code.stdout + docs.stdout;
+    if (out.length <= MAX_DIFF_CHARS) return out;
+    return `\u2026 (diff truncated to the first ${MAX_DIFF_CHARS} characters of ${out.length}; use the read tools to inspect anything not shown here)
+${out.slice(0, MAX_DIFF_CHARS)}`;
+  }
+  /**
+   * Rejection path: commit whatever draft the worktree holds to its branch (so the work is NOT lost) and
+   * KEEP both the worktree directory and the branch, so the user can inspect the produced files directly
+   * under .horsecode/worktrees/<slug>/base. Returns the worktree path. (closeSession, by contrast, deletes
+   * the worktree + branch — but nothing currently calls it on the happy path; worktrees are kept for inspection.)
+   */
+  async preserveSession(session, message) {
+    await this.commitMerge(session, message);
+    return session.baseWorktree;
+  }
+  async commitMerge(session, message) {
+    await this.run(["add", "-A"], session.baseWorktree);
+    const staged = await this.git(["diff", "--cached", "--quiet"], session.baseWorktree);
+    if (staged.code === 0) return;
+    await this.run(message ? ["commit", "-m", message] : ["commit", "--no-edit"], session.baseWorktree);
+  }
+  /** Commits all changes in the task worktree to the task branch; no-op if there are no changes. */
+  async commitTask(task, message) {
+    await this.run(["add", "-A"], task.worktree);
+    const staged = await this.git(["diff", "--cached", "--quiet"], task.worktree);
+    if (staged.code === 0) return;
+    await this.run(["commit", "-m", message], task.worktree);
+  }
+  async abortMerge(session) {
+    await this.run(["merge", "--abort"], session.baseWorktree);
+  }
+  async removeTask(session, task) {
+    await this.git(["worktree", "remove", "--force", task.worktree], this.repoRoot);
+    await this.git(["branch", "-D", task.branch], this.repoRoot);
+  }
+  async closeSession(session) {
+    await rm2(session.root, { recursive: true, force: true });
+    await this.git(["worktree", "prune"], this.repoRoot);
+    const prefix = `hc/${session.jobSlug}/`;
+    const list = await this.git(["branch", "--list"], this.repoRoot);
+    const branches = list.stdout.split("\n").map((s) => s.replace(/^[*+ ]+/, "").trim()).filter((b) => b.startsWith(prefix));
+    for (const b of branches) {
+      await this.git(["branch", "-D", b], this.repoRoot);
+    }
+  }
+  /** Whether a remote exists — the difference between a pull request being delivery and being impossible. */
+  async hasRemote(session, remote = "origin") {
+    return (await this.git(["remote", "get-url", remote], session.baseWorktree)).code === 0;
+  }
+  async push(session, remote = "origin") {
+    const check = await this.git(["remote", "get-url", remote], session.baseWorktree);
+    if (check.code !== 0) return;
+    await this.run(["push", remote, session.baseBranch], session.baseWorktree);
+  }
+  /**
+   * Lands the finished work on the branch the job started from, in the main working copy.
+   *
+   * Without this, a project with no git remote gets nothing: `push` is a no-op and a pull request has
+   * nowhere to go, so every completed task sits on `hc/<job>/base` — invisible from the repository root.
+   * A user who watched thirty tasks succeed then finds an empty directory and cannot run the project.
+   *
+   * A pull request is delivery when there is a remote to open it against. When there is not, merging is.
+   *
+   * Refuses rather than forces. A dirty working copy or a checkout on some other branch means the user has
+   * something in progress, and overwriting that to deliver would be a worse failure than not delivering:
+   * the branch still exists and the caller reports how to merge it by hand.
+   */
+  async deliverLocally(session, targetBranch) {
+    const dirty = await this.git(["status", "--porcelain"], this.repoRoot);
+    if (dirty.code !== 0) return { ok: false, why: "the repository could not be read" };
+    if (dirty.stdout.split("\n").some((l) => l.trim() && !l.startsWith("??"))) {
+      return { ok: false, why: "the working copy has uncommitted changes" };
+    }
+    const head = await this.git(["symbolic-ref", "--short", "HEAD"], this.repoRoot);
+    const current = head.stdout.trim();
+    if (head.code !== 0 || !current) return { ok: false, why: "the repository is not on a branch" };
+    if (current !== targetBranch) return { ok: false, why: `the repository is on \`${current}\`, not \`${targetBranch}\`` };
+    const count = await this.git(["rev-list", "--count", `${targetBranch}..${session.baseBranch}`], this.repoRoot);
+    const commits = Number(count.stdout.trim()) || 0;
+    if (!commits) return { ok: true, commits: 0 };
+    const merged = await this.git(
+      ["merge", "--no-ff", "-m", `hc: ${session.jobSlug}`, session.baseBranch],
+      this.repoRoot
+    );
+    if (merged.code !== 0) return { ok: false, why: "the merge did not apply cleanly" };
+    return { ok: true, commits };
+  }
+  async openPR(session, adapter, input) {
+    const res = await adapter.createPR({
+      branch: session.baseBranch,
+      base: input.base,
+      title: input.title,
+      body: input.body
+    });
+    return { url: res.url };
+  }
+};
+
+// src/skills/apply.ts
+import { readFile } from "fs/promises";
+import { readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve2, sep as sep3 } 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 readdirSync2(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;
+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.`;
+  }
+  return available.length ? `skill not found: ${name}. Available: ${available.join(", ")}. Use one of these exactly, or carry on without a skill \u2014 do not guess another name.` : `skill not found: ${name}. This project has no skills installed, so carry on without one.`;
+}
+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 = resolve2(skill.dir, file);
+      const root = resolve2(skill.dir);
+      if (target !== root && !target.startsWith(root + sep3)) {
+        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/engine/unfinished.ts
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync, statSync } from "fs";
+import { join as join3 } from "path";
+function boardCounts(dir) {
+  try {
+    const raw = JSON.parse(readFileSync(join3(dir, "board.json"), "utf8"));
+    const cards = Array.isArray(raw.cards) ? raw.cards : Object.values(raw.cards ?? {});
+    const list = cards;
+    return { total: list.length, done: list.filter((c) => c.column === "MERGED" || c.column === "DONE").length };
+  } catch {
+    return { total: 0, done: 0 };
+  }
+}
+function unfinishedSessions(cwd, commitCount = () => 0) {
+  const root = join3(cwd, ".horsecode", "worktrees");
+  if (!existsSync3(root)) return [];
+  const out = [];
+  for (const id of readdirSync3(root)) {
+    const dir = join3(root, id);
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (!existsSync3(join3(dir, "base"))) continue;
+    const checkpoint = readCheckpoint(dir);
+    if (!checkpoint) continue;
+    let updatedAt = 0;
+    try {
+      updatedAt = statSync(join3(dir, "checkpoint.json")).mtimeMs;
+    } catch {
+    }
+    out.push({
+      id,
+      checkpoint,
+      cards: boardCounts(dir),
+      commits: commitCount(`hc/${id}/base`),
+      updatedAt
+    });
+  }
+  return out.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function describeUnfinished(s) {
+  const asked = s.checkpoint.rawPrompt.trim() || s.checkpoint.title;
+  const bits = [
+    s.checkpoint.done.length ? `${s.checkpoint.done.join(" \u2192 ")} done` : "nothing finished yet",
+    s.cards.total ? `${s.cards.done}/${s.cards.total} tasks` : "",
+    s.commits ? `${s.commits} commit${s.commits === 1 ? "" : "s"}` : ""
+  ].filter(Boolean);
+  return `\u201C${asked.length > 70 ? `${asked.slice(0, 69)}\u2026` : asked}\u201D \u2014 ${bits.join(" \xB7 ")} (\`${s.id}\`; say **continue** to pick it up)`;
+}
+
+// src/tools/git.ts
+import { execFile } from "child_process";
+import { z as z2 } from "zod";
+var READ_ONLY = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "show",
+  "diff",
+  "blame",
+  "shortlog",
+  "whatchanged",
+  "rev-parse",
+  "rev-list",
+  "merge-base",
+  "name-rev",
+  "describe",
+  "symbolic-ref",
+  "ls-files",
+  "ls-tree",
+  "cat-file",
+  "count-objects",
+  "show-ref",
+  "for-each-ref",
+  "ls-remote",
+  /**
+   * `check-ignore` asks whether a path is ignored — it reads `.gitignore` and answers, and changes nothing.
+   *
+   * Left out, it was the one read-only verb agents had to reach for `shell` to run: four calls in one run,
+   * each landing outside the tool that knows this repository's rules. And through `shell` its exit code is
+   * raw, so "no, that path is not ignored" — which git says with 1 — came back as a failed command.
+   */
+  "check-ignore"
+]);
+var READ_ONLY_PAIRS = /* @__PURE__ */ new Set([
+  "worktree list",
+  "branch --list",
+  "branch -l",
+  "branch -a",
+  "branch -v",
+  "branch -r",
+  "tag --list",
+  "tag -l",
+  "stash list",
+  "remote -v",
+  "remote show",
+  "config --get",
+  "config --list"
+]);
+var REFUSED_ARG = /^(--output|-c$|--config-env|--exec-path|-C$|--git-dir|--work-tree|--upload-pack|--receive-pack)/;
+var params = z2.object({
+  args: z2.array(z2.string()).min(1).describe(
+    'Git arguments as a list, without the leading "git" \u2014 e.g. ["status","--porcelain"] or ["log","-5","--oneline"].'
+  )
+});
+var MAX_GIT_OUTPUT = 6e4;
+var GIT_TIMEOUT_MS = 3e4;
+var GIT_PUSH_TIMEOUT_MS = 12e4;
+var ANSWERS_WITH_ONE = /* @__PURE__ */ new Set(["diff", "diff-index", "diff-tree", "diff-files", "merge-base", "check-ignore"]);
+function answeredWithOne(args, code) {
+  return code === 1 && ANSWERS_WITH_ONE.has(args[0] ?? "");
+}
+function answerOfOne(args) {
+  const verb = args[0] ?? "";
+  if (verb === "check-ignore") {
+    return "No \u2014 that path is not ignored by this repository's rules. (git exit code 1, which is the answer here.)";
+  }
+  if (verb === "merge-base") {
+    return args.includes("--is-ancestor") ? "No \u2014 the first commit is not an ancestor of the second. (git exit code 1, which is the answer here.)" : "No merge base: these commits share no common ancestor. (git exit code 1, which is the answer here.)";
+  }
+  return "There ARE differences \u2014 the comparison is not empty. Nothing failed; `--quiet`/`--exit-code` reports this as exit code 1. Re-run without it to see them.";
+}
+function refuse(args) {
+  const bad = args.find((a) => REFUSED_ARG.test(a));
+  if (bad) {
+    return `\`${bad}\` is not allowed: it can write a file, run a program through git's configuration, or point git at another repository.`;
+  }
+  const [sub, second] = args;
+  if (!sub || sub.startsWith("-")) return "The first argument must be a git subcommand, e.g. `status`.";
+  if (READ_ONLY.has(sub)) return void 0;
+  if (second && READ_ONLY_PAIRS.has(`${sub} ${second}`)) return void 0;
+  return `\`git ${sub}\` is not available here \u2014 this tool reads history and state, it never changes them. Available: ${[...READ_ONLY].sort().join(", ")}; also ${[...READ_ONLY_PAIRS].sort().join(", ")}.`;
+}
+var gitTool = {
+  name: "git",
+  description: 'Runs a READ-ONLY git command in the working directory and returns its output. Pass arguments as a list without the leading `git`: ["status","--porcelain"], ["log","-10","--oneline"], ["diff","--stat","main...HEAD"], ["show","abc123:path/to/file"]. Use it for what only git knows \u2014 what changed, when, by which commit, how a branch compares to another. Commands that change anything (checkout, commit, reset, clean, branch -D, stash, worktree add) are refused.',
+  permissionLevel: "safe",
+  parameters: params,
+  describe: (args) => {
+    const list = args.args;
+    const text = Array.isArray(list) ? list.join(" ") : "";
+    return { allowKey: "git:read", preview: `git ${text}`.slice(0, 120) };
+  },
+  async run(rawArgs, ctx) {
+    const parsed = params.safeParse(rawArgs);
+    if (!parsed.success) {
+      return { content: `git: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
+    }
+    const args = parsed.data.args;
+    const why = refuse(args);
+    if (why) return { content: why, isError: true, settled: true };
+    const out = await new Promise((resolve6) => {
+      const child = execFile("git", args, {
+        cwd: ctx.cwd,
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer: MAX_GIT_OUTPUT * 4,
+        // `--no-pager` would still be needed for some subcommands; killing the pager entirely is simpler and
+        // leaves nothing waiting for a terminal that does not exist.
+        env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat", GIT_TERMINAL_PROMPT: "0" }
+      }, (err, stdout, stderr) => {
+        const text = `${stdout}${stderr}`.trim();
+        resolve6({ code: err?.code ?? (err ? 1 : 0), text });
+      });
+      ctx.signal?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
+    });
+    const failed = out.code !== 0 && !answeredWithOne(args, out.code);
+    if (!out.text) {
+      if (!failed && out.code === 1) return { content: answerOfOne(args), isError: false };
+      return { content: out.code === 0 ? "(no output)" : "git failed with no output.", isError: failed };
+    }
+    const clipped = out.text.length > MAX_GIT_OUTPUT ? `${truncateSafe(out.text, MAX_GIT_OUTPUT)}
+\u2026[truncated \u2014 narrow the range, or put \`--stat\` directly after the subcommand (git diff --stat <rest>), which git requires]` : out.text;
+    return { content: clipped, isError: failed };
+  }
+};
+var WRITE = /* @__PURE__ */ new Set(["add", "commit", "push", "fetch"]);
+var REFSPEC = /:/;
+var REFUSED_PUSH = /^(-f|--force|--force-with-lease|--delete|--mirror|--prune)/;
+function refuseWrite(args) {
+  const bad = args.find((a) => REFUSED_ARG.test(a));
+  if (bad) {
+    return `\`${bad}\` is not allowed: it can write a file, run a program through git's configuration, or point git at another repository.`;
+  }
+  const [sub] = args;
+  if (!sub || !WRITE.has(sub)) {
+    return `\`git ${sub ?? ""}\` is not available here \u2014 this tool records work (${[...WRITE].join(", ")}). Use the \`git\` tool to read history and state.`;
+  }
+  if (sub === "fetch") {
+    const spec = args.slice(1).find((a) => REFSPEC.test(a) && !a.startsWith("-"));
+    if (spec) {
+      return `\`${spec}\` is not allowed: a refspec can move LOCAL branches, including the one this session is standing on. Fetch without one \u2014 it updates the remote-tracking refs, which is what tells you whether the remote has moved.`;
+    }
+    const pruned = args.find((a) => /^(--prune|-p)$/.test(a));
+    if (pruned) {
+      return `\`${pruned}\` is not allowed: it deletes remote-tracking refs, and something else may be relying on one. Fetch without it.`;
+    }
+  }
+  const forced = sub === "push" && args.find((a) => REFUSED_PUSH.test(a));
+  if (forced) {
+    return `\`${forced}\` is not allowed: it rewrites or removes history on the remote, which no one can undo from here. Push the branch as it stands, or ask the user to do the rewrite themselves.`;
+  }
+  return void 0;
+}
+var gitWriteTool = {
+  name: "git_write",
+  description: 'Changes git state: `add`, `commit`, `push` and `fetch`, nothing else. `fetch` updates the remote-tracking refs so you can see whether the remote has moved \u2014 it touches no local branch and no file; refspecs and `--prune` are refused. To merge what you fetched, ask the user. Pass arguments as a list without the leading `git`: ["add","docs/architecture"], ["commit","-m","docs: refresh traces"], ["push"]. Use it ONLY when the user has asked for the work to be recorded \u2014 committing on your own initiative puts a change in their history that they did not ask for. Every call goes through the permission prompt, so do the job in as few calls as it takes, and say what you are about to commit BEFORE you call it. Read the state first with the `git` tool \u2014 which branch you are on, what is staged, what changed \u2014 and never commit what you have not looked at. Force pushes and history rewrites are refused.',
+  permissionLevel: "exec",
+  parameters: params,
+  describe: (args) => {
+    const list = args.args;
+    const text = Array.isArray(list) ? list.join(" ") : "";
+    const sub = Array.isArray(list) && typeof list[0] === "string" ? list[0] : "";
+    return { allowKey: `git ${sub}`, preview: `git ${text}`.slice(0, 200) };
+  },
+  async run(rawArgs, ctx) {
+    const parsed = params.safeParse(rawArgs);
+    if (!parsed.success) {
+      return { content: `git_write: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
+    }
+    const args = parsed.data.args;
+    const why = refuseWrite(args);
+    if (why) return { content: why, isError: true, settled: true };
+    const out = await new Promise((resolve6) => {
+      const child = execFile("git", args, {
+        cwd: ctx.cwd,
+        // A push talks to a server: the read tool's 30s is a reasonable ceiling for a local query and a
+        // pessimistic one for a repository with anything in it.
+        timeout: args[0] === "push" ? GIT_PUSH_TIMEOUT_MS : GIT_TIMEOUT_MS,
+        maxBuffer: MAX_GIT_OUTPUT * 4,
+        // GIT_TERMINAL_PROMPT=0: a push that needs credentials fails with a message instead of blocking on a
+        // prompt no one can see — the TUI owns the terminal, so the agent would simply hang.
+        env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat", GIT_TERMINAL_PROMPT: "0" }
+      }, (err, stdout, stderr) => {
+        resolve6({ code: err ? 1 : 0, text: `${stdout}${stderr}`.trim() });
+      });
+      ctx.signal?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
+    });
+    if (!out.text) return { content: out.code === 0 ? "(done)" : "git failed with no output.", isError: out.code !== 0 };
+    const clipped = out.text.length > MAX_GIT_OUTPUT ? `${truncateSafe(out.text, MAX_GIT_OUTPUT)}
+\u2026[truncated]` : out.text;
+    return { content: clipped, isError: out.code !== 0 };
+  }
+};
+
+// src/tools/remember.ts
+import { z as z3 } from "zod";
+var params2 = z3.object({
+  fact: z3.string().describe(
+    "One short sentence, durable and project-specific: where something lives, which command builds it, a convention this codebase follows, a schema detail that cost you a search. Not what you did, not what is true of the language in general \u2014 something the next agent would otherwise have to rediscover."
+  )
+});
+function buildRememberTool(sink) {
+  return {
+    name: "remember_fact",
+    description: "Save a short, durable fact worth recalling in future sessions \u2014 a project convention, where something lives, a schema detail, a command that works. It is written straight away, so a session that stops early still leaves it behind. Use it the moment you learn something you would not want to work out twice; skip anything transient or specific to the task in hand.",
+    permissionLevel: "safe",
+    parameters: params2,
+    async run(rawArgs, ctx) {
+      const parsed = params2.safeParse(rawArgs);
+      if (!parsed.success) return { content: "remember_fact: invalid args (expected { fact })", isError: true };
+      const fact = parsed.data.fact.trim();
+      if (!fact) return { content: "remember_fact: empty fact", isError: true };
+      const write = sink ?? ctx.remember;
+      if (!write) return { content: "remember_fact: memory is not available in this context", isError: true };
+      write(fact);
+      return { content: `Remembered: ${fact}`, isError: false };
+    }
+  };
+}
+var rememberFactTool = buildRememberTool();
+
+// 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.\nRight-size the same way the skill does: a task is the smallest unit worth its own test cycle and its own review. Fold setup and scaffolding into the task 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. 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/speckit/layout.ts
+import { existsSync as existsSync4, mkdirSync, readdirSync as readdirSync4 } from "fs";
+import { join as join4 } from "path";
+function specsDir(workdir) {
+  return join4(workdir, "specs");
+}
+function constitutionPath(workdir) {
+  return join4(workdir, ".specify", "memory", "constitution.md");
+}
+function featurePaths(workdir, slug) {
+  const dir = join4(specsDir(workdir), slug);
+  return { dir, brainstorm: join4(dir, "brainstorm.md"), spec: join4(dir, "spec.md"), plan: join4(dir, "plan.md"), tasks: join4(dir, "tasks.md") };
+}
+function verifyPaths(workdir, slug) {
+  const dir = join4(specsDir(workdir), slug);
+  return { dir, plan: join4(dir, "test-plan.md"), report: join4(dir, "test-report.md") };
+}
+var ACTIVITY_WORDS = /* @__PURE__ */ new Set([
+  "test",
+  "tests",
+  "testing",
+  "smoke",
+  "e2e",
+  "verify",
+  "verification",
+  "verifying",
+  "check",
+  "checking",
+  "run",
+  "running",
+  "continue",
+  "continuing",
+  "report",
+  "session",
+  "the",
+  "for",
+  "of",
+  "a",
+  "an",
+  "and"
+]);
+var subjectWords = (slug) => new Set(slug.split("-").filter((w) => w.length > 2 && !ACTIVITY_WORDS.has(w)));
+function featureSlugFor(workdir, title) {
+  const want = toSlug(title);
+  const dir = specsDir(workdir);
+  if (existsSync4(dir)) {
+    const names = readdirSync4(dir);
+    for (const name of names) {
+      if (name.replace(/^\d+-/, "") === want) return name;
+    }
+    const wanted = subjectWords(want);
+    let best;
+    for (const name of names) {
+      const shared = [...subjectWords(name.replace(/^\d+-/, ""))].filter((w) => wanted.has(w)).length;
+      if (shared >= 2 && (!best || shared > best.shared)) best = { name, shared };
+    }
+    if (best) return best.name;
+  }
+  return nextFeatureSlug(workdir, title);
+}
+function nextFeatureSlug(workdir, title) {
+  const dir = specsDir(workdir);
+  let max = 0;
+  if (existsSync4(dir)) {
+    for (const name of readdirSync4(dir)) {
+      const m = name.match(/^(\d+)-/);
+      if (m) max = Math.max(max, Number(m[1]));
+    }
+  }
+  return `${String(max + 1).padStart(3, "0")}-${toSlug(title)}`;
+}
+function scaffoldFeature(workdir, slug) {
+  const paths = featurePaths(workdir, slug);
+  mkdirSync(paths.dir, { recursive: true });
+  mkdirSync(join4(workdir, ".specify", "memory"), { recursive: true });
+  return paths;
+}
+
+// src/engine/constitution-store.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join5 } from "path";
+import { z as z4 } from "zod";
+
+// src/engine/constitution.ts
+var SCOPES = ["always", "backend", "frontend", "data", "infra", "docs", "review", "spec", "test", "govern"];
+var RATIONALE = /^\s*\*(?:Gerekçe|Rationale):\*/i;
+function sectionOf(heading) {
+  const m = /^([IVXLC]+)\.\s/.exec(heading);
+  return m ? m[1] : heading;
+}
+function parseConstitution(text) {
+  const out = [];
+  let heading = "";
+  let buf = [];
+  const flush = () => {
+    const block = buf.join("\n").trim();
+    buf = [];
+    if (!block || !heading || RATIONALE.test(block)) return;
+    out.push({ section: sectionOf(heading), heading, text: block });
+  };
+  for (const line of text.split("\n")) {
+    const h = /^#{2,3}\s+(.*)$/.exec(line);
+    if (h) {
+      flush();
+      heading = /^core principles$/i.test(h[1].trim()) ? "" : h[1].trim();
+      continue;
+    }
+    if (!line.trim()) {
+      flush();
+      continue;
+    }
+    buf.push(line);
+  }
+  flush();
+  return out;
+}
+var BY_EXT = [
+  [/\.(cs|java|kt|go|py|rb|php|scala|rs)$/i, "backend"],
+  [/\.(ts|tsx|js|jsx|html|css|scss|sass|less|vue|svelte)$/i, "frontend"],
+  [/\.(sql)$|(^|\/)migrations?\//i, "data"],
+  [/\.(tf|tfvars)$|(^|\/)(k8s|helm|charts|deploy|infra)\//i, "infra"],
+  [/\.(md|mdx|adoc)$/i, "docs"]
+];
+var BY_ROLE = {
+  "code-reviewer": ["review"],
+  "principal-coder": ["review"],
+  "senior-coder": ["review"],
+  analyst: ["spec"],
+  planner: ["spec"],
+  brainstormer: ["spec"],
+  tester: ["test"]
+};
+function scopesForWork(opts) {
+  const out = /* @__PURE__ */ new Set(["always"]);
+  for (const s of BY_ROLE[opts.role ?? ""] ?? []) out.add(s);
+  for (const f of opts.files ?? []) for (const [re, scope] of BY_EXT) if (re.test(f)) out.add(scope);
+  return out;
+}
+var MAX_CONSTITUTION_CHARS = 2e4;
+function selectRules(rules, scopes, max = MAX_CONSTITUTION_CHARS) {
+  const applies = (r) => r.scopes.some((s) => scopes.has(s));
+  const always = rules.filter((r) => r.scopes.includes("always"));
+  const scoped = rules.filter((r) => !r.scopes.includes("always") && applies(r));
+  const used = [...always];
+  const dropped = [];
+  let size = used.reduce((n, r) => n + r.text.length, 0);
+  for (const r of scoped) {
+    if (size + r.text.length > max) {
+      dropped.push(r);
+      continue;
+    }
+    used.push(r);
+    size += r.text.length;
+  }
+  return { text: render(used, dropped), used, dropped };
+}
+function render(used, dropped) {
+  if (!used.length) return "";
+  const byHeading = /* @__PURE__ */ new Map();
+  for (const r of used) byHeading.set(r.heading, [...byHeading.get(r.heading) ?? [], r.text]);
+  const body = [...byHeading].map(([h, texts]) => `## ${h}
+${texts.join("\n\n")}`).join("\n\n");
+  const cut = dropped.length ? `
+
+(${dropped.length} further section(s) of the constitution apply to this work but did not fit: ${[...new Set(dropped.map((d) => d.section))].join(", ")}. Read them in the constitution if this change goes near them.)` : "";
+  return `
+
+# Project constitution \u2014 the rules that bind THIS work
+
+These are binding, and they are the project's own words. Where they and anything else disagree, they win. The full document is at \`.specify/memory/constitution.md\`.
+
+${body}${cut}`;
+}
+var CLASSIFY_PROMPT = `You are labelling the rules of a software project's constitution so each one can be handed to the agents it actually binds.
+
+For each rule, answer with the scopes it is ABOUT, from exactly this list: ${SCOPES.join(", ")}.
+
+- \`backend\`, \`frontend\`, \`data\`, \`infra\`: it names code, files or tooling of that kind \u2014 a language, a framework, a database, a deployment target.
+- \`spec\`: it constrains what a specification or plan may say (the stack, the boundaries, the vocabulary).
+- \`review\`: it is a gate a reviewer applies \u2014 what blocks a merge, how findings are reported.
+- \`test\`: it is about verification and evidence.
+- \`govern\`: it is about amending the constitution itself, and binds nobody else.
+- \`always\`: it names NO particular kind of code. It is about how to work, how to talk to the user, or what may never be done \u2014 so it binds every role on every task.
+
+A rule may carry several scopes. \`always\` is a real answer, not a safe one: use it when the rule genuinely mentions no kind of code, and NOT because you are unsure. If a rule is about backend code, say \`backend\` \u2014 labelling it \`always\` sends it to everyone writing CSS.
+
+Answer for EVERY index you are given, and for no others. Do not translate, summarise or rewrite anything \u2014 you are only labelling.
+
+Return {labels: [{index, scopes}]} via submit, one entry per rule, in the order given.`;
+var CLASSIFY_BATCH = 20;
+var CLASSIFY_RETRIES = 2;
+function classifyMessage(rules, offset = 0) {
+  return rules.map((r, i) => `--- ${i + offset} --- (${r.heading})
+${r.text}`).join("\n\n");
+}
+function applyLabels(rules, labels) {
+  const known = new Set(SCOPES);
+  const byIndex = new Map(labels.map((l) => [l.index, l.scopes.filter((s) => known.has(s))]));
+  const unlabelled = [];
+  const scoped = rules.map((r, i) => {
+    const scopes = byIndex.get(i) ?? [];
+    if (!scopes.length) unlabelled.push(i);
+    return { ...r, scopes: scopes.length ? scopes : ["always"] };
+  });
+  return { scoped, unlabelled };
+}
+var MAX_ALWAYS_SHARE = 0.35;
+function labellingLooksWrong(scoped) {
+  if (!scoped.length) return void 0;
+  const always = scoped.filter((r) => r.scopes.includes("always")).length;
+  if (always > scoped.length * MAX_ALWAYS_SHARE) {
+    return `${always} of ${scoped.length} rules came back as \`always\``;
+  }
+  return void 0;
+}
+
+// src/engine/constitution-store.ts
+var LabelsSchema = z4.object({
+  labels: z4.array(z4.object({
+    index: z4.number().int().describe("The rule's number, exactly as given to you."),
+    scopes: z4.array(z4.enum(SCOPES)).describe(
+      `Which kinds of work this rule actually binds. Only the ones it really governs: a rule that reaches everyone is carried into every agent's prompt, so a scope added "to be safe" is paid for on every call that will never use it.`
+    )
+  }))
+});
+var CLASSIFY_MAX_TURNS = 3;
+function cachePath(home, text) {
+  const hash = createHash("sha256").update(text).digest("hex").slice(0, 16);
+  return join5(home, ".horsecode", "constitution", `${hash}.json`);
+}
+var memo = /* @__PURE__ */ new Map();
+async function scopedConstitution(deps, cwd) {
+  const path = constitutionPath(cwd);
+  if (!existsSync5(path)) return [];
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch {
+    return [];
+  }
+  const cache = cachePath(deps.home, text);
+  const hit = memo.get(cache);
+  if (hit) return hit;
+  if (existsSync5(cache)) {
+    try {
+      const saved = JSON.parse(readFileSync2(cache, "utf8"));
+      memo.set(cache, saved);
+      return saved;
+    } catch {
+    }
+  }
+  const rules = parseConstitution(text);
+  if (!rules.length) return [];
+  deps.note?.(`\u{1F4DC} Reading the project constitution \u2014 ${rules.length} rules, labelled once so each reaches the work it binds.`);
+  const labels = [];
+  const resolved = deps.roleRegistry.resolve("judge");
+  let failed = 0;
+  for (let start = 0; start < rules.length; start += CLASSIFY_BATCH) {
+    const batch = rules.slice(start, start + CLASSIFY_BATCH);
+    for (let attempt = 0; attempt <= CLASSIFY_RETRIES; attempt++) {
+      try {
+        const out = await runStructuredRole({
+          provider: deps.provider,
+          ...resolved,
+          systemPrompt: CLASSIFY_PROMPT,
+          tools: new ToolRegistry(),
+          messages: [{ role: "user", content: classifyMessage(batch, start) }],
+          permission: deps.permission,
+          approve: deps.approve,
+          cwd,
+          signal: deps.signal,
+          maxTurns: CLASSIFY_MAX_TURNS
+        }, LabelsSchema);
+        labels.push(...out.labels);
+        break;
+      } catch {
+        if (attempt === CLASSIFY_RETRIES) failed++;
+      }
+    }
+  }
+  const { scoped, unlabelled } = applyLabels(rules, labels);
+  if (unlabelled.length) {
+    deps.note?.(`\u26A0\uFE0F ${unlabelled.length} of ${rules.length} constitution rules could not be labelled \u2014 those go to every role. A rule sent too widely is noise; one sent nowhere is not a rule.`);
+  }
+  const wrong = labellingLooksWrong(scoped);
+  if (failed || wrong) {
+    deps.note?.(`\u26A0\uFE0F The constitution labelling is not trustworthy \u2014 ${failed ? `${failed} batch(es) failed` : wrong}. Not caching it, so the next session tries again rather than inheriting it.`);
+  } else {
+    try {
+      mkdirSync2(join5(deps.home, ".horsecode", "constitution"), { recursive: true });
+      writeFileSync(cache, JSON.stringify(scoped), "utf8");
+    } catch {
+    }
+  }
+  memo.set(cache, scoped);
+  return scoped;
+}
+async function constitutionNote(deps, cwd, work) {
+  const scoped = await scopedConstitution(deps, cwd);
+  if (!scoped.length) return "";
+  const sel = selectRules(scoped, scopesForWork(work));
+  if (sel.dropped.length) {
+    deps.note?.(`\u{1F4DC} ${sel.dropped.length} constitution section(s) that apply here did not fit the prompt: ${[...new Set(sel.dropped.map((d) => d.section))].join(", ")}.`);
+  }
+  return sel.text;
+}
+
+// src/engine/reviewer.ts
+import { z as z8 } from "zod";
+
+// src/tools/find-tool.ts
+import { z as z5 } from "zod";
+var params3 = z5.object({
+  query: z5.string().describe(
+    'What you need a tool for, in a few words \u2014 e.g. "pull request comments", "list angular projects". Or an exact tool name to fetch just that one.'
+  )
+});
+var MAX_FOUND = 5;
+var NOISE = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "of",
+  "for",
+  "in",
+  "on",
+  "to",
+  "and",
+  "or",
+  "with",
+  "by",
+  "from",
+  "get",
+  "list",
+  "tool",
+  "project",
+  "use",
+  "this",
+  "that",
+  "it",
+  "is",
+  "are",
+  "be",
+  "mcp"
+]);
+var words = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1 && !NOISE.has(w));
+function scoreTool(t, query) {
+  const q = words(query);
+  if (!q.length) return 0;
+  const name = t.name.toLowerCase();
+  const desc = t.description.toLowerCase();
+  let score = 0;
+  for (const w of q) {
+    if (name.includes(w)) score += 3;
+    else if (desc.includes(w)) score += 1;
+  }
+  if (name === query.toLowerCase().trim()) score += 100;
+  return score;
+}
+function buildFindToolTool(registry) {
+  return {
+    name: "find_tool",
+    description: 'Fetches the full definition of a project tool so you can call it. The system prompt lists the tools this project connects, by name and one line each; their parameters are not loaded until you ask. Pass what you need \u2014 "pull request threads", "run a build pipeline" \u2014 or an exact tool name. The matches become callable from your NEXT message, so call this first, then call the tool itself. If a search returns nothing useful, do the job with the tools you already have rather than searching again with different words.',
+    permissionLevel: "safe",
+    parameters: params3,
+    run: async (rawArgs) => {
+      const parsed = params3.safeParse(rawArgs);
+      if (!parsed.success) {
+        return { content: `find_tool: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
+      }
+      const { query } = parsed.data;
+      const pool = registry.deferredTools().filter((t) => t.broken === void 0);
+      if (!pool.length) {
+        return {
+          content: "Every tool this project connects is already loaded \u2014 there is nothing further to fetch. Use the ones you have.",
+          isError: false
+        };
+      }
+      const scored = pool.map((t) => ({ t, s: scoreTool(t, query) })).filter((x) => x.s > 0).sort((a, b) => b.s - a.s);
+      const exact = scored.find((x) => x.t.name.toLowerCase() === query.toLowerCase().trim());
+      const hits = exact ? [exact] : scored.slice(0, MAX_FOUND);
+      if (!hits.length) {
+        return {
+          content: `No project tool matches "${query}". Available to fetch: ${pool.map((t) => t.name).join(", ")}.`,
+          isError: false
+        };
+      }
+      registry.surface(hits.map((x) => x.t.name));
+      const rows = hits.map((x) => `- \`${x.t.name}\` \u2014 ${x.t.description.replace(/^\[MCP:[^\]]*\]\s*/, "").split(/\n/)[0].trim()}`);
+      return {
+        content: `Loaded ${hits.length} tool(s) \u2014 you can call them from your next message:
+${rows.join("\n")}`,
+        isError: false
+      };
+    }
+  };
+}
+
+// src/tools/unfinished-tool.ts
+import { execFileSync } from "child_process";
+import { join as join6 } from "path";
+import { z as z6 } from "zod";
+var params4 = z6.object({});
+function commitsAhead(cwd, branch) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["rev-list", "--count", `HEAD..${branch}`],
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+    return Number(out.trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+var findUnfinishedTool = {
+  name: "find_unfinished",
+  description: `Lists work a previous run left behind in this project, newest first: what the user originally asked, which pipeline phases finished, how many board tasks are done, how many commits sit on the session's branch, and the absolute path of its worktree. Call it whenever the user refers to earlier work \u2014 "continue", "where were we", "what was I doing" \u2014 before answering from the repository, because a session's work is NOT in the checkout you are standing in: it is on its own branch in its own worktree. Read files under the worktree path to see the spec, plan or board it produced.`,
+  permissionLevel: "safe",
+  parameters: params4,
+  describe: () => ({ allowKey: "find_unfinished", preview: "find unfinished work" }),
+  run: async (_args, ctx) => {
+    const found = unfinishedSessions(ctx.cwd, (b) => commitsAhead(ctx.cwd, b));
+    if (!found.length) {
+      return {
+        content: "No unfinished session in this project: every worktree has either been cleaned up or never recorded a checkpoint. Anything earlier is in the repository's own history.",
+        isError: false
+      };
+    }
+    const rows = found.map((s) => {
+      const c = s.checkpoint;
+      return [
+        `## ${s.id}`,
+        `- The user asked: "${c.rawPrompt.trim() || c.title}"`,
+        `- Understood as: ${c.refinedPrompt}`,
+        `- Phases finished: ${c.done.length ? c.done.join(" \u2192 ") : "none"}${c.lane ? ` (lane: ${c.lane})` : ""}`,
+        s.cards.total ? `- Tasks: ${s.cards.done} of ${s.cards.total} finished` : "- No task board yet",
+        `- Branch \`hc/${s.id}/base\` has ${s.commits} commit(s) the base does not`,
+        `- Worktree: ${join6(ctx.cwd, ".horsecode", "worktrees", s.id, "base")}`
+      ].join("\n");
+    });
+    return {
+      content: `${rows.join("\n\n")}
+
+To continue one of these, the user says **continue** \u2014 that reopens the session and its lane. You can read anything under the worktree path above to answer questions about it now.`,
+      isError: false
+    };
+  }
+};
+
+// src/tools/propose-memory.ts
+import { z as z7 } from "zod";
+var params5 = z7.object({
+  text: z7.string(),
+  kind: z7.enum(["fact", "lesson"]).optional().describe(
+    "`fact`: something true about this project that a later run would otherwise have to rediscover (where something lives, which command builds it). `lesson`: something learned the hard way \u2014 an approach that failed and what to do instead."
+  )
+});
+var proposeMemoryTool = {
+  name: "propose_memory",
+  description: "Propose something you learned about THIS PROJECT for long-term memory. It is NOT stored directly \u2014 a curator reviews, rewrites and may discard it. Propose ONLY durable, project-specific knowledge that would still be true and useful months from now in an unrelated task: a convention, a constraint, a non-obvious gotcha, the root cause of a recurring problem. NEVER propose your findings about the work you are reviewing right now, anything about this specific task or run, or general programming advice. Most reviews should propose nothing at all. Use it at most once, and only when you are sure.",
+  permissionLevel: "safe",
+  parameters: params5,
+  async run(rawArgs, ctx) {
+    const parsed = params5.safeParse(rawArgs);
+    if (!parsed.success) return { content: "propose_memory: invalid args (expected { text, kind? })", isError: true };
+    const text = parsed.data.text.trim();
+    if (!text) return { content: "propose_memory: empty proposal", isError: true };
+    if (!ctx.proposeMemory) return { content: "propose_memory: memory is not available in this context", isError: true };
+    const accepted = ctx.proposeMemory(text, parsed.data.kind ?? "fact");
+    return {
+      content: accepted ? "Proposal queued for the memory curator. It may be rewritten or discarded; do not propose it again." : "Already proposed (or the queue is full) \u2014 no action needed.",
+      isError: false
+    };
+  }
+};
+
+// src/skills/route.ts
+var STOP = /* @__PURE__ */ new Set([
+  "use",
+  "when",
+  "the",
+  "user",
+  "wants",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "into",
+  "also",
+  "not",
+  "other",
+  "otherwise",
+  "improve",
+  "covers",
+  "handles",
+  "should",
+  "become",
+  "than",
+  "over",
+  "onto",
+  "your",
+  "you",
+  "are",
+  "any",
+  "all",
+  "its",
+  "their",
+  "them",
+  "they",
+  "have",
+  "has",
+  "was",
+  "were",
+  "will",
+  "would",
+  "can",
+  "may",
+  "must",
+  "such",
+  "more",
+  "most",
+  "less",
+  "very",
+  "just",
+  "only",
+  "some",
+  "each",
+  "every",
+  "make",
+  "made",
+  "making",
+  "need",
+  "needs",
+  "needed",
+  "want",
+  "wanted",
+  "work",
+  "works",
+  "working",
+  "task",
+  "tasks",
+  "using",
+  "used",
+  "uses",
+  "via",
+  "per",
+  "out",
+  "off",
+  "about",
+  "after",
+  "before",
+  "then",
+  "there",
+  "where",
+  "which",
+  "while",
+  "what",
+  "who",
+  "how",
+  "why",
+  "does",
+  "did",
+  "done",
+  "get",
+  "got",
+  "let",
+  "lets"
+]);
+var MIN_TERM = 3;
+var SHORT_TERMS = /* @__PURE__ */ new Set(["ui", "ux", "db", "js", "ts", "qa"]);
+function splitIdentifiers(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_./-]+/g, " ");
+}
+function terms(text) {
+  return (splitIdentifiers(text).toLowerCase().match(/[a-z][a-z0-9]+/g) ?? []).filter((t) => (t.length >= MIN_TERM || SHORT_TERMS.has(t)) && !STOP.has(t));
+}
+var MIN_SHARED = 4;
+function sameWord(a, b) {
+  if (a === b) return true;
+  const fold = (w) => w.endsWith("e") ? w.slice(0, -1) : w;
+  const [x, y] = [fold(a), fold(b)];
+  const [short, long] = x.length <= y.length ? [x, y] : [y, x];
+  return short.length >= MIN_SHARED && long.startsWith(short);
+}
+function exclusions(description) {
+  const m = /\bnot\s+for\s+([^.]+)/i.exec(description);
+  return m ? terms(m[1]) : [];
+}
+function isExplicitOnly(description) {
+  return /\bonly\s+(runs?|use[sd]?|invoke[sd]?)\b[^.]*\bexplicit/i.test(description) || /\bdoes\s+not\s+trigger\s+on\s+its\s+own\b/i.test(description) || /\bonly\s+when\s+explicitly\s+(invoked|asked|requested)\b/i.test(description);
+}
+function isNonImplementing(description) {
+  return /\bread[- ]only\b/i.test(description) || /\bdoes\s+not\s+(implement|apply|execute|write)\b/i.test(description);
+}
+var MATCH_BAR = 3;
+var MAX_ROUTED = 3;
+var MAX_ROUTED_CHARS = 24e3;
+function scoreSkill(task, description) {
+  const taskTerms = new Set(terms(task));
+  if (!taskTerms.size) return { score: 0, hits: [], density: 0 };
+  const task_ = [...taskTerms];
+  const excluded2 = exclusions(description);
+  if (excluded2.some((e) => task_.some((t) => sameWord(t, e)))) return { score: 0, hits: [], density: 0 };
+  const body = description.replace(/\bnot\s+for\s+[^.]+/i, "");
+  const vocab = [...new Set(terms(body))];
+  const hits = vocab.filter((d) => task_.some((t) => sameWord(t, d)));
+  return { score: hits.length, hits, density: vocab.length ? hits.length / vocab.length : 0 };
+}
+function routeSkills(task, registry, already = [], opts = {}) {
+  const bar = opts.bar ?? MATCH_BAR;
+  let spent = 0;
+  const have = new Set(already);
+  const placed = new Set(opts.placed ?? []);
+  const paths = (opts.files ?? []).join(" ");
+  const base = [opts.role ?? "", routingSubject(task), paths].filter(Boolean).join(" ");
+  const subject = [base, expandExtensions(opts.files ?? []), expandAbbreviations(base)].filter(Boolean).join(" ");
+  return registry.list().filter((s) => !have.has(s.name)).filter((s) => !placed.has(s.name)).filter((s) => !isExplicitOnly(s.description)).filter((s) => !(opts.implementing && isNonImplementing(s.description))).map((s) => ({ name: s.name, ...scoreSkill(subject, s.description) })).filter((m) => m.score >= bar).sort((a, b) => b.score - a.score || b.density - a.density || a.name.localeCompare(b.name)).slice(0, opts.max ?? MAX_ROUTED).filter((m) => {
+    const len = registry.get(m.name)?.content.length ?? 0;
+    if (spent + len > MAX_ROUTED_CHARS) return false;
+    spent += len;
+    return true;
+  });
+}
+function routingSubject(task) {
+  return task.replace(/\S*[\\/]\.horsecode[\\/]pastes[\\/]\S+/g, " ").replace(/\s{2,}/g, " ").trim();
+}
+var EXT_WORDS = {
+  tsx: "frontend interface component web",
+  jsx: "frontend interface component web",
+  vue: "frontend interface component web",
+  svelte: "frontend interface component web",
+  css: "frontend interface styling web",
+  scss: "frontend interface styling web",
+  html: "frontend interface web",
+  sql: "database migration",
+  proto: "protocol schema"
+};
+var ABBREVIATIONS = {
+  a11y: "accessibility",
+  i18n: "internationalization localization",
+  l10n: "localization",
+  auth: "authentication",
+  ui: "interface",
+  ux: "interface experience"
+};
+function expandAbbreviations(text) {
+  const out = [];
+  for (const t of terms(text)) if (ABBREVIATIONS[t]) out.push(ABBREVIATIONS[t]);
+  return out.join(" ");
+}
+function expandExtensions(files) {
+  const words3 = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const ext2 = f.split(".").pop()?.toLowerCase();
+    if (ext2 && EXT_WORDS[ext2]) for (const w of EXT_WORDS[ext2].split(" ")) words3.add(w);
+  }
+  return [...words3].join(" ");
+}
+var CONFIDENT_MARGIN = 4;
+function partitionByConfidence(matches, bar = MATCH_BAR, margin = CONFIDENT_MARGIN) {
+  const confident = [];
+  const borderline = [];
+  for (const m of matches) (m.score >= bar + margin ? confident : borderline).push(m);
+  return { confident, borderline };
+}
+
+// src/engine/task-diff.ts
+var MAX_DIFF_CHARS2 = 6e4;
+async function taskDiff(cwd, baseRef, git = defaultGitRunner) {
+  const out = await git(["diff", `${baseRef}...HEAD`, "--", ".", ...excludeOwnState()], cwd);
+  if (out.code !== 0) return "";
+  const diff = out.stdout;
+  if (diff.length <= MAX_DIFF_CHARS2) return diff;
+  return `${diff.slice(0, MAX_DIFF_CHARS2)}
+\u2026diff truncated at ${MAX_DIFF_CHARS2} characters \u2014 read the remaining files directly.`;
+}
+function describeDiff(diff) {
+  if (!diff.trim()) {
+    return "The diff for this task could not be produced. Inspect the worktree with read_file/grep instead.";
+  }
+  return `The complete diff of this task's changes follows. It is the subject of the review \u2014 read it first, and open a file only when the diff alone cannot answer a question.
+
+\`\`\`diff
+${diff}
+\`\`\``;
+}
+async function workingTreeDiff(cwd, git = defaultGitRunner) {
+  const out = await git(["diff", "HEAD", "--", ".", ...excludeOwnState()], cwd);
+  if (out.code !== 0) return "";
+  const diff = out.stdout;
+  if (diff.length <= MAX_DIFF_CHARS2) return diff;
+  return `${diff.slice(0, MAX_DIFF_CHARS2)}
+\u2026diff truncated at ${MAX_DIFF_CHARS2} characters \u2014 read the remaining files directly.`;
+}
+async function diffSince(cwd, sinceRef, git = defaultGitRunner) {
+  const out = await git(["diff", sinceRef, "--", ".", ...excludeOwnState()], cwd);
+  if (out.code !== 0) return "";
+  const diff = out.stdout;
+  if (diff.length <= MAX_DIFF_CHARS2) return diff;
+  return `${diff.slice(0, MAX_DIFF_CHARS2)}
+\u2026diff truncated at ${MAX_DIFF_CHARS2} characters \u2014 read the remaining files directly.`;
+}
+
+// src/engine/reviewer.ts
+var CODE_REVIEW_MAX_TURNS = 25;
+var CODE_REVIEW_TIMEOUT_MS = 5 * 60 * 1e3;
+var VerdictSchema = z8.object({
+  verdict: z8.enum(["pass", "fail"]).describe(
+    "`fail` only if the code does not do what the task required, or does it wrongly. Style you would have written differently is a note on a `pass` \u2014 a fail sends the task back around the whole cycle."
+  ),
+  notes: z8.array(z8.string())
+});
+function readOnlyRegistry(deps, opts = {}) {
+  const r = new ToolRegistry();
+  r.register(readFileTool);
+  r.register(grepTool);
+  r.register(globTool);
+  r.register(gitTool);
+  r.register(buildSkillTool(deps.skillRegistry));
+  for (const t of contextTools(deps)) r.register(t);
+  if (opts.remember) r.register(buildRememberTool(deps.rememberFact));
+  if (opts.gitWrite) {
+    r.register(gitWriteTool);
+    r.register(findUnfinishedTool);
+  }
+  if (opts.propose) r.register(proposeMemoryTool);
+  if (opts.mcp) deferMcp(r, deps.mcpTools?.() ?? []);
+  return r;
+}
+function deferMcp(r, tools) {
+  for (const t of tools) r.registerDeferred(t);
+  if (tools.length) r.register(buildFindToolTool(r));
+}
+async function runReviewer(deps, task, cwd) {
+  const resolved = deps.roleRegistry.resolve("code-reviewer");
+  const hints = memoryHints(deps, task.title, { role: "code-reviewer" });
+  const reviewerTools = readOnlyRegistry(deps, { propose: true });
+  const routed = routeSkills(task.title, deps.skillRegistry, deps.roleRegistry.skillsFor("code-reviewer"), {
+    // The card's own files, never a guess: see the implementer for the measurement that settled it.
+    role: "code-reviewer",
+    files: task.files,
+    placed: placedSkills()
+  });
+  if (routed.length) deps.note?.(`\u{1F4CE} \`code-reviewer\` \xB7 ${routed.map((m) => `**${m.name}**`).join(", ")}`);
+  const diff = deps.baseRef ? await taskDiff(cwd, deps.baseRef) : "";
+  const ask = { role: "user", content: `Review the CODE that implements task "${task.title}" \u2014 correctness, tests, and implementation quality.
+The subject of this review is ALWAYS the code. Do NOT review, re-open, or comment on the upstream planning documents (specs/**, .specify/**, plan.md, tasks.md) \u2014 they were already reviewed and approved before coding began; treat them as fixed context, not as something to critique.
+Give a verdict (pass/fail + notes).
+
+${describeDiff(diff)}` };
+  const law = deps.home ? await constitutionNote(
+    { ...deps, home: deps.home, note: deps.note },
+    cwd,
+    { role: "code-reviewer", files: task.files, title: task.title }
+  ) : "";
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    // The reviewer gets the SAME rules the implementer was given: a gate that does not know what was
+    // required cannot tell whether it was met, and that is where a constitution stops being one.
+    systemPrompt: (routed.length ? applySkills(resolved.systemPrompt, routed.map((m) => m.name), deps.skillRegistry) : resolved.systemPrompt) + law + projectToolsNote(reviewerTools.list(), !!loadGraphSync(cwd)) + BATCH_TOOLS_NOTE,
+    tools: reviewerTools,
+    proposeMemory: (t, k) => deps.proposeMemory?.(t, k, "code-reviewer") ?? false,
+    messages: hints.message ? [{ role: "user", content: hints.message }, ask] : [ask],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd,
+    signal: AbortSignal.any([deps.signal, AbortSignal.timeout(CODE_REVIEW_TIMEOUT_MS)]),
+    maxTurns: CODE_REVIEW_MAX_TURNS
+  };
+  const verdict = await runStructuredRole(opts, VerdictSchema);
+  reinforceUsed(deps, hints.ids, verdict.notes.join(" "), "code-reviewer");
+  return verdict;
+}
+
+// src/tools/write.ts
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { dirname as dirname3, resolve as resolve3, sep as sep4 } from "path";
+import { z as z9 } from "zod";
+var params6 = z9.object({ path: z9.string(), content: z9.string() });
+var writeFileTool = {
+  name: "write_file",
+  description: "Writes content to a file (creates parent directories). Creating a NEW file is always allowed; to OVERWRITE an existing file you must read_file it first in this run \u2014 otherwise the write is refused.",
+  permissionLevel: "write",
+  parameters: params6,
+  describe(rawArgs) {
+    const a = params6.parse(rawArgs);
+    return { allowKey: a.path, preview: `write ${a.path} (${Buffer.byteLength(a.content)} bytes)` };
+  },
+  async run(rawArgs, ctx) {
+    const parsed = params6.safeParse(rawArgs);
+    if (!parsed.success) {
+      return {
+        content: `write_file: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`,
+        isError: true
+      };
+    }
+    const a = parsed.data;
+    const target = resolve3(ctx.cwd, a.path);
+    const cwdResolved = resolve3(ctx.cwd);
+    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep4)) {
+      return { content: `write_file: path is outside cwd: ${a.path}`, isError: true };
+    }
+    if (ctx.readFiles && existsSync6(target) && !ctx.readFiles.has(target)) {
+      return {
+        content: `write_file: refusing to overwrite ${a.path} \u2014 read_file it first so you know what you are replacing (or use edit_file for a targeted change).`,
+        isError: true
+      };
+    }
+    try {
+      await mkdir3(dirname3(target), { recursive: true });
+      await writeFile2(target, a.content, "utf8");
+      {
+        const ls = a.content ? a.content.split("\n") : [];
+        ctx.onActivity?.({ tool: "write", target: a.path, lines: ls.length, preview: ls.slice(0, 12), startLine: 1 });
+      }
+      ctx.readFiles?.add(target);
+      return { content: `Written: ${a.path}`, isError: false };
+    } catch (e) {
+      return {
+        content: `write_file error: ${e instanceof Error ? e.message : String(e)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/edit.ts
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve4, sep as sep5 } from "path";
+import { z as z10 } from "zod";
+var params7 = z10.object({
+  path: z10.string(),
+  oldString: z10.string(),
+  newString: z10.string(),
+  replaceAll: z10.boolean().optional()
+});
+var NEAR_MISS_CHARS = 600;
+var norm = (t) => t.replace(/[ \t]+/g, " ").replace(/[ \t]+$/gm, "").trim();
+function shortPath(path, cwd) {
+  const abs = resolve4(cwd, path);
+  return abs === cwd ? "." : abs.startsWith(cwd + sep5) ? abs.slice(cwd.length + 1) : path;
+}
+function whyNotFound(content, oldString) {
+  if (/^\s*\d+\t/m.test(oldString)) {
+    return " \u2014 your oldString still carries read_file's display prefixes (`123\\t\u2026`). Strip the number and the tab from every line and send the file's real bytes.";
+  }
+  const lines = content.split("\n");
+  const wanted = oldString.split("\n");
+  const firstReal = wanted.find((l) => l.trim().length > 0)?.trim();
+  if (firstReal === void 0) return " \u2014 your oldString is empty or only whitespace.";
+  if (norm(content).includes(norm(oldString))) {
+    const at2 = lines.findIndex((l) => norm(l) === norm(wanted.find((w) => w.trim())) || norm(l).includes(firstReal));
+    const block = at2 >= 0 ? lines.slice(at2, at2 + wanted.length).join("\n") : "";
+    return ` \u2014 the text IS in the file, but its whitespace differs from what you sent (tabs vs spaces, or trailing space). Here it is exactly as the file has it, from line ${at2 + 1}:
+` + block.slice(0, NEAR_MISS_CHARS);
+  }
+  const at = lines.findIndex((l) => l.includes(firstReal));
+  if (at >= 0) {
+    return ` \u2014 the file has "${firstReal.slice(0, 60)}" at line ${at + 1}, but what follows it is not what you sent. This is what is there now:
+${lines.slice(at, at + wanted.length + 2).join("\n").slice(0, NEAR_MISS_CHARS)}`;
+  }
+  return " \u2014 no line of your oldString is in the file. Read it again before editing: it has changed since you last saw it, or this is not the file you meant.";
+}
+var editFileTool = {
+  name: "edit_file",
+  description: "Performs an exact string replacement in a file. oldString must match the file's REAL bytes \u2014 strip the `<number>\\t` prefix that read_file adds for display, or nothing will match. oldString must be unique (otherwise replaceAll is required); a miss is reported as an error, never a silent no-op.",
+  permissionLevel: "write",
+  parameters: params7,
+  describe(rawArgs) {
+    const a = params7.parse(rawArgs);
+    return { allowKey: a.path, preview: `edit ${a.path}` };
+  },
+  async run(rawArgs, ctx) {
+    const parsed = params7.safeParse(rawArgs);
+    if (!parsed.success) {
+      return {
+        content: `edit_file: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`,
+        isError: true
+      };
+    }
+    const a = parsed.data;
+    const target = resolve4(ctx.cwd, a.path);
+    const cwdResolved = resolve4(ctx.cwd);
+    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep5)) {
+      return { content: `edit_file: path is outside cwd: ${a.path}`, isError: true };
+    }
+    let content;
+    try {
+      content = await readFile2(target, "utf8");
+    } catch (e) {
+      return {
+        content: `edit_file error: ${e instanceof Error ? e.message : String(e)}`,
+        isError: true
+      };
+    }
+    const count = content.split(a.oldString).length - 1;
+    if (count === 0) {
+      return {
+        content: `edit_file: oldString not found (${shortPath(a.path, cwdResolved)})${whyNotFound(content, a.oldString)}`,
+        isError: true
+      };
+    }
+    if (count > 1 && !a.replaceAll) {
+      return {
+        content: `edit_file: oldString is not unique (${count} matches) \u2014 replaceAll required`,
+        isError: true
+      };
+    }
+    const next = a.replaceAll ? content.split(a.oldString).join(a.newString) : content.replace(a.oldString, a.newString);
+    try {
+      await writeFile3(target, next, "utf8");
+      {
+        const added = a.newString ? a.newString.split("\n") : [];
+        const removed = a.oldString ? a.oldString.split("\n") : [];
+        const at = content.indexOf(a.oldString);
+        const startLine = at < 0 ? 1 : content.slice(0, at).split("\n").length;
+        ctx.onActivity?.({ tool: "edit", target: a.path, lines: added.length, preview: added.slice(0, 12), removed: removed.slice(0, 12), startLine });
+      }
+      return { content: `Edited: ${a.path}`, isError: false };
+    } catch (e) {
+      return {
+        content: `edit_file error: ${e instanceof Error ? e.message : String(e)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/shell.ts
+import { spawn } from "child_process";
+import { resolve as resolve5, sep as sep6 } from "path";
+import { z as z11 } from "zod";
+var params8 = z11.object({
+  command: z11.string(),
+  /** Milliseconds before the command is killed. Defaults to DEFAULT_TIMEOUT_MS, capped at MAX_TIMEOUT_MS. */
+  timeout: z11.number().int().positive().optional()
+});
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 6e5;
+var KILL_GRACE_MS = 2e3;
+var MAX_SHELL_CHARS = 32e3;
+var TAIL_SHARE = 0.6;
+function clampOutput(body, max = MAX_SHELL_CHARS) {
+  if (body.length <= max) return body;
+  const tail = Math.floor(max * TAIL_SHARE);
+  const head = max - tail;
+  const dropped = body.length - max;
+  const lines = body.slice(head, body.length - tail).split("\n").length;
+  return `${body.slice(0, head)}
+
+\u2026 [${dropped.toLocaleString("en-US")} chars / ~${lines} lines trimmed from the middle] \u2026
+
+${body.slice(-tail)}`;
+}
+var REWRITES = [
+  /\bsed\s+(?:-[a-zA-Z]*\s+)*-i\b/,
+  // sed -i
+  /\bperl\s+(?:-\w+\s+)*-i\b/,
+  // perl -i
+  /\bwrite_text\s*\(/,
+  // python: Path(...).write_text(...)
+  /\bwriteFileSync\s*\(/,
+  // node: fs.writeFileSync(...)
+  /\bopen\s*\([^)]*['"][wa]\+?['"]\s*\)/,
+  // python: open(path, "w")
+  /\btee\s+(?!-a\b)/
+  // tee <file>
+];
+var REDIRECT = /(?:^|[^0-9<>&])>>?\s*(?!\/dev\/|\/tmp\/|&)([A-Za-z0-9_./-]*\.[A-Za-z0-9]+)/;
+function leavesWorkdir(command, cwd) {
+  const base = resolve5(cwd);
+  let at = base;
+  for (const seg of command.split(/&&|\|\||;|\|/)) {
+    const m = /^\s*(?:cd|pushd)(?:\s+(.*))?$/.exec(seg.trim());
+    if (!m) continue;
+    const raw = (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
+    if (!raw || raw === "~" || raw === "$HOME" || raw.startsWith("~/")) return raw || "~";
+    if (raw === "-") return "-";
+    at = resolve5(at, raw);
+    if (at !== base && !at.startsWith(base + sep6)) return raw;
+  }
+  return void 0;
+}
+var DESTROYS_WORK = [
+  { re: /^reset\b[^]*\s--hard\b/, what: "reset --hard" },
+  { re: /^clean\b[^]*\s-\S*[fd]/, what: "clean -f/-d" },
+  { re: /^checkout\b[^]*\s--\s+(?:\.|-A|:\/)\s*$/, what: "checkout -- ." },
+  { re: /^restore\b[^]*\s(?:\.|-A|:\/)\s*$/, what: "restore ." }
+];
+function destroysWork(command) {
+  for (const seg of command.split(/&&|\|\||;|\|/)) {
+    const m = /^\s*git\s+(.*)$/.exec(seg.trim());
+    if (!m) continue;
+    const rest = (m[1] ?? "").replace(/^(?:-\S+\s+)*/, "").trim();
+    const hit = DESTROYS_WORK.find((d) => d.re.test(rest));
+    if (hit) return hit.what;
+  }
+  return void 0;
+}
+function rewritesAFile(command) {
+  for (const re of REWRITES) if (re.test(command)) return re.source;
+  const m = REDIRECT.exec(command);
+  return m ? `redirect into ${m[1]}` : void 0;
+}
+var shellTool = {
+  name: "shell",
+  description: "Runs a shell command (in the cwd context). Returns stdout+stderr and the exit code. Runs NON-INTERACTIVELY (stdin is closed) \u2014 pass non-interactive flags (e.g. --yes, --no-input) or the command will fail rather than wait for input. Killed after `timeout` ms (default 120000, max 600000); do not start long-running watchers or dev servers. To CHANGE a file use `edit_file` or `write_file` \u2014 rewriting one from here (sed -i, a python heredoc, a redirect) is refused: those tools report what changed, and this one cannot.",
+  permissionLevel: "exec",
+  parameters: params8,
+  describe(rawArgs) {
+    const a = params8.parse(rawArgs);
+    return { allowKey: a.command, preview: a.command };
+  },
+  run(rawArgs, ctx) {
+    const parsed = params8.safeParse(rawArgs);
+    const why = parsed.success ? rewritesAFile(parsed.data.command) : void 0;
+    if (why !== void 0) {
+      return Promise.resolve({
+        content: `shell: this command rewrites a file (${why}). Use \`edit_file\` to change part of one, or \`write_file\` to replace it \u2014 they report exactly what changed, so you do not have to read the file back afterwards to find out. Reading, searching and running things are still fine here.`,
+        isError: true
+      });
+    }
+    if (!parsed.success) {
+      return Promise.resolve({
+        content: `shell: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`,
+        isError: true
+      });
+    }
+    const wipes = parsed.success ? destroysWork(parsed.data.command) : void 0;
+    if (wipes !== void 0) {
+      return Promise.resolve({
+        content: `shell: \`git ${wipes}\` throws away uncommitted work wholesale, and the \`git\` tool refuses it for that reason \u2014 running it here goes around the same rule. Every file you write is already committed as a \`wip(\u2026)\` checkpoint, so undo by going back to one of those, or revert a NAMED path (\`git checkout -- path/to/file\`), which says in the transcript what was undone.`,
+        isError: true
+      });
+    }
+    const away = leavesWorkdir(parsed.data.command, ctx.cwd);
+    if (away !== void 0) {
+      return Promise.resolve({
+        content: `shell: \`cd ${away}\` leaves this session's working directory. You are in \`${ctx.cwd}\` and everything this task does belongs here \u2014 another checkout of the same repository is someone else's working copy, and anything written there is invisible to the review of THIS change and left behind as clutter. Run the command from here (a \`cd\` into a subdirectory is fine), or point the tool at a path under this directory.`,
+        isError: true
+      });
+    }
+    const a = parsed.data;
+    return new Promise((resolvePromise) => {
+      let child;
+      try {
+        child = spawn(a.command, {
+          cwd: ctx.cwd,
+          shell: true,
+          signal: ctx.signal,
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: true
+        });
+      } catch (e) {
+        resolvePromise({
+          content: `shell error: ${e instanceof Error ? e.message : String(e)}`,
+          isError: true
+        });
+        return;
+      }
+      const budget = Math.min(a.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+      let out = "";
+      let err = "";
+      let timedOut = false;
+      let killer;
+      const killTree = (sig) => {
+        try {
+          if (child.pid) process.kill(-child.pid, sig);
+          else child.kill(sig);
+        } catch {
+          try {
+            child.kill(sig);
+          } catch {
+          }
+        }
+      };
+      const onAbort = () => killTree("SIGKILL");
+      ctx.signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        killTree("SIGTERM");
+        killer = setTimeout(() => killTree("SIGKILL"), KILL_GRACE_MS);
+        killer.unref?.();
+      }, budget);
+      timer.unref?.();
+      const done = () => {
+        clearTimeout(timer);
+        if (killer) clearTimeout(killer);
+        ctx.signal?.removeEventListener("abort", onAbort);
+      };
+      child.stdout?.on("data", (d) => out += d.toString());
+      child.stderr?.on("data", (d) => err += d.toString());
+      child.on("error", (e) => {
+        done();
+        resolvePromise({ content: `shell error: ${e.message}`, isError: true });
+      });
+      child.on("close", (code) => {
+        done();
+        const body = clampOutput([out, err].filter((s) => s.length).join("\n").trimEnd());
+        const tail = timedOut ? `
+(killed after ${Math.round(budget / 1e3)}s \u2014 it was still running. Use a non-interactive, terminating command; do not start watchers or dev servers.)` : `
+(exit ${code ?? "null"})`;
+        resolvePromise({ content: `$ ${a.command}
+${body}${tail}`, isError: timedOut || code !== 0 });
+      });
+    });
+  }
+};
+
+// src/tools/web.ts
+import { z as z12 } from "zod";
+var params9 = z12.object({ url: z12.string().url() });
+var MAX_CHARS = 1e5;
+function createWebFetchTool(fetchFn = globalThis.fetch) {
+  return {
+    name: "web_fetch",
+    description: "Fetches the content (text) of a URL.",
+    permissionLevel: "safe",
+    parameters: params9,
+    async run(rawArgs, ctx) {
+      const parsed = params9.safeParse(rawArgs);
+      if (!parsed.success) {
+        return {
+          content: `web_fetch: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`,
+          isError: true
+        };
+      }
+      const a = parsed.data;
+      try {
+        const res = await fetchFn(a.url, { signal: ctx.signal });
+        const text = await res.text();
+        const capped = text.length > MAX_CHARS ? text.slice(0, MAX_CHARS) + "\n\u2026 (truncated)" : text;
+        return { content: capped, isError: !res.ok };
+      } catch (e) {
+        return {
+          content: `web_fetch error: ${e instanceof Error ? e.message : String(e)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+
+// src/engine/trace-refresh.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+var IRRELEVANT = /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml)$/;
+async function changedByMerge(git, cwd, before, after = "HEAD") {
+  if (!before) return [];
+  const r = await git(["diff", "--name-only", `${before}..${after}`], cwd);
+  if (r.code !== 0) return [];
+  return r.stdout.split("\n").map((l) => l.trim()).filter((l) => l && !IRRELEVANT.test(l));
+}
+async function refreshAfterChange(opts) {
+  if (!opts.files.length) return;
+  try {
+    const r = await refreshTraces({
+      cwd: opts.cwd,
+      files: opts.files,
+      provider: opts.provider,
+      models: opts.models,
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.note ? { note: opts.note } : {}
+    });
+    const line = describeRefresh(r);
+    if (line) opts.note?.(line);
+    await commitRefreshed(opts.git ?? defaultGitRunner, opts.cwd, traceRootRel());
+  } catch {
+  }
+}
+async function refreshTraces(opts) {
+  const out = { traced: 0, failed: 0, removed: 0, skipped: 0 };
+  const candidates = traceable(opts.files);
+  out.skipped = opts.files.length - candidates.length;
+  const gone = candidates.filter((f) => !existsSync7(join7(opts.cwd, f)));
+  if (gone.length) {
+    try {
+      const index = await loadTraceIndex(opts.cwd);
+      const kept = new Set(Object.keys(index.traces).filter((f) => !gone.includes(f)));
+      out.removed = (await pruneTraces(opts.cwd, kept, index)).length;
+      if (out.removed) await saveTraceIndex(opts.cwd, index);
+    } catch {
+    }
+  }
+  const targets = candidates.filter((f) => !gone.includes(f));
+  if (!targets.length) return out;
+  const model = opts.models.find(Boolean);
+  if (!model) return out;
+  try {
+    const g = await buildProjectGraph(opts.cwd);
+    out.graph = g.message;
+    out.staleNames = await pruneAreaNames(opts.cwd);
+    const plan = await planFor(opts.cwd, targets);
+    if (!plan.jobs.length) {
+      out.skipped += targets.length;
+      return out;
+    }
+    const res = await runTraces({
+      cwd: opts.cwd,
+      provider: opts.provider,
+      model,
+      plan,
+      // No liveFiles: this run knows only the files one task changed, and a pruner given that list would
+      // read every OTHER trace in the project as orphaned and delete it.
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    out.traced = res.written;
+    out.failed = res.failed.length;
+    out.skipped += res.upToDate;
+  } catch (e) {
+    opts.note?.(`Trace refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  return out;
+}
+function describeRefresh(r) {
+  if (!r.traced && !r.failed && !r.removed && !r.staleNames) return void 0;
+  const bits = [`\u{1F4DD} ${r.traced} trace(s) refreshed`];
+  if (r.removed) bits.push(`${r.removed} removed for deleted file(s)`);
+  if (r.staleNames) bits.push(`${r.staleNames} area name(s) dropped \u2014 the rebuild left them pointing at nothing`);
+  if (r.failed) bits.push(`${r.failed} failed`);
+  return `${bits.join(" \xB7 ")} \u2014 the changed files now describe themselves.`;
+}
+async function commitRefreshed(git, baseWorktree, traceRootRel2) {
+  const paths = [traceRootRel2, ...sharedDerived()].filter((p) => existsSync7(join7(baseWorktree, p)));
+  if (!paths.length) return false;
+  const add = await git(["add", "--", ...paths], baseWorktree);
+  if (add.code !== 0) return false;
+  const staged = await git(["diff", "--cached", "--quiet", "--", ...paths], baseWorktree);
+  if (staged.code === 0) return false;
+  const r = await git(["commit", "-m", "docs(traces): refresh for the files this task changed", "--", ...paths], baseWorktree);
+  return r.code === 0;
+}
+
+// src/engine/role-fitness.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname4 } from "path";
+var UNFIT_AFTER = 2;
+var UNFIT_RATE = 0.5;
+var key = (role, model) => `${role}\0${model}`;
+var RoleFitness = class {
+  constructor(path, now = () => Date.now()) {
+    this.path = path;
+    this.now = now;
+    if (path) this.load();
+  }
+  path;
+  now;
+  records = /* @__PURE__ */ new Map();
+  /**
+   * Records that a model failed to do a role's job — not that a call failed.
+   *
+   * The distinction is the whole point: a rate limit, a timeout or a network error says nothing about
+   * fitness and must never be recorded here. What belongs here is a model that answered without doing the
+   * work — prose instead of an implementation, prose instead of the structured result the role demands.
+   */
+  record(role, model, reason) {
+    if (!role || !model) return 0;
+    const k = key(role, model);
+    const prev = this.records.get(k);
+    const rec = {
+      role,
+      model,
+      strikes: (prev?.strikes ?? 0) + 1,
+      attempts: (prev?.attempts ?? 0) + 1,
+      reason: reason.slice(0, 120),
+      at: this.now()
+    };
+    this.records.set(k, rec);
+    this.save();
+    return rec.strikes;
+  }
+  /**
+   * Records that the model DID do the role's job.
+   *
+   * Without this the record only ever accumulates evidence against a model, and a model used a hundred times
+   * looks worse than one used twice. Successes are what make the failures mean something.
+   */
+  ok(role, model) {
+    if (!role || !model) return;
+    const k = key(role, model);
+    const prev = this.records.get(k);
+    this.records.set(k, {
+      role,
+      model,
+      strikes: prev?.strikes ?? 0,
+      attempts: (prev?.attempts ?? 0) + 1,
+      reason: prev?.reason ?? "",
+      at: this.now()
+    });
+    this.save();
+  }
+  /**
+   * True when this model has failed this role often enough, and often ENOUGH OF THE TIME, that assigning it
+   * again is a known mistake. Both tests must pass: a pattern, and a pattern that dominates.
+   */
+  unfit(role, model) {
+    const r = this.records.get(key(role, model));
+    if (!r || r.strikes < UNFIT_AFTER) return false;
+    return r.strikes / Math.max(r.attempts, 1) >= UNFIT_RATE;
+  }
+  /** Why a model is unfit for a role, for the line that tells the user. */
+  reasonFor(role, model) {
+    return this.unfit(role, model) ? this.records.get(key(role, model))?.reason : void 0;
+  }
+  /**
+   * Drops the models a role has already proven it cannot use — but never returns an empty list.
+   *
+   * A role with no model at all is a worse failure than a role with a bad one: the first stops the run, the
+   * second wastes an attempt and rotates. When everything available is unfit, the original order is returned
+   * unchanged and the caller carries on.
+   */
+  fitFor(role, models) {
+    const fit = models.filter((m) => !this.unfit(role, m));
+    return fit.length ? fit : models;
+  }
+  /** Everything recorded, worst first — for `/roles` and for explaining an assignment. */
+  list() {
+    return [...this.records.values()].sort((a, b) => b.strikes - a.strikes);
+  }
+  /** Forgets one pairing, or all of them — a model that was broken in March may be fine in June. */
+  clear(role, model) {
+    if (role && model) this.records.delete(key(role, model));
+    else this.records.clear();
+    this.save();
+  }
+  load() {
+    try {
+      const raw = JSON.parse(readFileSync3(this.path, "utf8"));
+      if (!Array.isArray(raw)) return;
+      for (const r of raw) {
+        if (r && typeof r.role === "string" && typeof r.model === "string" && typeof r.strikes === "number") {
+          this.records.set(key(r.role, r.model), { ...r, attempts: r.attempts ?? r.strikes });
+        }
+      }
+    } catch {
+    }
+  }
+  save() {
+    if (!this.path) return;
+    try {
+      mkdirSync3(dirname4(this.path), { recursive: true });
+      writeFileSync2(this.path, JSON.stringify(this.list(), null, 2), "utf8");
+    } catch {
+    }
+  }
+};
+
+// src/engine/routing.ts
+import { z as z13 } from "zod";
+
+// src/engine/route-role.ts
+var STYLE_EXT = [".css", ".scss", ".sass", ".less", ".styl"];
+var MARKUP_EXT = [".html", ".htm", ".svg", ".vue", ".svelte"];
+var COMPONENT_EXT = [".tsx", ".jsx"];
+var BACKEND_EXT = [".sql", ".prisma", ".proto", ".go", ".py", ".rb", ".php", ".java", ".rs", ".kt"];
+var BACKEND_DIR = ["server", "api", "backend", "db", "database", "migrations", "migration", "infra", "worker", "jobs"];
+var UI_DIR = ["ui", "components", "component", "views", "view", "pages", "page", "screens", "styles", "theme", "themes", "layouts", "widgets"];
+var DESIGN_WORDS = [
+  "style",
+  "styles",
+  "styling",
+  "theme",
+  "theming",
+  "layout",
+  "design",
+  "visual",
+  "visuals",
+  "animation",
+  "animate",
+  "transition",
+  "responsive",
+  "accessibility",
+  "a11y",
+  "color",
+  "colors",
+  "colour",
+  "typography",
+  "spacing",
+  "icon",
+  "icons",
+  "ui",
+  "ux",
+  "polish",
+  "palette",
+  "css"
+];
+var ext = (p) => {
+  const base = p.slice(p.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot).toLowerCase() : "";
+};
+var segments = (p) => p.toLowerCase().split(/[/\\]/).slice(0, -1);
+var words2 = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+function routeByEvidence(card) {
+  const files = card.files.map((f) => f.trim()).filter(Boolean);
+  const exts = files.map(ext);
+  const dirs = files.flatMap(segments);
+  const title = words2(card.title);
+  const hasStyle = exts.some((e) => STYLE_EXT.includes(e));
+  const hasMarkup = exts.some((e) => MARKUP_EXT.includes(e));
+  const hasComponent = exts.some((e) => COMPONENT_EXT.includes(e));
+  const hasUiDir = dirs.some((d) => UI_DIR.includes(d));
+  const designWord = title.find((w) => DESIGN_WORDS.includes(w));
+  const backend = exts.some((e) => BACKEND_EXT.includes(e)) || dirs.some((d) => BACKEND_DIR.includes(d));
+  if (!hasStyle && !hasMarkup && !hasComponent && !hasUiDir && !designWord) {
+    return { role: "coder", why: files.length ? "no interface work in its files or title" : "nothing about it is interface work" };
+  }
+  if ((hasStyle || hasMarkup || designWord) && !backend) {
+    const reason = hasStyle || hasMarkup ? `writes ${files.find((f) => STYLE_EXT.includes(ext(f)) || MARKUP_EXT.includes(ext(f)))}` : `"${designWord}" is the work`;
+    return { role: "designer", why: reason };
+  }
+  return { why: hasComponent && !hasStyle && !hasMarkup ? "component files could be either" : "the evidence points both ways" };
+}
+
+// src/agent/deadline.ts
+function withDeadline(work, signal, message) {
+  work.catch(() => {
+  });
+  return Promise.race([work, expired(signal, message)]);
+}
+function expired(signal, message) {
+  return new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(new Error(message));
+      return;
+    }
+    signal.addEventListener("abort", () => reject(new Error(message)), { once: true });
+  });
+}
+var SHORT_CALL_MS = 3 * 60 * 1e3;
+var LONG_CALL_MS = 15 * 60 * 1e3;
+
+// src/engine/routing.ts
+var RouteSchema = z13.object({
+  role: z13.enum(["coder", "designer"]).describe(
+    "Who should implement this. `designer` when the work IS how the thing looks or behaves to a person \u2014 layout, spacing, colour, copy, interaction. `coder` for everything else. Judge by what the work is, not by the file type: a component file holding a data hook is code work; a component file whose whole job is appearance is design work."
+  )
+});
+async function routeTask(deps, task) {
+  const evidence = routeByEvidence(task);
+  telemetry().event("decision.route", {
+    "hc.decision": "route",
+    "hc.task.id": task.id,
+    "hc.role": evidence.role,
+    "hc.route.why": evidence.why,
+    "hc.route.by": evidence.role ? "evidence" : "model"
+  });
+  if (evidence.role) return evidence.role;
+  try {
+    const resolved = deps.roleRegistry.resolve("router");
+    const tools = new ToolRegistry();
+    tools.register(buildSkillTool(deps.skillRegistry));
+    const opts = {
+      provider: deps.provider,
+      ...resolved,
+      tools,
+      messages: [
+        { role: "user", content: `Task: "${task.title}"
+` + (task.files.length ? `Files it writes: ${task.files.join(", ")}
+` : "") + (task.acceptance.length ? `Done when: ${task.acceptance.join("; ")}
+` : "") + `
+Is this UI/UX work (designer) or code work (coder)? Judge by what the work IS, not by the file types: a component file holding a data hook is code work, and a component file whose whole job is how the thing looks is design work.` }
+      ],
+      permission: deps.permission,
+      approve: deps.approve,
+      cwd: "/",
+      signal: deps.signal,
+      perAttemptMs: SHORT_CALL_MS,
+      // each model in the chain gets its own clock — see RoleAgentOptions
+      // One question, one answer, from the text in front of it. Nothing here is worth a fifty-turn budget —
+      // and an unbounded structured role walks its entire fallback chain when a model will not submit.
+      maxTurns: 3
+    };
+    const { role } = await runStructuredRole(opts, RouteSchema);
+    return role;
+  } catch (e) {
+    if (deps.signal.aborted) throw e;
+    return "coder";
+  }
+}
+
+// src/tools/index.ts
+function createDefaultRegistry() {
+  const reg = new ToolRegistry();
+  reg.register(readFileTool);
+  reg.register(writeFileTool);
+  reg.register(editFileTool);
+  reg.register(grepTool);
+  reg.register(globTool);
+  reg.register(gitTool);
+  reg.register(shellTool);
+  reg.register(createWebFetchTool());
+  return reg;
+}
+
+// src/engine/operational.ts
+import { z as z14 } from "zod";
+var CommitSchema = z14.object({
+  message: z14.string().describe("A Conventional Commits message: `type(scope): subject`, English, imperative.")
+});
+var MAX_DIFF = 12e3;
+var OPERATIONAL_MAX_TURNS = 3;
+async function runOperational(deps, diff, context) {
+  const clipped = diff.length > MAX_DIFF ? `${diff.slice(0, MAX_DIFF)}
+\u2026 (diff truncated)` : diff;
+  const resolved = deps.roleRegistry.resolve("operational");
+  const out = await runStructuredRole({
+    provider: deps.provider,
+    ...resolved,
+    tools: new ToolRegistry(),
+    messages: [{ role: "user", content: `Context: ${context}
+
+Git diff of the work just completed:
+
+${clipped}
+
+Write the commit message.` }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: ".",
+    signal: deps.signal,
+    perAttemptMs: SHORT_CALL_MS,
+    // each model in the chain gets its own clock — see RoleAgentOptions
+    totalMs: SHORT_CALL_MS * 2,
+    // …and the whole chain cannot outlast the sentence it is writing
+    // One sentence from a diff it was handed. Uncapped, a model that would not call `submit` walked its whole
+    // fallback chain at fifty turns an attempt — to phrase a commit message.
+    maxTurns: OPERATIONAL_MAX_TURNS
+  }, CommitSchema);
+  return out.message.trim();
+}
+function fileCommitMessage(path) {
+  const p = path.replace(/\\/g, "/");
+  const type = /(^|\/)(test|tests|spec|__tests__)\//.test(p) || /\.(spec|test)\.[a-z]+$/.test(p) ? "test" : /\.(md|mdx|txt|rst)$/i.test(p) ? "docs" : /(^|\/)(package\.json|tsconfig[^/]*\.json|angular\.json|vite\.config|.*\.config\.[a-z]+)$/i.test(p) ? "build" : "chore";
+  const dir = p.includes("/") ? p.slice(0, p.lastIndexOf("/")).split("/").filter((x) => x !== "src").pop() : "";
+  return `wip(${type}${dir ? `/${dir}` : ""}): ${p.slice(p.lastIndexOf("/") + 1)}`;
+}
+var SCRATCH_RE = /(^|\/|\.)(tmp|scratch|repro|sandbox)\.|[-_.](tmp|scratch|repro)\.[a-z]+$/i;
+function isScratch(path) {
+  return SCRATCH_RE.test(path.split("/").pop() ?? path);
+}
+async function commitFile(deps, workdir, path, git = defaultGitRunner) {
+  if (writableStateRoot(workdir) === void 0) return void 0;
+  if (isScratch(path)) return void 0;
+  await git(["add", "--", path], workdir);
+  const staged = await git(["diff", "--cached", "--quiet", "--", path], workdir);
+  if (staged.code === 0) return void 0;
+  const message = fileCommitMessage(path);
+  const res = await git(["commit", "-m", message, "--", path], workdir);
+  if (res.code !== 0) return void 0;
+  return message;
+}
+async function commitStep(deps, workdir, context, git = defaultGitRunner) {
+  await git(["add", "-A"], workdir);
+  const dirty = await git(["diff", "--cached", "--name-only"], workdir);
+  const scratch = dirty.stdout.split("\n").map((l) => l.trim()).filter((l) => l && isScratch(l));
+  if (scratch.length) await git(["reset", "--quiet", "--", ...scratch], workdir);
+  const staged = await git(["diff", "--cached", "--quiet"], workdir);
+  if (staged.code === 0) return void 0;
+  const diff = await git(["diff", "--cached"], workdir);
+  let message;
+  try {
+    message = await runOperational(deps, diff.stdout, context);
+  } catch {
+    message = `chore: ${context}`;
+  }
+  const res = await git(["commit", "-m", message], workdir);
+  if (res.code !== 0) return void 0;
+  deps.note?.(`\u{1F516} ${message}`);
+  return message;
+}
+async function squashTask(deps, worktree, baseRef, title, git = defaultGitRunner) {
+  const fork = await git(["merge-base", "HEAD", baseRef], worktree);
+  if (fork.code !== 0) return void 0;
+  const at = fork.stdout.trim();
+  if (!at) return void 0;
+  const aheadOut = await git(["rev-list", "--count", `${at}..HEAD`], worktree);
+  const ahead = Number(aheadOut.stdout.trim() || "0");
+  if (ahead < 1) return void 0;
+  const diff = await git(["diff", `${at}..HEAD`], worktree);
+  if (!diff.stdout.trim()) return void 0;
+  let message;
+  try {
+    message = await runOperational(deps, diff.stdout, `completed the task: ${title}`);
+  } catch {
+    message = `chore: ${title}`;
+  }
+  const reset = await git(["reset", "--soft", at], worktree);
+  if (reset.code !== 0) return void 0;
+  const res = await git(["commit", "-m", message], worktree);
+  if (res.code !== 0) return void 0;
+  deps.note?.(`\u{1F4E6} **${message}**${ahead ? ` \u2014 ${ahead} checkpoint(s) squashed` : ""}`);
+  return message;
+}
+
+// src/skills/adjudicate.ts
+async function adjudicateSkills(opts) {
+  const { confident, borderline } = partitionByConfidence(opts.matches, opts.bar, opts.margin);
+  if (!borderline.length) return { keep: confident, asked: false };
+  const described = borderline.map((m) => `- ${m.name}: ${opts.registry.get(m.name)?.description ?? "(no description)"}`).join("\n");
+  const systemPrompt = `Decide which of these skills, if any, genuinely apply to one development task.
+
+A skill is a document inlined into the agent's instructions: whatever it says, the agent will do. So a skill on the wrong task is worse than no skill \u2014 the agent will follow it.
+
+Judge by whether the task IS the kind of work the skill is for, not by whether they share words. "Implement store CRUD methods" mentions components and state, but it is data-layer work, not interface design. Rejecting all of them is a normal and frequent answer.
+
+Task: ${opts.task}
+
+Candidates:
+${described}
+
+Answer with a fenced \`\`\`json block: {"keep":["<skill name>", \u2026]} \u2014 an empty list if none apply. One short sentence of reasoning before it.`;
+  try {
+    const req = {
+      model: opts.model,
+      messages: [
+        { role: "system", content: "You decide whether a skill applies to a task. You reject far more often than you accept." },
+        { role: "user", content: systemPrompt }
+      ],
+      tools: []
+    };
+    let full = "";
+    for await (const ev of opts.provider.chat(req, opts.signal ?? new AbortController().signal)) {
+      if (ev.type === "text-delta") full += ev.text;
+      else if (ev.type === "error") throw new Error(ev.message);
+    }
+    const keep = parseKeep(full);
+    if (!keep) throw new Error("unparseable verdict");
+    const kept = borderline.filter((m) => keep.includes(m.name));
+    return {
+      keep: [...confident, ...kept],
+      asked: true,
+      reasoning: full.split("```")[0].replace(/<\/?think>/gi, "").trim().slice(0, 200)
+    };
+  } catch {
+    return { keep: opts.matches, asked: false };
+  }
+}
+function parseKeep(text) {
+  const fence = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
+  const raw = fence ? fence[1] : text.slice(text.indexOf("{"));
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.keep) ? parsed.keep.filter((k) => typeof k === "string") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/engine/implementer.ts
+var IMPLEMENTER_MAX_TURNS = 200;
+var WHAT_IT_COST = "Before you stop: did anything here cost you more than one attempt \u2014 a command that had to be invoked a particular way, a file that was not where it should have been, a trap you fell into? If you have not already recorded it with `remember_fact`, do that now. The next agent pays for it again otherwise.";
+var IMPLEMENTER_TIMEOUT_MS = 20 * 60 * 1e3;
+var MAX_BUDGET_EXTENSIONS = 2;
+function attemptBudget(task, baseMs) {
+  let deaths = 0;
+  for (let i = task.stageHistory.length - 1; i >= 0 && deaths < MAX_BUDGET_EXTENSIONS; i--) {
+    const e = task.stageHistory[i];
+    if (e.action === "attempt-error") {
+      if (!/budget/i.test(e.note ?? "")) break;
+      deaths += 1;
+      continue;
+    }
+    if (e.action === "reviewed:fail" || e.action === "acceptance:failed" || e.action === "no-changes") break;
+  }
+  return baseMs * (1 + deaths);
+}
+var DEADLINE_WARNING_AT = 0.75;
+function deadlineWarning(elapsedMs, budgetMs) {
+  if (elapsedMs < budgetMs * DEADLINE_WARNING_AT) return void 0;
+  const left = Math.max(1, Math.round((budgetMs - elapsedMs) / 6e4));
+  return `You have about ${left} minute(s) of budget left for this attempt, and it will be stopped when they are gone. Finish and WRITE what you have now \u2014 a partial implementation that is on disk is kept and continued from; work still in your head is lost. Stop exploring.`;
+}
+var MAX_WRITTEN_CHARS = 6e4;
+async function writtenText(cwd, touched) {
+  const { readFile: readFile4 } = await import("fs/promises");
+  const { join: join10 } = await import("path");
+  const parts = [];
+  let used = 0;
+  for (const p of [...new Set(touched)]) {
+    if (used >= MAX_WRITTEN_CHARS) break;
+    try {
+      const t = await readFile4(join10(cwd, p), "utf8");
+      parts.push(t.slice(0, MAX_WRITTEN_CHARS - used));
+      used += t.length;
+    } catch {
+    }
+  }
+  return parts.join("\n");
+}
+async function runImplementer(deps, role, task, cwd, slot = 0) {
+  const resolved = deps.roleRegistry.resolve(role);
+  const chain = deps.roleRegistry.chainFor(role, slot);
+  const tok = { promptTokens: 0, completionTokens: 0 };
+  let serving = chain[0] ?? "";
+  const tools = createDefaultRegistry();
+  tools.register(buildSkillTool(deps.skillRegistry));
+  for (const t of contextTools(deps)) tools.register(t);
+  tools.register(buildRememberTool(deps.rememberFact));
+  const returning = task.reviewNotes.length > 0;
+  const brief = [
+    task.acceptance.length ? `It is done when ALL of these are true \u2014 they are exactly what the review will check:
+` + task.acceptance.map((a) => `- ${a}`).join("\n") : "",
+    task.files.length ? `The plan expects this task to create or change these files:
+${task.files.map((f) => `- ${f}`).join("\n")}
+Start there. Touch anything else the work genuinely needs \u2014 this is where the plan expected the change to live, not a limit on it.` : ""
+  ].filter(Boolean).join("\n\n");
+  const hygiene = `Your whole diff is what the review judges. Before you finish: undo anything you changed for your OWN convenience \u2014 a test config narrowed to one spec, a widened timeout, a disabled lint rule \u2014 and delete any scratch, repro or debug file you made. Leaving them in fails the review even when the work is right.`;
+  const handOver = `When you stop you are HANDING the change over \u2014 to a review and an acceptance check that have not run yet. So close with what you changed and what you ran, and leave the verdict to them: do not write that the task is complete, done or finished. Whether it is, is not yours to say, and saying it is how a card reads "complete" above a review that rejects it.
+
+${WHAT_IT_COST}
+
+Staging, committing and branches are this tool's business, never the developer's: do not end by asking them to \`git add\`, commit, or tidy the tree. Ask them only for what nobody else can do \u2014 look at a screen, start an environment, decide something. If a file you wrote is not in git yet, that is a fault to report, not an errand to hand over.`;
+  const content = (returning ? `This is a RETURNING task: "${task.title}". Address the reviewer notes:
+${task.reviewNotes.map((n) => `- ${n}`).join("\n")}` : `This is a NEW task: "${task.title}". Implement it.`) + (brief ? `
+
+${brief}` : "") + `
+
+${hygiene}
+
+${handOver}`;
+  const hints = memoryHints(deps, `${task.title} ${task.reviewNotes.join(" ")}`, { role, operations: true });
+  const touched = [];
+  const attached = deps.roleRegistry.skillsFor(role);
+  const subject = `${task.title} ${task.acceptance.join(" ")} ${task.reviewNotes.join(" ")}`;
+  const routed = routeSkills(subject, deps.skillRegistry, attached, {
+    role,
+    implementing: true,
+    /**
+     * The files the PLAN named, when it named any.
+     *
+     * Inference is a fallback, not the first answer: resolving a task's words against the whole graph returns
+     * whatever happens to contain those words, and those paths are then treated as evidence about what kind
+     * of work this is. Measured live — "fix product description rendering" resolved to `ShopifyService.cs`,
+     * `n11/OrderMapper.cs` and `ExcelTableRenderer.cs`, because marketplace integrators are full of symbols
+     * called product and description, and the brainstormer was handed `azure-kubernetes` for it.
+     *
+     * A card's own file list came from a plan a person approved. It outranks a guess.
+     */
+    /**
+     * Only files someone NAMED, never a guess.
+     *
+     * Resolving a task's words against the graph was measured over real commit history: on the integration
+     * project this runs against, 131 samples, an answer produced for 130 of them, and 9% of those files
+     * correct. The domain is the reason: "product", "description", "order" name symbols in every marketplace
+     * integrator there is, so the words that describe a task resolve to all of them.
+     *
+     * Confident and wrong is the worst kind of evidence, because it reads as knowledge. Without it the router
+     * falls back to the task's own text, which is honest about knowing less.
+     */
+    files: task.files,
+    placed: placedSkills()
+  });
+  const verdict = routed.length ? await adjudicateSkills({
+    provider: deps.provider,
+    model: chain[0] ?? "",
+    task: subject,
+    matches: routed,
+    registry: deps.skillRegistry,
+    signal: deps.signal
+  }) : { keep: routed, asked: false, reasoning: void 0 };
+  const kept = verdict.keep;
+  if (kept.length) {
+    deps.note?.(`\u{1F4CE} \`${role}\` \xB7 ${kept.map((m) => `**${m.name}**`).join(", ")}${verdict.asked ? " _(adjudicated)_" : ""}`);
+  } else if (routed.length && verdict.asked) {
+    deps.note?.(`\u{1F4CE} \`${role}\` \xB7 **no skill applied** \u2014 considered ${routed.map((m) => m.name).join(", ")}: ${verdict.reasoning ?? "none of them fit this task"}`);
+  }
+  const withSkills = kept.length ? applySkills(resolved.systemPrompt, kept.map((m) => m.name), deps.skillRegistry) : resolved.systemPrompt;
+  const law = deps.home ? await constitutionNote(
+    { ...deps, home: deps.home, note: deps.note },
+    cwd,
+    { role, files: task.files, title: task.title }
+  ) : "";
+  const systemPrompt = withSkills + law + projectToolsNote(tools.list(), !!loadGraphSync(cwd)) + BATCH_TOOLS_NOTE;
+  const budgetMs = attemptBudget(task, deps.implementerTimeoutMs ?? IMPLEMENTER_TIMEOUT_MS);
+  const budget = AbortSignal.timeout(budgetMs);
+  let warned = false;
+  const startedAt = Date.now();
+  const deadlineNote = () => {
+    if (warned) return void 0;
+    const note = deadlineWarning(Date.now() - startedAt, budgetMs);
+    if (note) warned = true;
+    return note;
+  };
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    systemPrompt,
+    ...chain.length ? { model: chain[0], fallbacks: chain.slice(1) } : {},
+    tools,
+    maxTurns: IMPLEMENTER_MAX_TURNS,
+    /**
+     * A screenshot named in the task comes with it.
+     *
+     * A card built from a small request or from a finding carries the user's own words, and those words can
+     * name the picture that shows the problem. Without this the implementer gets a path and the only thing it
+     * can do with one is `read_file`, which cannot read a PNG.
+     */
+    messages: (hints.message ? [{ role: "user", content: hints.message }] : []).concat([
+      { role: "user", ...handedOver(content, cwd) }
+    ]),
+    onUsage: (u) => {
+      tok.promptTokens += u.promptTokens;
+      tok.completionTokens += u.completionTokens;
+      if (u.model && u.model !== serving) {
+        serving = u.model;
+        deps.onProgress?.({ kind: "agent-model", id: task.id, model: serving });
+      }
+      deps.onProgress?.({ kind: "agent-usage", id: task.id, ...tok });
+    },
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd,
+    // The agent's own inbox first (a by-the-way note), then the deadline warning when it is due.
+    inbox: () => deps.inbox?.() ?? deadlineNote(),
+    signal: AbortSignal.any([deps.signal, budget]),
+    // Stamped with the card id: the agent panel is keyed by it, and unattributed activity goes to the chat.
+    onActivity: deps.onActivity ? (a) => deps.onActivity?.({ ...a, agent: task.id }) : void 0,
+    /**
+     * Attributed by ID, not by title.
+     *
+     * A wave runs several implementers at once, so unattributed prose interleaves into something no one can
+     * read — that much was right. Using the task's TITLE for it was not: one agent narrating fifteen times
+     * printed the same forty-word title fifteen times, and the user reported it as the tool "saying the same
+     * thing over and over". They were reading it correctly; two thirds of every line WAS the same.
+     *
+     * The id is unique, it is what the board and the agent panel already show, and it leaves the line to the
+     * sentence that differs.
+     */
+    ...deps.note ? { onSay: (t) => deps.note?.(`  \u21B3 **${role}** \`${task.id}\` ${t}`) } : {},
+    onLiveActivity: deps.onLiveActivity,
+    onWrite: (path) => {
+      touched.push(path);
+      return commitFile(deps, cwd, path).then(() => {
+      });
+    }
+  };
+  const mins = Math.round(budgetMs / 6e4);
+  const baseMins = Math.round((deps.implementerTimeoutMs ?? IMPLEMENTER_TIMEOUT_MS) / 6e4);
+  if (mins > baseMins) {
+    deps.note?.(`\u23F3 **${task.title}** ran out of time, not out of ideas \u2014 this attempt gets ${mins} minutes.`);
+  }
+  const overran = `the implementer ran past its ${mins}-minute budget for a single attempt and was stopped. Whatever it wrote is committed and kept \u2014 continue from there rather than starting over.`;
+  try {
+    const attempt = () => withDeadline(runToCompletion(opts), budget, overran);
+    const timed = () => deps.timings ? deps.timings.time("implementation", attempt) : attempt();
+    await telemetry().span("stage.implementation", {
+      "hc.stage": "implementation",
+      "hc.role": role,
+      "hc.task.id": task.id,
+      "hc.task.title": task.title.slice(0, 120),
+      "hc.model": chain[0],
+      "hc.attempt": task.attempts
+    }, timed);
+  } catch (e) {
+    if (deps.signal.aborted || !budget.aborted) throw e;
+    throw new Error(overran);
+  } finally {
+    reinforceTouched(deps, hints.ids, touched, role);
+    reinforceUsed(deps, hints.ids, await writtenText(cwd, touched), role);
+  }
+}
+
+// src/engine/review.ts
+import { existsSync as existsSync8 } from "fs";
+import { isAbsolute, join as join8 } from "path";
+import { z as z15 } from "zod";
+
+// 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);
+}
+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);
+  }
+  /**
+   * 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 key2 = role ? `${model}::${role}` : model;
+    const n = (this.strikes.get(key2) ?? 0) + 1;
+    this.strikes.set(key2, 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);
+    const k = c.length ? (slot % c.length + c.length) % c.length : 0;
+    return k === 0 ? c : [...c.slice(k), ...c.slice(0, k)];
+  }
+  /** 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) => this.markExhausted(m, reason ?? "unavailable"),
+      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/review.ts
+function asChoice(o) {
+  return typeof o === "string" ? { label: o } : o;
+}
+var AssessmentSchema = z15.object({
+  findings: z15.array(z15.object({
+    severity: z15.enum(["critical", "medium", "low"]).describe(
+      "`critical`: shipping it this way causes real harm \u2014 wrong behaviour, data loss, a security hole. `medium`: it should be fixed but nothing breaks if it ships. `low`: a preference or a tidy-up."
+    ),
+    note: z15.string()
+  })).default([]),
+  recommendation: z15.enum(["approve", "revise"]).describe(
+    "`revise` only if at least one finding must be addressed before this can ship; otherwise `approve` and leave the findings as notes. Findings you would not block on do not make it a revise."
+  )
+});
+function severityCounts(a) {
+  const c = { critical: 0, medium: 0, low: 0 };
+  for (const f of a.findings) c[f.severity]++;
+  return c;
+}
+function memberStatus(a) {
+  const c = severityCounts(a);
+  return `${a.recommendation === "approve" ? "APPROVE" : "REJECT"} \xB7 C:${c.critical} M:${c.medium} L:${c.low}`;
+}
+function findingNotes(assessments, stage, severities) {
+  return assessments.flatMap((a) => a.findings.filter((f) => severities.includes(f.severity)).map((f) => `[${stage}][${f.severity}] ${a.name}: ${f.note}`));
+}
+function nonBlockingNotes(assessments, stage) {
+  return findingNotes(assessments, stage, ["medium", "low"]);
+}
+function reviseBrief(findings, reasons) {
+  return [...findings, ...reasons.map((r) => `[decision] ${r}`)];
+}
+function voteReasons(votes) {
+  return votes.filter((v) => v.vote === "revise").map((v) => `${v.name}: ${v.rationale}`);
+}
+function blockingSignatures(assessments) {
+  const out = /* @__PURE__ */ new Set();
+  for (const a of assessments) for (const f of a.findings) {
+    if (f.severity === "critical") out.add(`${a.name}::${f.note.trim().toLowerCase().replace(/\s+/g, " ")}`);
+  }
+  return out;
+}
+function severityTotal(assessments, sev) {
+  return assessments.filter((a) => !a.unverified).reduce((n, a) => n + a.findings.filter((f) => f.severity === sev).length, 0);
+}
+var TEAM_MIN_COVERAGE = 0.6;
+function coverage(assessments) {
+  const unverified = assessments.filter((a) => a.unverified).length;
+  const verified = assessments.length - unverified;
+  return { verified, unverified, enough: !assessments.length || verified / assessments.length >= TEAM_MIN_COVERAGE };
+}
+var CouncilVoteSchema = z15.object({
+  vote: z15.enum(["pass", "revise"]).describe(
+    "`revise` only if something must change before this can ship. A concern you would not block on is a `pass` with the concern in the rationale."
+  ),
+  rationale: z15.string()
+});
+var JudgeSchema = z15.object({
+  decision: z15.enum(["pass", "revise", "ask-human"]).describe(
+    "`pass`: it can ship. `revise`: it can be fixed from the feedback below, without anyone being asked. `ask-human` ONLY when the decision is genuinely not yours \u2014 the reviewers disagree on something a person owns, or the answer depends on intent nobody wrote down. It stops the run and costs someone their attention; do not use it for a call you can make."
+  ),
+  feedback: z15.array(z15.string()),
+  question: z15.string()
+});
+var STAGE_FRAMING = {
+  spec: `You are reviewing a SPECIFICATION: it states WHAT the product must do and WHY, written for business stakeholders. By design it MUST NOT contain implementation detail (languages, frameworks, APIs, storage mechanics, code structure) \u2014 those decisions belong to the LATER plan stage.
+OUT OF SCOPE here: implementation questions (which storage engine, how concurrency is handled, API shapes, libraries, performance tactics). Do NOT ask the spec to answer them and do NOT treat their absence as a defect \u2014 that is the plan's job. (The one exception is the abstraction-leak lens, which flags implementation detail that HAS leaked into the spec.)
+SEVERITY: "critical" = the spec contradicts itself, or a capability the user explicitly requested is missing or impossible as written. "medium" = a real ambiguity or gap that would likely cause the wrong thing to be built. "low" = wording/polish. "The spec does not specify <technical mechanism>" is NOT a finding.`,
+  plan: 'You are reviewing an IMPLEMENTATION PLAN: it states HOW the already-approved spec will be built (technical context, architecture, data model, contracts, project structure). This is the right place for technology and mechanism decisions.\nOUT OF SCOPE here: re-litigating WHAT the product should do (the spec is approved), and reviewing code that does not exist yet.\nSEVERITY: "critical" = the plan cannot deliver a specified requirement, or has a design flaw that would have to be undone later. "medium" = a design weakness worth fixing now. "low" = preference/polish.',
+  code: `You are reviewing CODE that implements one approved task.
+OUT OF SCOPE here: re-litigating the approved spec or plan, and demanding refactors beyond this task's scope.
+SEVERITY: "critical" = breaks correctness, security or data integrity, or the task's requirement is not actually implemented. "medium" = a real defect or risk worth fixing now. "low" = style/polish.`
+};
+var REVIEW_MAX_TURNS = 15;
+var REVIEW_TIMEOUT_MS = 3 * 60 * 1e3;
+function isDeadlineFailure(e) {
+  return /within its deadline|timed? ?out/i.test(e instanceof Error ? e.message : String(e));
+}
+function reviewerDeadlineMs(deps) {
+  return deps.reviewTimeoutMs ?? REVIEW_TIMEOUT_MS;
+}
+var SCOPE_RULE = "Scale your expectations to the REQUESTED scope: do not hold a small, simple product to enterprise-grade standards it never asked for. Demanding unrequested capability is itself a defect (scope creep), not a finding.";
+function teamPrompt(stage, perspective) {
+  return `You are a review TEAM member for the ${stage.toUpperCase()} stage. Your lens: ${perspective}.
+
+${STAGE_FRAMING[stage]}
+
+${SCOPE_RULE}
+
+Produce a list of findings \u2014 each with a severity ("critical"/"medium"/"low") and a concise note \u2014 plus a recommendation: "approve" (nothing blocking from your lens) or "revise". Report only genuine issues: an empty findings list with "approve" is the correct answer for work that is good enough for THIS stage. Write findings in ENGLISH \u2014 they are a technical review artifact, not a conversation with the user, so they stay English regardless of any conversational-language rule.`;
+}
+function councilPrompt(perspective) {
+  return `You are a member of the review COUNCIL \u2014 a small, senior decision panel. Your judgment lens: ${perspective}.
+
+You are given the work under review AND the review team's findings. Weigh them and cast a single vote: "pass" (ship it as-is for this stage) or "revise" (it needs changes first), with a concise rationale. Judge it against what was ASKED FOR and against what THIS stage is responsible for \u2014 a spec is not expected to answer implementation questions, and a plan is not expected to re-state requirements. Do not nitpick: vote "revise" only for issues that genuinely warrant another pass. ${SCOPE_RULE} Write the rationale in ENGLISH regardless of any conversational-language rule.`;
+}
+function buildReviewerRegistry(reviewers, prompt) {
+  const roles = {};
+  for (const r of reviewers) roles[r.name] = { models: r.models, systemPrompt: prompt(r.perspective) };
+  return new RoleRegistry(roles);
+}
+function buildTeamRegistry(stage, team) {
+  return buildReviewerRegistry(team, (p) => teamPrompt(stage, p));
+}
+function buildCouncilRegistry(council) {
+  return buildReviewerRegistry(council, councilPrompt);
+}
+function errText(e) {
+  const m = e instanceof Error ? e.message : String(e);
+  return m.length > 160 ? `${m.slice(0, 159)}\u2026` : m;
+}
+async function runWithHealing(deps, role, id, opts, schema, signal, emit) {
+  try {
+    return await runStructuredRole(opts, schema);
+  } catch (e) {
+    if (deps.signal.aborted || isDeadlineFailure(e) || !deps.rechainRole) throw e;
+    const chain = await deps.rechainRole(role, errText(e));
+    if (!chain?.length) throw e;
+    emit({ kind: "note", text: `\u{1F501} \`${role}\` lost its whole model chain \u2014 retrying on \`${chain[0]}\`.` });
+    emit({ kind: "agent-model", id, model: chain[0] });
+    return runStructuredRole({ ...opts, model: chain[0], fallbacks: chain.slice(1) }, schema);
+  }
+}
+async function runTeam(deps, stage, workdir, target, request, emit = () => {
+}, carried = []) {
+  const registry = deps.teamRegistries[stage];
+  const carriedByName = new Map(carried.map((a) => [a.name, a]));
+  const team = deps.teams[stage].filter((c) => !carriedByName.has(c.name));
+  if (carriedByName.size) {
+    emit({ kind: "note", text: `\u21A9\uFE0E ${carriedByName.size} lens(es) approved last round \u2014 carrying their verdict; re-reviewing ${team.length}.` });
+  }
+  const scope = request ? `
+
+The user's original request (the scope you must judge against):
+"""
+${request}
+"""` : "";
+  const what = stage === "code" ? `Review the code for ONE task: ${target}.
+The subject is THIS task's change and nothing else. Other tasks in the plan \u2014 including ones this change references, depends on, or leaves for later \u2014 are NOT your subject: each has its own card and its own review, and work that has not started yet is not a defect in this change. Judge whether what is here does THIS task correctly, and say nothing about what other tasks have not done.` : `Review the "${target}" document.`;
+  const diff = stage === "code" ? await changeUnderReview(deps, workdir) : "";
+  const evidence = stage === "code" ? `
+
+${describeDiff(diff)}` : "";
+  const query = `${stage} ${target} ${request ?? ""}`;
+  const hintsByLens = new Map(team.map((c) => [c.name, memoryHints(deps, query, { role: c.name, silent: true })]));
+  emit({ kind: "agents", agents: team.map((c) => ({ id: `team:${c.name}`, title: `team: ${c.name}`, model: registry.peekModel(c.name) })) });
+  emitBatchInjection(deps, `team:${stage}`, [...hintsByLens.values()]);
+  try {
+    const fresh = await Promise.all(
+      team.map(async (c) => {
+        const tok = { promptTokens: 0, completionTokens: 0 };
+        let resolved;
+        try {
+          resolved = registry.resolve(c.name);
+        } catch (e) {
+          emit({ kind: "agent-result", id: `team:${c.name}`, status: "\u26A0 UNVERIFIED (no model)" });
+          return { name: c.name, recommendation: "revise", findings: [{
+            severity: "critical",
+            note: `The "${c.name}" lens has no model assigned (${errText(e)}) \u2014 this dimension is UNVERIFIED. Run \`/roles adjust\` to give every review lens a model.`
+          }] };
+        }
+        const hints = hintsByLens.get(c.name);
+        const id = `team:${c.name}`;
+        let serving = registry.peekModel(c.name);
+        const ask = { role: "user", content: `${what} Evaluate it through your lens.${scope}${evidence}` };
+        const signal = deps.signal;
+        const opts = {
+          provider: deps.provider,
+          ...resolved,
+          // Fifteen lenses reading the same change, one file per turn each, is the same waste multiplied.
+          systemPrompt: resolved.systemPrompt + BATCH_TOOLS_NOTE,
+          tools: readOnlyRegistry(deps, { propose: true }),
+          // A slide down the chain is a visible event: rename the row, then let the registry's own note run.
+          onFallback: (from, to, why) => {
+            serving = to;
+            emit({ kind: "agent-model", id, model: to });
+            resolved.onFallback?.(from, to, why);
+          },
+          proposeMemory: (t, k) => deps.proposeMemory?.(t, k, c.name) ?? false,
+          messages: hints.message ? [{ role: "user", content: hints.message }, ask] : [ask],
+          permission: deps.permission,
+          approve: deps.approve,
+          cwd: workdir,
+          signal,
+          // Per MODEL, not once for the chain — see reviewerDeadlineMs.
+          perAttemptMs: reviewerDeadlineMs(deps),
+          maxTurns: REVIEW_MAX_TURNS,
+          // Stream the running total onto this member's row as each call lands — a row that shows only a
+          // ticking clock for minutes says nothing about what it is costing while it is still costing it.
+          onUsage: (u) => {
+            tok.promptTokens += u.promptTokens;
+            tok.completionTokens += u.completionTokens;
+            if (u.model && u.model !== serving) {
+              serving = u.model;
+              emit({ kind: "agent-model", id, model: serving });
+            }
+            emit({ kind: "agent-usage", id, ...tok });
+          }
+        };
+        try {
+          const r = await runWithHealing(deps, c.name, id, opts, AssessmentSchema, signal, emit);
+          const a = { name: c.name, findings: r.findings, recommendation: r.recommendation };
+          reinforceUsed(deps, hints.ids, r.findings.map((f) => f.note).join(" "), c.name);
+          emit({ kind: "agent-result", id: `team:${c.name}`, status: memberStatus(a), ...tok });
+          return a;
+        } catch (e) {
+          if (deps.signal.aborted) throw e;
+          const timedOut = isDeadlineFailure(e);
+          const why = timedOut ? `did not finish within its ${Math.round((deps.reviewTimeoutMs ?? REVIEW_TIMEOUT_MS) / 1e3)}s budget` : `every model in its chain failed \u2014 ${errText(e)}`;
+          emit({ kind: "agent-result", id: `team:${c.name}`, status: timedOut ? "\u26A0 UNVERIFIED (timed out)" : "\u26A0 UNVERIFIED (no response)", ...tok });
+          return { name: c.name, recommendation: "revise", unverified: true, findings: [{ severity: "critical", note: `The "${c.name}" lens could not complete its review (${why}) \u2014 this dimension is UNVERIFIED and must be re-checked.` }] };
+        }
+      })
+    );
+    return [...carried, ...fresh];
+  } finally {
+    emit({ kind: "agents", agents: [] });
+  }
+}
+function findingsDigest(assessments) {
+  return assessments.map((a) => {
+    const list = a.findings.map((f) => `[${f.severity}] ${f.note}`).join("; ") || "no findings";
+    return `- ${a.name} (${a.recommendation}): ${list}`;
+  }).join("\n");
+}
+function teamSummaryNote(assessments, label) {
+  const approve = assessments.filter((a) => a.recommendation === "approve").length;
+  const lines = assessments.map((a) => {
+    const c = severityCounts(a);
+    const counts = c.critical || c.medium || c.low ? ` \u2014 C:${c.critical} M:${c.medium} L:${c.low}` : "";
+    return `- \`${a.name}\` ${a.recommendation === "approve" ? "\u2713 APPROVE" : "\u2717 REJECT"}${counts}`;
+  }).join("\n");
+  return `**Team review of the ${label}** \u2014 ${approve}/${assessments.length} approve:
+${lines}`;
+}
+async function runCouncil(deps, stage, workdir, target, assessments, request, emit = () => {
+}, question = "blocking") {
+  const digest = findingsDigest(assessments);
+  const scope = request ? `
+
+The user's original request:
+"""
+${request}
+"""` : "";
+  const subject = stage === "code" ? `the code for: ${target}` : `the "${target}" ${stage}`;
+  const councilDiff = stage === "code" ? await changeUnderReview(deps, workdir) : "";
+  const councilEvidence = stage === "code" ? `
+
+${describeDiff(councilDiff)}` : "";
+  const ask = question === "deferral" ? `
+
+NOTE: this work has ALREADY been revised once and NO critical findings remain \u2014 only medium/low ones. Decide: vote "pass" to hand it to the next stage and DEFER those findings (they are recorded and carried forward, not dropped), or vote "revise" ONLY if one of them would genuinely cause the wrong thing to be built or shipped despite its label. Wanting it clearer, tighter or more complete is NOT a reason to revise.` : "";
+  const hintsByMember = new Map(deps.council.map((c) => [c.name, memoryHints(deps, `${stage} ${target} ${request ?? ""}`, { role: c.name, silent: true })]));
+  emit({ kind: "agents", agents: deps.council.map((c) => ({ id: `council:${c.name}`, title: `council: ${c.name}`, model: deps.councilRegistry.peekModel(c.name) })) });
+  emitBatchInjection(deps, "council", [...hintsByMember.values()]);
+  try {
+    const results = await Promise.all(
+      deps.council.map(async (c) => {
+        const tok = { promptTokens: 0, completionTokens: 0 };
+        let resolved;
+        try {
+          resolved = deps.councilRegistry.resolve(c.name);
+        } catch (e) {
+          emit({ kind: "agent-result", id: `council:${c.name}`, status: "\u26A0 UNVERIFIED (no model)" });
+          return {
+            name: c.name,
+            vote: "revise",
+            rationale: `The "${c.name}" decider has no model assigned (${errText(e)}) \u2014 counted as revise to be safe.`
+          };
+        }
+        const hints = hintsByMember.get(c.name);
+        const id = `council:${c.name}`;
+        let serving = deps.councilRegistry.peekModel(c.name);
+        const vote = { role: "user", content: `You are reviewing ${subject} (the ${stage} stage), plus the team's findings:
+${digest}${scope}${ask}${councilEvidence}
+
+Cast your vote (pass/revise) with a rationale.` };
+        const signal = deps.signal;
+        const opts = {
+          provider: deps.provider,
+          ...resolved,
+          // Fifteen lenses reading the same change, one file per turn each, is the same waste multiplied.
+          systemPrompt: resolved.systemPrompt + BATCH_TOOLS_NOTE,
+          tools: readOnlyRegistry(deps, { propose: true }),
+          // A slide down the chain is a visible event: rename the row, then let the registry's own note run.
+          onFallback: (from, to, why) => {
+            serving = to;
+            emit({ kind: "agent-model", id, model: to });
+            resolved.onFallback?.(from, to, why);
+          },
+          proposeMemory: (t, k) => deps.proposeMemory?.(t, k, c.name) ?? false,
+          messages: hints.message ? [{ role: "user", content: hints.message }, vote] : [vote],
+          permission: deps.permission,
+          approve: deps.approve,
+          cwd: workdir,
+          signal,
+          // Per MODEL, not once for the chain — see reviewerDeadlineMs.
+          perAttemptMs: reviewerDeadlineMs(deps),
+          maxTurns: REVIEW_MAX_TURNS,
+          // Stream the running total onto this member's row as each call lands — a row that shows only a
+          // ticking clock for minutes says nothing about what it is costing while it is still costing it.
+          onUsage: (u) => {
+            tok.promptTokens += u.promptTokens;
+            tok.completionTokens += u.completionTokens;
+            if (u.model && u.model !== serving) {
+              serving = u.model;
+              emit({ kind: "agent-model", id, model: serving });
+            }
+            emit({ kind: "agent-usage", id, ...tok });
+          }
+        };
+        try {
+          const r = await runWithHealing(deps, c.name, id, opts, CouncilVoteSchema, signal, emit);
+          reinforceUsed(deps, hints.ids, r.rationale, c.name);
+          emit({ kind: "agent-result", id: `council:${c.name}`, status: r.vote === "pass" ? "PASS" : "REVISE", ...tok });
+          return { name: c.name, vote: r.vote, rationale: r.rationale };
+        } catch (e) {
+          if (deps.signal.aborted) throw e;
+          const timedOut = isDeadlineFailure(e);
+          emit({ kind: "agent-result", id: `council:${c.name}`, status: timedOut ? "\u26A0 UNVERIFIED (timed out)" : "\u26A0 UNVERIFIED (no response)", ...tok });
+          return { name: c.name, vote: "revise", rationale: `The "${c.name}" decider could not vote (${timedOut ? "timed out" : `chain failed \u2014 ${errText(e)}`}) \u2014 counted as revise to be safe.` };
+        }
+      })
+    );
+    return results;
+  } finally {
+    emit({ kind: "agents", agents: [] });
+  }
+}
+async function runJudge(deps, stage, workdir, target, assessments, votes, request, emit = () => {
+}, question = "contested", rounds = 0) {
+  const resolved = deps.roleRegistry.resolve("judge");
+  const findings = findingsDigest(assessments);
+  const council = votes.map((v) => `- ${v.name}: ${v.vote} \u2014 ${v.rationale}`).join("\n");
+  const subject = stage === "code" ? `The code for "${target}"` : `The "${target}" ${stage}`;
+  const ask = question === "final" ? `This review is STUCK: ${rounds} revision round(s) have run and the same blocking findings keep surviving, or the round budget is spent. You are the LAST authority before the user is involved.
+Rule decisively:
+- "pass" \u2014 the work is good enough for THIS stage; remaining findings are not real blockers (preferred if true).
+- "revise" \u2014 one more TARGETED attempt is genuinely worth it; say exactly what must change.
+- "ask-human" \u2014 ONLY if the blocker is a product/scope decision that you cannot make on the user's behalf. Difficulty, reviewer disagreement or a desire for more polish are NOT reasons to ask the user.` : `You are the final decider on this contested round. Judge it against what was asked for and against what THIS stage is responsible for (a spec answers WHAT/WHY, a plan answers HOW, code is the implementation). Decide (pass/revise/ask-human).`;
+  const hints = memoryHints(deps, `${stage} ${target} ${request ?? ""}`, { role: "judge" });
+  const brief = { role: "user", content: `${subject} is contested (the ${stage} review stage).${request ? `
+
+The user's original request:
+"""
+${request}
+"""` : ""}
+
+The review team's findings:
+${findings}
+
+The council's votes:
+${council}
+
+${ask}` };
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools: readOnlyRegistry(deps, { propose: true }),
+    proposeMemory: (t, k) => deps.proposeMemory?.(t, k, "judge") ?? false,
+    messages: hints.message ? [{ role: "user", content: hints.message }, brief] : [brief],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal,
+    perAttemptMs: reviewerDeadlineMs(deps),
+    maxTurns: REVIEW_MAX_TURNS
+  };
+  let d;
+  try {
+    d = await runStructuredRole(opts, JudgeSchema);
+    reinforceUsed(deps, hints.ids, d.feedback.join(" "), "judge");
+  } catch (e) {
+    if (deps.signal.aborted) throw e;
+    emit({ kind: "note", text: `\u{1F528} **Judge** couldn't produce a ruling \u2014 defaulting to revise (re-reviewing).` });
+    return { decision: "revise", feedback: ["The judge could not reach a structured decision; revising and re-reviewing to be safe."], question: "" };
+  }
+  emit({ kind: "note", text: d.decision === "pass" ? `\u{1F528} **Judge** ruled: approve.` : d.decision === "revise" ? `\u{1F528} **Judge** ruled: revise \u2192 sending it back for changes.` : `\u{1F528} **Judge** needs your input to break the tie.` });
+  return d;
+}
+var TEAM_CONSENSUS = 0.7;
+var REVIEW_SIGNATURES_LOGGED = 8;
+var SIGNATURE_CHARS = 120;
+var COUNCIL_SUPERMAJORITY = 0.8;
+function tallyCouncil(votes) {
+  if (votes.length === 0) return "split";
+  const needed = Math.ceil(votes.length * COUNCIL_SUPERMAJORITY);
+  const pass = votes.filter((v) => v.vote === "pass").length;
+  if (pass >= needed) return "pass";
+  if (votes.length - pass >= needed) return "revise";
+  return "split";
+}
+async function runReviewLoop(deps, o) {
+  const { stage, workdir, target, request, revise, askUser, maxRounds } = o;
+  const emit = o.emit ?? (() => {
+  });
+  const language = o.language;
+  const label = stage;
+  let round = 0;
+  let prevSignatures = /* @__PURE__ */ new Set();
+  let deferralVetoUsed = false;
+  let batches = 1;
+  const MAX_BATCHES = 2;
+  let lastAssessments;
+  let lastVotes = [];
+  for (; ; ) {
+    for (let i = 0; i < maxRounds; i++, round++) {
+      if (stage !== "code" && !existsSync8(isAbsolute(target) ? target : join8(workdir, target))) {
+        emit({ kind: "note", text: `\u26A0\uFE0F **${label} not found** at \`${target}\` \u2014 nothing to review. The authoring phase produced no file.` });
+        return { approved: false };
+      }
+      const approvedLast = (lastAssessments ?? []).filter((a) => a.recommendation === "approve");
+      const carry = round > 0 && approvedLast.length < (lastAssessments?.length ?? 0) ? approvedLast : [];
+      emit({ kind: "note", text: `\u{1F50D} **Reviewing the ${label}** (round ${round + 1}) \u2014 the team (${deps.teams[stage].length - carry.length}) is discussing it\u2026` });
+      const assessments = await runTeam(deps, stage, workdir, target, request, emit, carry);
+      lastAssessments = assessments;
+      if (assessments.length) emit({ kind: "note", text: teamSummaryNote(assessments, label) });
+      const verdicts = assessments.filter((a) => !a.unverified);
+      const approve = verdicts.filter((a) => a.recommendation === "approve").length;
+      const crit = severityTotal(assessments, "critical");
+      const med = severityTotal(assessments, "medium");
+      const cover = coverage(assessments);
+      if (cover.unverified) {
+        emit({ kind: "note", text: `\u26A0\uFE0F ${cover.unverified} of ${assessments.length} lens(es) never returned a verdict \u2014 those dimensions are UNVERIFIED. ${cover.enough ? "The decision rests on the ones that did." : "Too few ran to decide by rule."}` });
+      }
+      if (round === 0) {
+        const clean = crit === 0 && med === 0 && cover.enough;
+        if (verdicts.length && clean && approve / verdicts.length >= TEAM_CONSENSUS) {
+          emit({ kind: "note", text: `\u2705 **Team** \u2014 clean (no critical/medium findings), ${approve}/${verdicts.length} approve \u2192 the ${label} is approved.` });
+          return { approved: true };
+        }
+      } else if (crit === 0 && cover.enough) {
+        const deferred = nonBlockingNotes(assessments, stage);
+        if (!deferred.length) {
+          emit({ kind: "note", text: `\u2705 **Team** \u2014 nothing left to fix \u2192 the ${label} is approved.` });
+          return { approved: true };
+        }
+        if (deferralVetoUsed) {
+          emit({ kind: "note", text: `\u2705 **Team** \u2014 only medium/low findings remain \u2192 the ${label} is approved; ${deferred.length} note(s) carried forward.` });
+          return { approved: true, deferred };
+        }
+        emit({ kind: "note", text: `\u{1F465} **Team** \u2014 no criticals, ${deferred.length} medium/low finding(s) \u2192 asking the **council** whether to defer them or fix one now.` });
+        const dVotes = await runCouncil(deps, stage, workdir, target, assessments, request, emit, "deferral");
+        const dTally = tallyCouncil(dVotes);
+        const dPass = dVotes.filter((v) => v.vote === "pass").length;
+        if (dTally === "pass") {
+          emit({ kind: "note", text: `\u2705 **Council** voted to defer (${dPass}/${dVotes.length} pass) \u2192 the ${label} is approved; ${deferred.length} note(s) carried forward.` });
+          return { approved: true, deferred };
+        }
+        const dJudged = dTally === "revise" ? { decision: "revise", feedback: voteReasons(dVotes), question: "" } : await runJudge(deps, stage, workdir, target, assessments, dVotes, request, emit);
+        if (dJudged.decision === "pass") {
+          emit({ kind: "note", text: `\u2705 **Judge** approved the ${label}; ${deferred.length} note(s) carried forward.` });
+          return { approved: true, deferred };
+        }
+        emit({ kind: "note", text: `\u{1F504} **Council** found a non-critical finding worth fixing \u2192 one more revision of the ${label}.` });
+        deferralVetoUsed = true;
+        await revise(reviseBrief(deferred, dJudged.feedback));
+        continue;
+      }
+      const sig = blockingSignatures(assessments);
+      const stuck = round > 0 && sig.size > 0 && [...sig].every((x) => prevSignatures.has(x));
+      telemetry().event("decision.review_round", {
+        "hc.stage": stage,
+        "hc.review.round": round,
+        "hc.review.blocking": sig.size,
+        "hc.review.repeated": [...sig].filter((x) => prevSignatures.has(x)).length,
+        "hc.review.stuck": stuck,
+        "hc.review.signatures": [...sig].slice(0, REVIEW_SIGNATURES_LOGGED).map((s) => s.length > SIGNATURE_CHARS ? `${s.slice(0, SIGNATURE_CHARS)}\u2026` : s).join(" \xB7 ")
+      });
+      prevSignatures = sig;
+      const blockingFindings = findingNotes(assessments, stage, round === 0 ? ["critical", "medium"] : ["critical"]);
+      const reason = crit || med ? `surfaced ${crit} critical / ${med} medium finding(s)` : `is split (${approve}/${assessments.length} approve)`;
+      emit({ kind: "note", text: `\u{1F465} **Team** ${reason} \u2192 handed the decision to the **council** (${deps.council.length} members vote).` });
+      const votes = await runCouncil(deps, stage, workdir, target, assessments, request, emit);
+      const tally = tallyCouncil(votes);
+      const passVotes = votes.filter((v) => v.vote === "pass").length;
+      let decision;
+      if (tally === "pass") {
+        const deferred = nonBlockingNotes(assessments, stage);
+        emit({ kind: "note", text: `\u2705 **Council** voted to approve (${passVotes}/${votes.length} pass) \u2192 the ${label} is approved.${deferred.length ? ` ${deferred.length} note(s) carried forward.` : ""}` });
+        return { approved: true, deferred };
+      } else if (tally === "revise") {
+        emit({ kind: "note", text: `\u{1F504} **Council** voted to revise (${votes.length - passVotes}/${votes.length}) \u2192 sending the ${label} back for changes.` });
+        decision = { decision: "revise", feedback: voteReasons(votes), question: "" };
+      } else {
+        emit({ kind: "note", text: `\u{1F528} **Council** was split (${passVotes}/${votes.length} pass) \u2192 deferred the final decision to the **judge**.` });
+        decision = await runJudge(deps, stage, workdir, target, assessments, votes, request, emit);
+        if (decision.decision === "pass") {
+          const deferred = nonBlockingNotes(assessments, stage);
+          emit({ kind: "note", text: `\u2705 **Judge** approved the ${label}.${deferred.length ? ` ${deferred.length} note(s) carried forward.` : ""}` });
+          return { approved: true, deferred };
+        }
+      }
+      lastVotes = votes;
+      let feedback = decision.feedback;
+      if (decision.decision === "ask-human") {
+        emit({ kind: "note", text: `\u2753 Judge needs your input: ${decision.question}` });
+        const answer2 = await askUser(decision.question);
+        feedback = [...feedback, `Human answer: ${answer2}`];
+      }
+      if (stuck) {
+        emit({ kind: "note", text: `\u26A0\uFE0F **Not converging** \u2014 the same blocking findings survived the last revision. Handing it to the **judge** for a final ruling.` });
+        break;
+      }
+      emit({ kind: "note", text: `\u{1F504} Revising the ${label} with ${blockingFindings.length} finding(s) + the deciders' reasons\u2026` });
+      await revise(reviseBrief(blockingFindings, feedback));
+    }
+    if (lastAssessments) {
+      const finalRuling = await runJudge(deps, stage, workdir, target, lastAssessments, lastVotes, request, emit, "final", round);
+      if (finalRuling.decision === "pass") {
+        const deferred = nonBlockingNotes(lastAssessments, stage);
+        emit({ kind: "note", text: `\u2705 **Judge** ruled the ${label} good enough for this stage.${deferred.length ? ` ${deferred.length} note(s) carried forward.` : ""}` });
+        return { approved: true, deferred };
+      }
+      if (finalRuling.decision === "revise" && batches < MAX_BATCHES) {
+        batches++;
+        emit({ kind: "note", text: `\u{1F504} **Judge** ruled one more targeted attempt is worth it \u2192 another ${maxRounds} round(s).` });
+        await revise(reviseBrief(findingNotes(lastAssessments, stage, ["critical"]), finalRuling.feedback));
+        prevSignatures = /* @__PURE__ */ new Set();
+        continue;
+      }
+      if (finalRuling.decision === "ask-human" && finalRuling.question) {
+        emit({ kind: "note", text: `\u2753 **Judge** needs a decision only you can make: ${finalRuling.question}` });
+      }
+    }
+    const [q, approveLabel, continueLabel, stopLabel] = language === "Turkish" ? [`${round} revizyon turunda onaylanmad\u0131. Ne yapmak istersin?`, "Mevcut haliyle onayla", `Review'a devam et (${maxRounds} tur daha)`, "Durdur"] : [`Not approved after ${round} revision rounds. What now?`, "Approve as-is", `Keep reviewing (${maxRounds} more rounds)`, "Stop"];
+    const answer = (await askUser(q, { options: [approveLabel, continueLabel, stopLabel] })).trim();
+    if (answer === continueLabel || /^\s*(review|more|daha|başka|tur|round)/i.test(answer)) continue;
+    if (answer === stopLabel || /^\s*(stop|durdur|iptal|cancel|hay[ıi]r|no)\s*$/i.test(answer)) return { approved: false };
+    if (answer === approveLabel || /^\s*(approve|yes|onayla|onay|evet|kabul|tamam|ok)\s*$/i.test(answer)) return { approved: true };
+    emit({ kind: "note", text: language === "Turkish" ? "\u{1F504} Anla\u015F\u0131lamad\u0131 \u2014 review'a devam ediliyor." : "\u{1F504} Unclear answer \u2014 continuing the review." });
+  }
+}
+var CORE_CODE_LENSES = [
+  "code-correctness",
+  "code-plan-conformance",
+  "code-tests",
+  "code-security"
+];
+var SMALL_CHANGE_LINES = 40;
+function changedLines(diff) {
+  let n = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+") || line.startsWith("-")) n++;
+  }
+  return n;
+}
+function lensesFor(team, diff) {
+  if (!diff.trim() || changedLines(diff) > SMALL_CHANGE_LINES) return team;
+  const core = team.filter((c) => CORE_CODE_LENSES.includes(c.name));
+  return core.length ? core : team;
+}
+async function changeUnderReview(deps, workdir) {
+  if (deps.baseRef) return taskDiff(workdir, deps.baseRef);
+  if (deps.inPlaceBase) return diffSince(workdir, deps.inPlaceBase);
+  return workingTreeDiff(workdir);
+}
+async function runCodeReview(deps, workdir, taskTitle, request, emit = () => {
+}, attempt = 0) {
+  const diff = await changeUnderReview(deps, workdir);
+  const team = lensesFor(deps.teams.code, diff);
+  const scaled = team.length < deps.teams.code.length;
+  telemetry().event("decision.review_scale", {
+    "hc.decision": "review_scale",
+    "hc.changed_lines": changedLines(diff),
+    "hc.lenses": team.length,
+    "hc.lenses.full": deps.teams.code.length,
+    "hc.scaled": scaled
+  });
+  emit({ kind: "note", text: `\u{1F50D} **Reviewing the code** for "${taskTitle}" \u2014 ${team.length} lens(es)${scaled ? ` (${changedLines(diff)} changed lines \u2014 the core set)` : ""} discussing it\u2026` });
+  const assessments = await runTeam({ ...deps, teams: { ...deps.teams, code: team } }, "code", workdir, taskTitle, request, emit);
+  if (assessments.length) emit({ kind: "note", text: teamSummaryNote(assessments, "code") });
+  const approve = assessments.filter((a) => a.recommendation === "approve").length;
+  const crit = severityTotal(assessments, "critical");
+  const med = severityTotal(assessments, "medium");
+  const cover = coverage(assessments);
+  if (!cover.enough) {
+    const why = `${cover.unverified} of ${assessments.length} lens(es) never returned a verdict \u2014 too little of the review ran to judge this change. Re-run it; if it keeps happening the lens's model chain is the fault.`;
+    emit({ kind: "note", text: `\u26A0\uFE0F **Code review** \u2014 ${why}` });
+    return { verdict: "fail", notes: [why] };
+  }
+  if (crit === 0) {
+    const deferred = nonBlockingNotes(assessments, "code");
+    if (!deferred.length) {
+      if (attempt > 0 || !assessments.length || approve / assessments.length >= TEAM_CONSENSUS) {
+        emit({ kind: "note", text: `\u2705 **Team** \u2014 nothing to fix \u2192 the code passed.` });
+        return { verdict: "pass", notes: [] };
+      }
+    }
+    emit({ kind: "note", text: `\u2705 **Team** \u2014 no critical findings; ${deferred.length} medium/low note(s) deferred to the revision pass.` });
+    return { verdict: "pass", notes: [], deferred };
+  }
+  const reason = crit || med ? `surfaced ${crit} critical / ${med} medium finding(s)` : `is split (${approve}/${assessments.length} approve)`;
+  emit({ kind: "note", text: `\u{1F465} **Team** ${reason} \u2192 handed the decision to the **council** (${deps.council.length} members vote).` });
+  const votes = await runCouncil(deps, "code", workdir, taskTitle, assessments, request, emit);
+  const tally = tallyCouncil(votes);
+  const passVotes = votes.filter((v) => v.vote === "pass").length;
+  const blocking = assessments.flatMap((a) => a.findings.filter((f) => f.severity !== "low").map((f) => `[${f.severity}] ${a.name}: ${f.note}`));
+  if (tally === "pass") {
+    emit({ kind: "note", text: `\u2705 **Council** voted to approve (${passVotes}/${votes.length} pass) \u2192 the code passed.` });
+    return { verdict: "pass", notes: [] };
+  }
+  if (tally === "revise") {
+    emit({ kind: "note", text: `\u{1F504} **Council** voted to revise (${votes.length - passVotes}/${votes.length}) \u2192 sending the code back.` });
+    return { verdict: "fail", notes: blocking.length ? blocking : votes.filter((v) => v.vote === "revise").map((v) => v.rationale) };
+  }
+  emit({ kind: "note", text: `\u{1F528} **Council** was split (${passVotes}/${votes.length} pass) \u2192 deferred the final decision to the **judge**.` });
+  const d = await runJudge(deps, "code", workdir, taskTitle, assessments, votes, request, emit);
+  if (d.decision === "pass") return { verdict: "pass", notes: [] };
+  return { verdict: "fail", notes: d.feedback.length ? d.feedback : blocking };
+}
+
+// src/engine/acceptance.ts
+import { z as z16 } from "zod";
+
+// src/engine/test-runner.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { join as join9 } from "path";
+var TEST_TIMEOUT_MS = 6e5;
+var MAX_TEST_OUTPUT = 12e3;
+var PLACEHOLDER = /no test specified/i;
+async function detectTestCommand(cwd) {
+  const pkgPath = join9(cwd, "package.json");
+  if (existsSync9(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await readFile3(pkgPath, "utf8"));
+      const script = pkg.scripts?.test;
+      if (script && !PLACEHOLDER.test(script)) {
+        const runner = existsSync9(join9(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync9(join9(cwd, "yarn.lock")) ? "yarn" : existsSync9(join9(cwd, "bun.lockb")) ? "bun" : "npm";
+        const ci = /\bng test\b/.test(script) && !/--watch|--no-watch/.test(script) ? ["--", "--watch=false", "--browsers=ChromeHeadless"] : [];
+        return { argv: [runner, "test", ...ci], why: `package.json scripts.test: ${script}` };
+      }
+    } catch {
+    }
+  }
+  if (existsSync9(join9(cwd, "pytest.ini")) || existsSync9(join9(cwd, "pyproject.toml")) || existsSync9(join9(cwd, "tox.ini"))) {
+    return { argv: ["python3", "-m", "pytest", "-q"], why: "a pytest configuration is present" };
+  }
+  if (existsSync9(join9(cwd, "go.mod"))) return { argv: ["go", "test", "./..."], why: "go.mod is present" };
+  if (existsSync9(join9(cwd, "Cargo.toml"))) return { argv: ["cargo", "test"], why: "Cargo.toml is present" };
+  if (existsSync9(join9(cwd, "Gemfile"))) return { argv: ["bundle", "exec", "rspec"], why: "a Gemfile is present" };
+  return void 0;
+}
+async function runProjectTests(cwd, cmd) {
+  const command = cmd ?? await detectTestCommand(cwd);
+  if (!command) return { skipped: true, passed: true, output: "", timedOut: false };
+  const [bin, ...args] = command.argv;
+  return new Promise((resolve6) => {
+    const child = spawn2(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1" } });
+    let out = "";
+    const take = (d) => {
+      out += d.toString();
+      if (out.length > MAX_TEST_OUTPUT * 4) out = out.slice(-MAX_TEST_OUTPUT * 2);
+    };
+    child.stdout.on("data", take);
+    child.stderr.on("data", take);
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, TEST_TIMEOUT_MS);
+    const done = (code, extra = "") => {
+      clearTimeout(timer);
+      resolve6({
+        skipped: false,
+        passed: code === 0 && !timedOut,
+        command: command.argv.join(" "),
+        why: command.why,
+        output: clampOutput(`${extra}${out}`.trimEnd(), MAX_TEST_OUTPUT),
+        timedOut
+      });
+    };
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve6({
+        skipped: true,
+        passed: true,
+        command: command.argv.join(" "),
+        why: command.why,
+        output: `could not run the suite: ${e.message}`,
+        timedOut: false
+      });
+    });
+    child.on("close", (code) => done(code ?? 1));
+  });
+}
+function describeTestRun(run) {
+  if (run.skipped) {
+    return run.output ? `The project's test suite could not be run (${run.output}). Judge the criteria by reading the code.` : "This project has no test suite. Judge the criteria by reading the code.";
+  }
+  if (run.timedOut) {
+    return `The test suite (\`${run.command}\`) was killed after ${TEST_TIMEOUT_MS / 6e4} minutes without finishing. Treat this as a FAILURE unless the criteria are unrelated to it.
+
+${run.output}`;
+  }
+  if (run.passed) return `The project's test suite passed (\`${run.command}\`).`;
+  return `The project's test suite FAILED (\`${run.command}\`). This is evidence, not opinion \u2014 a criterion about behaviour cannot be met while the suite is red. If the failures are clearly unrelated to this task's criteria, say so explicitly in the evidence rather than ignoring them.
+
+${run.output}`;
+}
+
+// src/engine/acceptance.ts
+var AcceptanceSchema = z16.object({
+  checks: z16.array(z16.object({
+    criterion: z16.string(),
+    met: z16.boolean(),
+    evidence: z16.string().describe(
+      'Where you SAW it: a file path and what it contains, a symbol, a test name. "It looks fine" is not evidence.'
+    )
+  }))
+});
+var PROMPT = `You are the acceptance gate for one implementation task. You are given the task's acceptance criteria and read-only access to the worktree. For EACH criterion decide whether it is ACTUALLY satisfied by the code that is present, and cite the concrete evidence you saw (file path, symbol, test name, config key).
+Rules:
+- Verify by LOOKING. If you did not open the file, the criterion is not met.
+- "met" means observably true right now \u2014 not "planned", "close enough" or "the implementer says so".
+- Judge ONLY the listed criteria. Code quality, style and scope opinions belong to the code review, not here.
+- Write the evidence in ENGLISH (it is a technical record).`;
+async function verifyAcceptance(deps, card, cwd, emit = () => {
+}) {
+  const suite = () => deps.timings ? deps.timings.time("test suite", () => runProjectTests(cwd)) : runProjectTests(cwd);
+  const tests = await telemetry().span("stage.test_suite", { "hc.stage": "test suite" }, suite);
+  telemetry().event("tests.run", {
+    "hc.tests.ran": !tests.skipped,
+    "hc.tests.passed": tests.passed,
+    "hc.tests.timed_out": tests.timedOut === true,
+    "hc.tests.command": tests.command
+  });
+  if (!tests.skipped) {
+    emit({ kind: "note", text: tests.passed ? `\u2705 **Tests passed** for "${card.title}" \u2014 \`${tests.command}\`` : `\u274C **Tests FAILED** for "${card.title}" \u2014 \`${tests.command}\`${tests.timedOut ? " (timed out)" : ""}` });
+    if (!tests.passed) {
+      return {
+        passed: false,
+        unmet: [
+          `The project's test suite fails (\`${tests.command}\`)${tests.timedOut ? " \u2014 it timed out" : ""}. Nothing may enter DONE while it is red.
+${tests.output.slice(-4e3)}`,
+          ...card.acceptance.map((c) => `${c} (not assessed \u2014 the suite is red)`)
+        ],
+        tests: { ran: true, passed: false, ...tests.command ? { command: tests.command } : {} }
+      };
+    }
+  }
+  const testEvidence = { ran: !tests.skipped, passed: tests.passed, ...tests.command ? { command: tests.command } : {} };
+  if (!card.acceptance.length) return { passed: true, unmet: [], tests: testEvidence };
+  const diff = deps.baseRef ? await taskDiff(cwd, deps.baseRef) : deps.inPlaceBase ? await diffSince(cwd, deps.inPlaceBase) : "";
+  const resolved = deps.roleRegistry.resolve("code-reviewer");
+  const hints = memoryHints(deps, `${card.title} ${card.acceptance.join(" ")}`, { role: "code-reviewer" });
+  const ask = { role: "user", content: `Task: "${card.title}".
+
+Acceptance criteria:
+${card.acceptance.map((c, i) => `${i + 1}. ${c}`).join("\n")}
+
+Check each one against the worktree and report met/unmet with the evidence you saw.
+
+${describeTestRun(tests)}
+
+${describeDiff(diff)}` };
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    systemPrompt: `${PROMPT}${deps.roleRegistry.ruleSuffix()}`,
+    tools: readOnlyRegistry(deps),
+    messages: hints.message ? [{ role: "user", content: hints.message }, ask] : [ask],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd,
+    signal: AbortSignal.any([deps.signal, AbortSignal.timeout(CODE_REVIEW_TIMEOUT_MS)]),
+    maxTurns: CODE_REVIEW_MAX_TURNS
+  };
+  let checks;
+  try {
+    ({ checks } = await runStructuredRole(opts, AcceptanceSchema));
+    reinforceUsed(deps, hints.ids, checks.map((c) => c.evidence).join(" "), "code-reviewer");
+  } catch (e) {
+    if (deps.signal.aborted) throw e;
+    emit({ kind: "note", text: `\u26A0\uFE0F **Acceptance gate** could not run for "${card.title}" \u2014 treating the criteria as unmet.` });
+    return {
+      passed: false,
+      unmet: card.acceptance.map((c) => `${c} (not verified: the gate did not run)`),
+      tests: testEvidence
+    };
+  }
+  const byCriterion = new Map(checks.map((c) => [c.criterion.trim().toLowerCase(), c]));
+  const unmet = [];
+  for (const c of card.acceptance) {
+    const hit = byCriterion.get(c.trim().toLowerCase()) ?? checks.find((x) => x.criterion.toLowerCase().includes(c.trim().toLowerCase().slice(0, 40)));
+    if (!hit) unmet.push(`${c} (not reported by the acceptance gate)`);
+    else if (!hit.met) unmet.push(`${c} \u2014 ${hit.evidence}`);
+  }
+  const passed = unmet.length === 0;
+  const result = { passed, unmet, tests: testEvidence };
+  emit({ kind: "note", text: passed ? `\u2705 **Acceptance gate** \u2014 all ${card.acceptance.length} criteria verified for "${card.title}".` : `\u26D4 **Acceptance gate** \u2014 ${unmet.length}/${card.acceptance.length} criteria NOT met for "${card.title}".` });
+  return result;
+}
+
+// src/engine/worktree-state.ts
+async function worktreeState(git, cwd) {
+  const head = await git(["rev-parse", "HEAD"], cwd);
+  if (head.code !== 0) return void 0;
+  const status = await git(["status", "--porcelain"], cwd);
+  return `${head.stdout.trim()}|${status.stdout.trim()}`;
+}
+async function hasWorkAgainst(git, cwd, baseRef) {
+  const merge = await git(["merge-base", "HEAD", baseRef], cwd);
+  const at = merge.stdout.trim();
+  if (merge.code !== 0 || !at) return false;
+  const diff = await git(["diff", "--quiet", `${at}..HEAD`], cwd);
+  if (diff.code !== 0) return true;
+  const dirty = await git(["status", "--porcelain"], cwd);
+  return dirty.stdout.trim().length > 0;
+}
+
+// src/engine/task-cycle.ts
+async function runCycleWithRole(deps, board, taskId, cwd, role, git = defaultGitRunner, slot = 0) {
+  board.move(taskId, "IN-PROGRESS", role);
+  const rotation = slot + board.get(taskId).attempts;
+  board.setWorker(taskId, role, deps.roleRegistry.chainFor(role, rotation)[0] ?? "");
+  const before = await worktreeState(git, cwd);
+  const startedAt = before?.split("|")[0];
+  const rdeps = deps.baseRef || !startedAt ? deps : { ...deps, inPlaceBase: startedAt };
+  await runImplementer(deps, role, board.get(taskId), cwd, rotation);
+  const after = await worktreeState(git, cwd);
+  const idle = before !== void 0 && after !== void 0 && before === after && !(deps.baseRef && await hasWorkAgainst(git, cwd, deps.baseRef));
+  if (idle) {
+    const note = "The previous attempt produced NO file changes. You must actually write the code with write_file/edit_file \u2014 describing it is not enough.";
+    const servedBy = deps.roleRegistry.chainFor(role, rotation)[0] ?? "";
+    telemetry().event("implementer.no_changes", {
+      "hc.task.id": taskId,
+      "hc.role": role,
+      "hc.model": servedBy,
+      "hc.attempt": board.get(taskId).attempts
+    });
+    if (servedBy) {
+      const strikes = deps.fitness?.record(role, servedBy, "answered in prose instead of implementing") ?? 0;
+      if (strikes === UNFIT_AFTER) {
+        deps.note?.(`\u{1F6AB} \`${servedBy}\` will no longer be assigned to \`${role}\` \u2014 ${strikes} attempts that wrote nothing. It stays available to every other role.`);
+      }
+    }
+    board.appendStage(taskId, { role, action: "no-changes", note: servedBy ? `model: ${servedBy}` : void 0 });
+    board.clearReviewNotes(taskId);
+    board.addReviewNote(taskId, note);
+    board.move(taskId, "TODO", role);
+    deps.note?.(`\u26A0\uFE0F **${board.get(taskId).title}** \u2014 \`${role}\`${servedBy ? ` on \`${servedBy}\`` : ""} wrote nothing; trying the next model.`);
+    return { verdict: "fail", notes: [note], noProgress: true };
+  }
+  deps.fitness?.ok(role, deps.roleRegistry.chainFor(role, rotation)[0] ?? "");
+  board.move(taskId, "REVIEW", role);
+  const card = board.get(taskId);
+  const review = () => runCodeReview(rdeps, cwd, card.title, void 0, (ev) => {
+    if (ev.kind === "note") deps.note?.(ev.text);
+  }, card.attempts);
+  let v;
+  try {
+    v = await telemetry().span(
+      "stage.code_review",
+      { "hc.stage": "code review", "hc.task.id": taskId },
+      () => deps.timings ? deps.timings.time("code review", review) : review()
+    );
+  } catch (e) {
+    if (!deps.signal.aborted) throw e;
+    const note = "Review was cancelled. Add a human note before retrying this task.";
+    board.clearReviewNotes(taskId);
+    board.addReviewNote(taskId, note);
+    board.appendStage(taskId, { role: "code-reviewer", action: "reviewed:cancelled", note });
+    return { verdict: "fail", notes: [note] };
+  }
+  if (deps.signal.aborted) {
+    const note = "Review was cancelled. Add a human note before retrying this task.";
+    board.clearReviewNotes(taskId);
+    board.addReviewNote(taskId, note);
+    board.appendStage(taskId, { role: "code-reviewer", action: "reviewed:cancelled", note });
+    return { verdict: "fail", notes: [note] };
+  }
+  if (v.verdict === "pass") {
+    const check = () => verifyAcceptance(rdeps, board.get(taskId), cwd, (ev) => {
+      if (ev.kind === "note") deps.note?.(ev.text);
+    });
+    const gate = await telemetry().span(
+      "stage.acceptance_gate",
+      { "hc.stage": "acceptance gate", "hc.task.id": taskId },
+      () => deps.timings ? deps.timings.time("acceptance gate", check) : check()
+    );
+    if (!gate.passed) {
+      board.appendStage(taskId, { role: "code-reviewer", action: "acceptance:failed", note: gate.unmet.join("; ") });
+      board.clearReviewNotes(taskId);
+      for (const n of gate.unmet) board.addReviewNote(taskId, `Acceptance criterion not met: ${n}`);
+      board.move(taskId, "TODO", "code-reviewer");
+      return { verdict: "fail", notes: gate.unmet };
+    }
+    board.appendStage(taskId, { role: "code-reviewer", action: "acceptance:passed" });
+    board.appendStage(taskId, { role: "code-reviewer", action: "reviewed:pass" });
+    for (const d of v.deferred ?? []) board.appendStage(taskId, { role: "code-reviewer", action: "deferred", note: d });
+    board.clearReviewNotes(taskId);
+    board.move(taskId, "DONE", "code-reviewer");
+  } else {
+    const notes = v.notes.length > 0 ? v.notes : ["review failed (no notes given)"];
+    board.appendStage(taskId, {
+      role: "code-reviewer",
+      action: "reviewed:fail",
+      note: notes.join("; ")
+    });
+    board.clearReviewNotes(taskId);
+    for (const n of notes) board.addReviewNote(taskId, n);
+    board.move(taskId, "TODO", "code-reviewer");
+  }
+  return v;
+}
+async function runTaskCycle(deps, board, taskId, worktreePath, slot = 0) {
+  const task = board.get(taskId);
+  if (!task) throw new Error(`runTaskCycle: unknown task: ${taskId}`);
+  const role = await routeTask(deps, task);
+  board.setWorktree(taskId, worktreePath);
+  return runCycleWithRole(deps, board, taskId, worktreePath, role, defaultGitRunner, slot);
+}
+
+// src/board/board.ts
+import { z as z17 } from "zod";
+var MAX_STAGE_EVENTS = 200;
+var stageEventSchema = z17.object({
+  role: z17.string(),
+  action: z17.string(),
+  note: z17.string().optional()
+});
+var cardSchema = z17.object({
+  id: z17.string(),
+  title: z17.string(),
+  column: z17.enum(["TODO", "IN-PROGRESS", "REVIEW", "DONE", "MERGED", "PARKED", "ABANDONED"]),
+  worktree: z17.string().optional(),
+  deps: z17.array(z17.string()),
+  acceptance: z17.array(z17.string()).default([]),
+  // default: boards persisted before the gate existed still load
+  files: z17.array(z17.string()).default([]),
+  // ditto — a board written before file lists existed still loads
+  reviewNotes: z17.array(z17.string()),
+  attempts: z17.number(),
+  stageHistory: z17.array(stageEventSchema)
+});
+var boardDataSchema = z17.object({ version: z17.literal(1), cards: z17.array(cardSchema) });
+function migrateDelivered(c) {
+  if (c.column !== "DONE") return c;
+  return c.stageHistory.some((e) => e.action === "merged") ? { ...c, column: "MERGED" } : c;
+}
+function cloneCard(c) {
+  return {
+    ...c,
+    deps: [...c.deps],
+    acceptance: [...c.acceptance],
+    files: [...c.files],
+    reviewNotes: [...c.reviewNotes],
+    stageHistory: c.stageHistory.map((e) => ({ ...e }))
+  };
+}
+var Board = class _Board {
+  onChange;
+  // called after every mutation (if set; H3a progress events)
+  onMove;
+  // called on a real column transition → action notes
+  cards = /* @__PURE__ */ new Map();
+  constructor(cards = []) {
+    for (const c of cards) this.cards.set(c.id, cloneCard(c));
+  }
+  addCard(input) {
+    if (this.cards.has(input.id)) throw new Error(`card already exists: ${input.id}`);
+    const card = {
+      id: input.id,
+      title: input.title,
+      column: "TODO",
+      deps: input.deps ? [...input.deps] : [],
+      acceptance: input.acceptance ? [...input.acceptance] : [],
+      files: input.files ? [...input.files] : [],
+      reviewNotes: [],
+      attempts: 0,
+      stageHistory: []
+    };
+    this.cards.set(card.id, card);
+    this.onChange?.();
+    return cloneCard(card);
+  }
+  get(id) {
+    const c = this.cards.get(id);
+    return c ? cloneCard(c) : void 0;
+  }
+  list() {
+    return [...this.cards.values()].map(cloneCard);
+  }
+  byColumn(column) {
+    return this.list().filter((c) => c.column === column);
+  }
+  require(id) {
+    const c = this.cards.get(id);
+    if (!c) throw new Error(`unknown card: ${id}`);
+    return c;
+  }
+  move(id, column, actor) {
+    const c = this.require(id);
+    const from = c.column;
+    c.column = column;
+    if (actor) {
+      c.stageHistory.push({ role: actor, action: `\u2192${column}` });
+      if (c.stageHistory.length > MAX_STAGE_EVENTS) {
+        c.stageHistory.splice(0, c.stageHistory.length - MAX_STAGE_EVENTS);
+      }
+    }
+    if (from !== column) this.onMove?.(c, from, column, actor);
+    this.onChange?.();
+  }
+  /**
+   * Records a dependency the breakdown missed.
+   *
+   * Returns false — rather than throwing — for anything that is not a real new edge (unknown id, self, or
+   * already present), because the caller is an audit whose input is a model's suggestion: a nonsense entry
+   * is an expected outcome there, not an exceptional one.
+   */
+  addDep(id, dependsOn) {
+    const c = this.cards.get(id);
+    if (!c || id === dependsOn || !this.cards.has(dependsOn) || c.deps.includes(dependsOn)) return false;
+    c.deps.push(dependsOn);
+    this.onChange?.();
+    return true;
+  }
+  /** Undoes `addDep` — used when the added edge turns out to close a cycle. */
+  removeDep(id, dependsOn) {
+    const c = this.cards.get(id);
+    if (!c) return;
+    c.deps = c.deps.filter((d) => d !== dependsOn);
+    this.onChange?.();
+  }
+  appendStage(id, event) {
+    this.require(id).stageHistory.push({ ...event });
+    this.onChange?.();
+  }
+  /** Records the model of the implementer now working this card (surfaced in the live-agents UI). */
+  setModel(id, model) {
+    this.require(id).model = model;
+    this.onChange?.();
+  }
+  /**
+   * Returns an interrupted card to TODO and forgets who was working it.
+   *
+   * Deliberately silent — no stage event, no move note: nothing HAPPENED to this task, a process died. The
+   * chat should not report a transition the user did not cause and no agent performed.
+   */
+  reopen(id) {
+    const c = this.require(id);
+    c.column = "TODO";
+    c.role = void 0;
+    c.model = void 0;
+    this.onChange?.();
+  }
+  /** Records WHO is working this card: the role and the model it will actually use. */
+  setWorker(id, role, model) {
+    const c = this.require(id);
+    c.role = role;
+    c.model = model;
+    this.onChange?.();
+  }
+  addReviewNote(id, note) {
+    this.require(id).reviewNotes.push(note);
+    this.onChange?.();
+  }
+  clearReviewNotes(id) {
+    this.require(id).reviewNotes = [];
+    this.onChange?.();
+  }
+  /**
+   * Starts the escalation ladder over for one card, keeping its history.
+   *
+   * The tier is derived from `attempts`, so a task carrying a large count from earlier runs begins at the
+   * council — the most expensive tier, and the one that had already failed it. Everything that actually
+   * happened stays in `stageHistory`; only the counter that picks the tier goes back to zero.
+   */
+  resetAttempts(id) {
+    const c = this.require(id);
+    if (c.attempts === 0) return;
+    c.stageHistory.push({ role: "team-lead", action: "reset", note: `new run \u2014 ladder restarted (was ${c.attempts})` });
+    c.attempts = 0;
+    this.onChange?.();
+  }
+  incrementAttempts(id) {
+    const c = this.require(id);
+    c.attempts += 1;
+    this.onChange?.();
+    return c.attempts;
+  }
+  setWorktree(id, path) {
+    this.require(id).worktree = path;
+    this.onChange?.();
+  }
+  toJSON() {
+    return { version: 1, cards: this.list() };
+  }
+  static fromJSON(data) {
+    const parsed = boardDataSchema.parse(data);
+    return new _Board(parsed.cards.map(migrateDelivered));
+  }
+};
+
+export {
+  describeInherited,
+  describeTopUp,
+  toSlug,
+  mainWorktreeRoot,
+  WorktreeManager,
+  applySkills,
+  buildSkillTool,
+  RoleRegistry,
+  unfinishedSessions,
+  describeUnfinished,
+  gitTool,
+  buildRememberTool,
+  routeSkills,
+  REQUIRED_ROLES,
+  DEFAULT_ROLE_SKILLS,
+  DEFAULT_PROMPTS,
+  SPEC_TEAM,
+  PLAN_TEAM,
+  CODE_TEAM,
+  DEFAULT_COUNCIL,
+  placedSkills,
+  specsDir,
+  constitutionPath,
+  verifyPaths,
+  featureSlugFor,
+  nextFeatureSlug,
+  scaffoldFeature,
+  constitutionNote,
+  readOnlyRegistry,
+  deferMcp,
+  runReviewer,
+  asChoice,
+  buildTeamRegistry,
+  buildCouncilRegistry,
+  runReviewLoop,
+  writeFileTool,
+  editFileTool,
+  shellTool,
+  createWebFetchTool,
+  createDefaultRegistry,
+  changedByMerge,
+  refreshAfterChange,
+  LONG_CALL_MS,
+  routeTask,
+  commitFile,
+  commitStep,
+  squashTask,
+  WHAT_IT_COST,
+  runImplementer,
+  RoleFitness,
+  worktreeState,
+  hasWorkAgainst,
+  runCycleWithRole,
+  runTaskCycle,
+  Board
+};