@hizliemre/horse-code 0.3.0 → 0.4.0

package/dist/chunk-PIG54WFU.js

@@ -0,0 +1,2873 @@
+import {
+  CODE_REVIEW_MAX_TURNS,
+  CODE_REVIEW_TIMEOUT_MS,
+  buildRememberTool,
+  constitutionNote,
+  createWebFetchTool,
+  describeDiff,
+  diffSince,
+  gitTool,
+  partitionByConfidence,
+  readOnlyRegistry,
+  routeSkills,
+  taskDiff,
+  workingTreeDiff
+} from "./chunk-NBTH2VVI.js";
+import {
+  RoleRegistry,
+  cliFor,
+  cliInvocation,
+  grokEffort,
+  planFor,
+  runTraces
+} from "./chunk-ACTVFJRW.js";
+import {
+  applySkills,
+  buildSkillTool,
+  placedSkills
+} from "./chunk-MZM24M5M.js";
+import {
+  SYNTHETIC,
+  runCliAgent
+} from "./chunk-G45RWL7S.js";
+import {
+  defaultGitRunner
+} from "./chunk-LPQU436C.js";
+import {
+  BATCH_TOOLS_NOTE,
+  contextTools,
+  emitBatchInjection,
+  globTool,
+  grepTool,
+  memoryHints,
+  projectToolsNote,
+  readFileTool,
+  reinforceTouched,
+  reinforceUsed
+} from "./chunk-BFIZMM4G.js";
+import {
+  ToolRegistry,
+  runStructuredRole
+} from "./chunk-CYLPQWIF.js";
+import {
+  handedOver,
+  runToCompletion,
+  telemetry
+} from "./chunk-JLWQCA7B.js";
+import {
+  loadTraceIndex,
+  pruneTraces,
+  saveTraceIndex,
+  sharedDerived,
+  traceRootRel,
+  traceable
+} from "./chunk-ZPJP2VH5.js";
+import {
+  buildProjectGraph,
+  loadGraphSync,
+  pruneAreaNames
+} from "./chunk-4M6LXNG2.js";
+import {
+  writableStateRoot
+} from "./chunk-6W4UH2BQ.js";
+
+// 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 = 5 * 60 * 1e3;
+var LONG_CALL_MS = 15 * 60 * 1e3;
+function isCallerAbort(signal) {
+  return signal.aborted && signal.reason?.name !== "TimeoutError";
+}
+function isDeadline(signal) {
+  return signal.aborted && signal.reason?.name === "TimeoutError";
+}
+
+// src/agents/cli-provider.ts
+function promptFor(req) {
+  const parts = [];
+  for (const m of req.messages) {
+    if (m.role === "system") {
+      parts.push(m.content);
+      continue;
+    }
+    if (!m.content.trim()) continue;
+    parts.push(m.role === "assistant" ? `[your previous reply]
+${m.content}` : m.content);
+  }
+  const submit = req.tools?.find((t) => t.name === "submit");
+  if (submit) {
+    parts.push(
+      "Reply with ONE JSON object and nothing else \u2014 no prose before or after it, no code fence. It must satisfy this schema:\n" + JSON.stringify(submit.parameters ?? {}, null, 2)
+    );
+  }
+  return parts.join("\n\n");
+}
+function isLoggedOut(text) {
+  return /not logged in|not signed in|please run \/login/i.test(text);
+}
+async function* streamWhileRunning(start) {
+  const queue = [];
+  let finished = false;
+  let wake = () => {
+  };
+  let waiter = new Promise((r) => {
+    wake = r;
+  });
+  const bump = () => {
+    const w = wake;
+    waiter = new Promise((r) => {
+      wake = r;
+    });
+    w();
+  };
+  const done = start((ev) => {
+    queue.push(ev);
+    bump();
+  });
+  let failure;
+  void done.then(() => {
+    finished = true;
+    bump();
+  }, (e) => {
+    failure = e;
+    finished = true;
+    bump();
+  });
+  for (; ; ) {
+    while (queue.length) yield queue.shift();
+    if (finished) break;
+    await waiter;
+  }
+  if (failure) throw failure;
+}
+var CliProvider = class {
+  fixed;
+  readOnly;
+  cwd;
+  accounts;
+  constructor(opts = {}) {
+    this.fixed = opts.kind;
+    this.readOnly = opts.readOnly ?? true;
+    this.cwd = opts.cwd;
+    this.accounts = opts.accounts;
+  }
+  async *chat(req, signal) {
+    const kind = this.fixed ?? cliFor(req.model);
+    if (!kind) {
+      yield { type: "error", message: `no CLI serves ${req.model} \u2014 it is not available in this catalog`, retryable: true };
+      return;
+    }
+    const args = [];
+    const { model, effort: named } = cliInvocation(req.model);
+    if (model) args.push("--model", model);
+    const effort = req.effort ?? named;
+    if (effort && (kind === "claude" || kind === "zai")) args.push("--effort", effort);
+    if (effort && kind === "grok") {
+      const level = grokEffort(effort);
+      if (level) args.push("--reasoning-effort", level);
+    }
+    if (this.readOnly && (kind === "claude" || kind === "zai")) args.push("--disallowed-tools", "Write", "Edit", "NotebookEdit");
+    if (this.readOnly && kind === "codex") args.push("--sandbox", "read-only");
+    if (this.readOnly && kind === "grok") args.push("--disallowed-tools", "write,search_replace");
+    if (!this.readOnly && (kind === "claude" || kind === "zai")) args.push("--permission-mode", "acceptEdits");
+    if (!this.readOnly && kind === "codex") args.push("--sandbox", "workspace-write");
+    if (!this.readOnly && kind === "grok") args.push("--permission-mode", "acceptEdits");
+    const account = this.accounts?.pick(kind);
+    let res;
+    yield* streamWhileRunning((push) => runCliAgent({
+      kind,
+      cwd: this.cwd ?? process.cwd(),
+      prompt: promptFor(req),
+      signal,
+      args,
+      ...account ? { configDir: account.configDir } : {},
+      onEvent: (ev) => {
+        if (ev.tool) push({ type: "activity", tool: ev.tool.name, ...ev.tool.target ? { target: ev.tool.target } : {}, ...ev.tool.ok === false ? { ok: false } : {} });
+        if (ev.text) push({ type: "text-delta", text: ev.text });
+        if (ev.quota && account) this.accounts?.record(kind, account.name, ev.quota.windows);
+      }
+    }).then((r) => {
+      res = r;
+    }));
+    if (res.rateLimited) {
+      yield { type: "error", message: `${kind} CLI: ${res.rateLimited}`, retryable: true };
+      return;
+    }
+    if (res.served === SYNTHETIC) {
+      const loggedOut = isLoggedOut(res.text);
+      yield {
+        type: "error",
+        retryable: true,
+        message: loggedOut ? `${kind} CLI is not logged in${account ? ` under profile "${account.name}"` : ""} \u2014 run \`hcode add-provider ${kind}\` to sign it in again` : `${kind} CLI did not recognise ${req.model} and answered without a model`
+      };
+      return;
+    }
+    if (isCallerAbort(signal)) {
+      yield { type: "error", message: "cancelled", retryable: false };
+      return;
+    }
+    if (isDeadline(signal)) {
+      yield { type: "error", message: `${kind} CLI: deadline expired`, retryable: true };
+      return;
+    }
+    if (res.error && !res.text.trim()) {
+      if (isLoggedOut(res.error)) {
+        yield {
+          type: "error",
+          retryable: true,
+          message: `${kind} CLI is not logged in${account ? ` under profile "${account.name}"` : ""} \u2014 run \`hcode add-provider ${kind}\` to sign it in again`
+        };
+        return;
+      }
+      yield { type: "error", message: `${kind} CLI: ${res.error}`, retryable: res.exitCode !== 0 };
+      return;
+    }
+    if (res.usage) yield usageEvent(res.usage);
+    yield { type: "done", finishReason: "stop" };
+  }
+};
+function usageEvent(u) {
+  return {
+    type: "usage",
+    promptTokens: u.freshTokens,
+    completionTokens: u.outputTokens,
+    cachedTokens: u.cachedTokens,
+    cacheWriteTokens: u.cacheWriteTokens
+  };
+}
+
+// src/tools/write.ts
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, resolve, sep } from "path";
+import { z } from "zod";
+var params = z.object({ path: z.string(), content: z.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: params,
+  describe(rawArgs) {
+    const a = params.parse(rawArgs);
+    return { allowKey: a.path, preview: `write ${a.path} (${Buffer.byteLength(a.content)} bytes)` };
+  },
+  async run(rawArgs, ctx) {
+    const parsed = params.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 = resolve(ctx.cwd, a.path);
+    const cwdResolved = resolve(ctx.cwd);
+    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep)) {
+      return { content: `write_file: path is outside cwd: ${a.path}`, isError: true };
+    }
+    if (ctx.readFiles && existsSync(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 mkdir(dirname(target), { recursive: true });
+      await writeFile(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, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve2, sep as sep2 } from "path";
+import { z as z2 } from "zod";
+var params2 = z2.object({
+  path: z2.string(),
+  oldString: z2.string(),
+  newString: z2.string(),
+  replaceAll: z2.boolean().optional()
+});
+var NEAR_MISS_CHARS = 600;
+var MAX_MATCH_LINES = 5;
+var norm = (t) => t.replace(/[ \t]+/g, " ").replace(/[ \t]+$/gm, "").trim();
+function shortPath(path, cwd) {
+  const abs = resolve2(cwd, path);
+  return abs === cwd ? "." : abs.startsWith(cwd + sep2) ? 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: params2,
+  describe(rawArgs) {
+    const a = params2.parse(rawArgs);
+    return { allowKey: a.path, preview: `edit ${a.path}` };
+  },
+  async run(rawArgs, ctx) {
+    const parsed = params2.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 = resolve2(ctx.cwd, a.path);
+    const cwdResolved = resolve2(ctx.cwd);
+    if (target !== cwdResolved && !target.startsWith(cwdResolved + sep2)) {
+      return { content: `edit_file: path is outside cwd: ${a.path}`, isError: true };
+    }
+    let content;
+    try {
+      content = await readFile(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) {
+      const lines = content.split("\n");
+      const at = [];
+      for (let i = 0; i < lines.length && at.length <= MAX_MATCH_LINES; i++) {
+        if (lines[i]?.includes(a.oldString.split("\n")[0] ?? "")) at.push(i + 1);
+      }
+      const where = at.length ? ` First seen at line${at.length > 1 ? "s" : ""} ${at.slice(0, MAX_MATCH_LINES).join(", ")}${at.length > MAX_MATCH_LINES ? ", \u2026" : ""}.` : "";
+      return {
+        content: `edit_file: oldString matches ${count} places in ${shortPath(a.path, cwdResolved)}.${where} Add surrounding lines to oldString so it names the one you mean \u2014 or pass replaceAll: true if every occurrence should change.`,
+        isError: true
+      };
+    }
+    const next = a.replaceAll ? content.split(a.oldString).join(a.newString) : content.replace(a.oldString, a.newString);
+    try {
+      await writeFile2(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 resolve3, sep as sep3 } from "path";
+import { z as z3 } from "zod";
+var params3 = z3.object({
+  command: z3.string(),
+  /** Milliseconds before the command is killed. Defaults to DEFAULT_TIMEOUT_MS, capped at MAX_TIMEOUT_MS. */
+  timeout: z3.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 = resolve3(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 = resolve3(at, raw);
+    if (at !== base && !at.startsWith(base + sep3)) 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(/^(?:(?:-[cC]|--(?:git-dir|work-tree|namespace|exec-path|config-env))\s+\S+|-\S+)\s+/g, "").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: params3,
+  describe(rawArgs) {
+    const a = params3.parse(rawArgs);
+    return { allowKey: a.command, preview: a.command };
+  },
+  run(rawArgs, ctx) {
+    const parsed = params3.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/engine/trace-refresh.ts
+import { existsSync as existsSync2 } from "fs";
+import { join } 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) => !existsSync2(join(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 chain = opts.models.filter(Boolean);
+  if (!chain.length) 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,
+      models: chain,
+      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) => existsSync2(join(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/writer-registry.ts
+import { z as z5 } from "zod";
+
+// src/engine/normalize-question.ts
+import { z as z4 } from "zod";
+var NormalizedQuestionSchema = z4.object({
+  question: z4.string().describe("The core question, concise, WITHOUT the embedded options table/list."),
+  options: z4.array(z4.string()).describe("Each selectable choice as a SHORT label; the recommended one first, suffixed ' (recommended)'. Empty when the question is genuinely open-ended."),
+  multiSelect: z4.boolean().describe("true only if the user may pick more than one.")
+});
+var PROMPT = "You reformat an agent's question for a terminal UI that renders selectable options (arrow keys + Enter). Given the raw question text \u2014 which may embed choices as a markdown table, an A/B/C/D list, or a 'recommended' suggestion \u2014 extract exactly:\n- `question`: the core question, concise, WITHOUT the embedded options table/list.\n- `options`: each selectable choice as a SHORT label. If one choice is recommended, list it FIRST and append ' (recommended)'. Do NOT add an 'other' / free-text / 'answer in your own words' option \u2014 the UI already provides that.\n- `multiSelect`: true only if the user may pick several.\nIf the text is genuinely open-ended (no discrete choices), return options: []. Preserve the user's language. Return the result via submit.";
+function looksLikeChoices(text) {
+  return /\|[^\n]*\|[^\n]*\|/.test(text) || /(^|\n)\s*[A-Ea-e][).\-:]\s/.test(text) || /(^|\n)\s*[-*]\s+\S.*(\n\s*[-*]\s+\S.*){1,}/.test(text) || /\b(option|seçenek|choice|önerilen|recommended)\b/i.test(text);
+}
+async function normalizeQuestion(deps, raw) {
+  const { role: agentRole, model, fallbacks, onExhausted, onFallback } = deps.roleRegistry.fallbackOpts("refiner");
+  return runStructuredRole({
+    provider: deps.provider,
+    role: agentRole,
+    model,
+    fallbacks,
+    onExhausted,
+    onFallback,
+    // This shapes the question the USER reads; a rule like "always ask in Turkish" belongs here.
+    systemPrompt: PROMPT + deps.roleRegistry.ruleSuffix(),
+    tools: new ToolRegistry(),
+    messages: [{ role: "user", content: raw }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: ".",
+    signal: deps.signal
+  }, NormalizedQuestionSchema);
+}
+function extractChoicesFrom(text) {
+  const lines = text.split("\n");
+  const rows = lines.map((l) => l.trim()).filter((l) => l.startsWith("|") && l.endsWith("|") && !/^\|[\s|:-]+\|$/.test(l)).map((l) => l.slice(1, -1).split("|").map((c) => c.trim()));
+  const body = rows.filter((cells) => cells.length >= 2 && cells[0] && cells[1]).filter((cells, i) => !(i === 0 && /^(option|seçenek|choice|alternatif)$/i.test(cells[0])));
+  if (body.length >= 2) {
+    const question = lines.filter((l) => !/^\s*\|.*\|\s*$/.test(l)).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    return { choices: body.map((cells) => ({ label: cells[0], description: cells.slice(1).join(" \u2014 ") })), question };
+  }
+  const isLettered = (l) => /^\s*([A-Ea-e])[).\-:]\s+(\S.*)$/.exec(l.trim());
+  const lettered = lines.map(isLettered).filter((m) => !!m).map((m) => ({ label: `${m[1].toUpperCase()} \u2014 ${m[2]}` }));
+  if (lettered.length >= 2) {
+    const question = lines.filter((l) => !isLettered(l)).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    return { choices: lettered, question };
+  }
+  const MARKER = /\(([A-Ea-e])\)\s*/g;
+  const marks = [...text.matchAll(MARKER)];
+  const inOrder = marks.length >= 2 && marks.every((m, i) => m[1].toUpperCase() === String.fromCharCode(65 + i));
+  if (inOrder) {
+    const first = marks[0].index ?? 0;
+    const parts = marks.map((m, i) => {
+      const start = (m.index ?? 0) + m[0].length;
+      const end = i + 1 < marks.length ? marks[i + 1].index ?? text.length : text.length;
+      return { letter: m[1].toUpperCase(), body: text.slice(start, end).trim().replace(/\s+/g, " ") };
+    }).filter((p) => p.body);
+    if (parts.length >= 2) {
+      const question = text.slice(0, first).replace(/\s*(Se\u00e7enekler|Options|Choices)\s*:?\s*$/i, "").trim();
+      return {
+        choices: parts.map((p) => ({ label: `${p.letter} \u2014 ${clipLabel(p.body)}`, description: p.body })),
+        question: question || text
+      };
+    }
+  }
+  return { choices: [], question: text };
+}
+var clipLabel = (body) => {
+  const cut = body.replace(/^\[[^\]]*\]\s*/, "");
+  const stop = cut.search(/[—–.;:]\s/);
+  const head = stop > 12 ? cut.slice(0, stop) : cut;
+  return head.length > 72 ? `${head.slice(0, 71)}\u2026` : head;
+};
+
+// src/engine/writer-registry.ts
+var askUserParams = z5.object({
+  question: z5.string(),
+  // For a multiple-choice question, list the choices here → the UI shows a selectable checkbox/radio list
+  // (arrow keys + Enter) instead of a free-text box. Omit for an open-ended question.
+  //
+  // A choice may be a plain string, or an object carrying what the label alone cannot say: a one-line
+  // `description`, and a `preview` rendered in a panel beside the list while that option is focused. Use the
+  // rich form when the decision turns on the trade-offs rather than the name (e.g. "which approach?").
+  options: z5.array(z5.union([
+    z5.string(),
+    z5.object({ label: z5.string(), description: z5.string().optional(), preview: z5.string().optional() })
+  ])).optional().describe(
+    "The choices, when the question has discrete answers \u2014 the UI renders a selectable list instead of a free-text box. Omit for an open-ended question. A choice may be a plain string, or an object with a one-line `description` and a `preview` shown beside the list; use the rich form when the decision turns on trade-offs rather than on the name."
+  ),
+  multiSelect: z5.boolean().optional().describe(
+    "True when the user may pick more than one (checkboxes); omitted means pick exactly one (radio)."
+  ),
+  /**
+   * What the user has to DO before they can answer — one action per entry.
+   *
+   * Present ⇒ this is a hand-off, not a question: the run has stopped because only a person can carry the
+   * next step, and the UI says so rather than showing a bare "? Question".
+   */
+  steps: z5.array(z5.string()).optional().describe(
+    'What the user has to DO before they can answer \u2014 one action per entry. Supplying this makes it a HAND-OFF rather than a question: the run has stopped because only a person can carry the next step, and the UI says so instead of showing a bare "? Question". Use it whenever you are asking someone to go and perform something and report back; leave it out when you only want an answer.'
+  )
+});
+var POINTS_ELSEWHERE = /\b(above|below|earlier|previously|as listed|as described)\b|yukarı|aşağı|altında|önceki|birazdan|listelenen/i;
+var ITEM_REFERENCE = /(?:^|[^\w])(?:q|soru|question|madde|item)\s*\.?\s*(\d{1,2})\b/gi;
+var ITEM_STATED = /^[\s>*\-–—#]*(?:q|soru|question|madde|item)\s*\.?\s*\d{1,2}\s*[:).]/gim;
+function danglingItems(question) {
+  const referenced = new Set([...question.matchAll(ITEM_REFERENCE)].map((m) => Number(m[1])));
+  if (referenced.size < 2) return [];
+  const stated = question.match(ITEM_STATED)?.length ?? 0;
+  return stated >= referenced.size ? [] : [...referenced].sort((a, b) => a - b);
+}
+var ENUMERATOR = /(?:^|[^\w])\(?(\d{1,2})[).:]/g;
+function packedQuestions(question) {
+  if ((question.match(/\?/g)?.length ?? 0) < 2) return 0;
+  const numbered = new Set([...question.matchAll(ENUMERATOR)].map((m) => Number(m[1])));
+  return numbered.size;
+}
+var ONE_AT_A_TIME = "This tool asks ONE question and takes ONE answer. Ask the first one on its own, with its own `options`, and call this tool again for the next once you have the answer \u2014 the answer to one of these usually changes what the next one should be.";
+function buildAskUserTool(askUser, normalize) {
+  return {
+    name: "ask_user",
+    description: 'Ask the user ONE question and get their answer. Several decisions are several calls: ask the first, read the answer, then ask the next \u2014 the user has one answer field, so four questions in one box means four decisions they must hold in their head and answer in prose. For a multiple-choice question, pass `options` (the choices) \u2014 the UI shows a selectable list the user checks off; set `multiSelect: true` when they may pick several. Omit `options` for an open-ended (free-text) question. An option may be a plain string, or {label, description, preview} when the decision turns on trade-offs the label cannot carry \u2014 the preview is shown beside the list as the user moves the cursor. A `label` is a SHORT single line (a few words, no line breaks): it is a name for the choice, not the argument for it. Put the reasoning in `description` (one sentence) and the detail in `preview`. If you have findings to report, WRITE THEM as your message before calling this \u2014 a question that says "the evaluation is above" when you never wrote one leaves the user choosing between options whose basis they cannot see. The user may attach a free-text note to their choice, which arrives appended to the answer.\n\nWhen you need the user to DO something first \u2014 click through a screen, run a scenario, look at a network response \u2014 put each action in `steps`, one per entry, and ask in `question` for what they should report back. The user reads THIS BOX and the chat; a file you wrote is not on their screen, so "the steps above" points at nothing they can see. With `steps` the UI shows a hand-off \u2014 the numbered actions and then the question \u2014 instead of a bare question.',
+    permissionLevel: "safe",
+    parameters: askUserParams,
+    run: async (rawArgs, ctx) => {
+      const parsed = askUserParams.safeParse(rawArgs);
+      if (!parsed.success) {
+        return { content: `ask_user: invalid args: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
+      }
+      const { question, options, multiSelect, steps } = parsed.data;
+      const asker = ctx.role || ctx.model ? { asker: { ...ctx.role ? { role: ctx.role } : {}, ...ctx.model ? { model: ctx.model } : {} } } : {};
+      if (POINTS_ELSEWHERE.test(question) && !steps?.length && !ctx.said?.trim()) {
+        return {
+          content: "ask_user: this question refers to something the user cannot see. You wrote no message this turn, so there is nothing above it \u2014 and a file you wrote is not on their screen. Put what they must do in `steps` (one action per entry), or write it out in `question`, and ask again.",
+          isError: true
+        };
+      }
+      const dangling = danglingItems(question);
+      if (dangling.length && !steps?.length && !ctx.said?.trim()) {
+        return {
+          content: `ask_user: this asks the user to answer ${dangling.map((n) => `Q${n}`).join(", ")}, and none of them is on their screen \u2014 you did not write them this turn, and a file you wrote is not something they are looking at. ${ONE_AT_A_TIME}`,
+          isError: true
+        };
+      }
+      const packed = packedQuestions(question);
+      if (packed >= 2 && !steps?.length && !options?.length) {
+        return {
+          content: `ask_user: this is ${packed} questions in one box, and the user has one answer field for all of them. ${ONE_AT_A_TIME}`,
+          isError: true
+        };
+      }
+      if ((!options || options.length === 0) && !steps?.length && looksLikeChoices(question)) {
+        const found = extractChoicesFrom(question);
+        if (found.choices.length >= 2) {
+          return { content: await askUser(found.question, { options: found.choices, ...asker }), isError: false };
+        }
+        if (normalize) {
+          try {
+            const n = await normalize(question);
+            if (n.options.length > 0) {
+              return { content: await askUser(n.question, { options: n.options, multiSelect: n.multiSelect, ...asker }), isError: false };
+            }
+          } catch {
+          }
+        }
+      }
+      return { content: await askUser(question, { options, multiSelect, steps, ...asker }), isError: false };
+    }
+  };
+}
+function writerRegistry(skillRegistry, extra = []) {
+  const r = new ToolRegistry();
+  r.register(readFileTool);
+  r.register(writeFileTool);
+  r.register(editFileTool);
+  r.register(grepTool);
+  r.register(globTool);
+  r.register(buildSkillTool(skillRegistry));
+  for (const t of extra) r.register(t);
+  return r;
+}
+
+// src/engine/role-fitness.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname as dirname2 } 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(readFileSync(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 {
+      mkdirSync(dirname2(this.path), { recursive: true });
+      writeFileSync(this.path, JSON.stringify(this.list(), null, 2), "utf8");
+    } catch {
+    }
+  }
+};
+
+// src/engine/routing.ts
+import { z as z6 } 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 words = (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 = words(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/engine/routing.ts
+var RouteSchema = z6.object({
+  role: z6.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 z7 } from "zod";
+var CommitSchema = z7.object({
+  message: z7.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/engine/touched.ts
+async function changedPaths(cwd, git = defaultGitRunner) {
+  const res = await git(["status", "--porcelain", "-uall"], cwd);
+  if (res.code !== 0) return [];
+  const out = [];
+  for (const line of res.stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const path = line.slice(3).trim();
+    const arrow = path.lastIndexOf(" -> ");
+    const p = arrow >= 0 ? path.slice(arrow + 4) : path;
+    out.push(p.startsWith('"') && p.endsWith('"') ? p.slice(1, -1) : p);
+  }
+  return out;
+}
+async function reconcileTouched(deps, cwd, touched, git = defaultGitRunner) {
+  let changed;
+  try {
+    changed = await changedPaths(cwd, git);
+  } catch {
+    return [];
+  }
+  const known = new Set(touched);
+  const extra = changed.filter((p) => !known.has(p));
+  for (const p of extra) {
+    touched.push(p);
+    try {
+      await commitFile(deps, cwd, p, git);
+    } catch {
+    }
+  }
+  return extra;
+}
+
+// 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/group-notes.ts
+function subjectOf(note) {
+  const path = /\b((?:[\w.-]+\/)+[\w.-]+\.(?:cs|ts|tsx|json|sql|md))\b/.exec(note)?.[1];
+  if (path) return path.split("/").pop().replace(/\.\w+$/, "");
+  return /\b([A-Z][a-z]+(?:[A-Z][a-z0-9]+){1,})\b/.exec(note)?.[1];
+}
+function groupNotes(notes) {
+  const order = [];
+  const bySubject = /* @__PURE__ */ new Map();
+  const loose = [];
+  for (const note of notes) {
+    const s = subjectOf(note);
+    if (!s) {
+      loose.push(note);
+      continue;
+    }
+    if (!bySubject.has(s)) {
+      bySubject.set(s, []);
+      order.push(s);
+    }
+    bySubject.get(s).push(note);
+  }
+  const blocks = [];
+  for (const s of order) {
+    const group = bySubject.get(s);
+    if (group.length === 1) {
+      loose.push(group[0]);
+      continue;
+    }
+    blocks.push(`${s} \u2014 ${group.length} notes, one subject:
+${group.map((n) => `  - ${n}`).join("\n")}`);
+  }
+  if (loose.length) blocks.push(loose.map((n) => `- ${n}`).join("\n"));
+  return blocks.join("\n\n");
+}
+
+// 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: readFile3 } = await import("fs/promises");
+  const { join: join4 } = 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 readFile3(join4(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));
+  if (deps.askUser) tools.register(buildAskUserTool(deps.askUser));
+  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:
+${groupNotes(task.reviewNotes)}` : `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(" ")}`;
+  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 delegate = deps.delegateTo ? cliFor(chain[0] ?? "") ?? deps.delegateTo : void 0;
+  const systemPrompt = withSkills + law + (delegate ? "" : 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 = {
+    /**
+     * A delegated implementer gets a provider bound to its worktree and allowed to write; every other role
+     * keeps the one the composition root built. Per call rather than shared, because the worktree differs
+     * per task and a provider shared across parallel implementers could only hold one of them.
+     */
+    provider: delegate ? new CliProvider({ kind: delegate, readOnly: false, cwd, ...deps.accounts ? { accounts: deps.accounts } : {} }) : 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 {
+    const alsoChanged = await reconcileTouched(deps, cwd, touched);
+    if (alsoChanged.length) {
+      deps.note?.(`\u{1F4DD} ${alsoChanged.length} file(s) changed outside a write tool \u2014 checkpointed and credited.`);
+    }
+    reinforceTouched(deps, hints.ids, touched, role);
+    reinforceUsed(deps, hints.ids, await writtenText(cwd, touched), role);
+  }
+}
+
+// src/engine/review.ts
+import { existsSync as existsSync3 } from "fs";
+import { isAbsolute, join as join2 } from "path";
+import { z as z8 } from "zod";
+function asChoice(o) {
+  return typeof o === "string" ? { label: o } : o;
+}
+var AssessmentSchema = z8.object({
+  findings: z8.array(z8.object({
+    severity: z8.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: z8.string()
+  })).default([]),
+  recommendation: z8.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 = z8.object({
+  vote: z8.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: z8.string()
+});
+var JudgeSchema = z8.object({
+  decision: z8.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: z8.array(z8.string()),
+  question: z8.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 = 10 * 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 CORROBORATION_FLOOR = 5;
+function corroboratedCriticals(assessments) {
+  const criticals = assessments.flatMap((a) => a.findings.filter((f) => f.severity === "critical").map((f) => ({ lens: a.name, note: f.note })));
+  if (assessments.length < CORROBORATION_FLOOR) return criticals.length;
+  const bySubject = /* @__PURE__ */ new Map();
+  for (const c of criticals) {
+    const key2 = subjectOf(c.note) ?? `${c.lens}:${c.note.slice(0, 40)}`;
+    (bySubject.get(key2) ?? bySubject.set(key2, /* @__PURE__ */ new Set()).get(key2)).add(c.lens);
+  }
+  return [...bySubject.values()].filter((lenses) => lenses.size > 1).length;
+}
+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" && !existsSync3(isAbsolute(target) ? target : join2(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, cleared = []) {
+  const diff = await changeUnderReview(deps, workdir);
+  const scoped = lensesFor(deps.teams.code, diff);
+  const remaining = cleared.length ? scoped.filter((c) => !cleared.includes(c.name)) : scoped;
+  const named = scoped.filter((c) => CORE_CODE_LENSES.includes(c.name));
+  const core = named.length ? named : scoped.slice(0, CORE_CODE_LENSES.length);
+  const team = remaining.length ? remaining : core;
+  const scaled = team.length < deps.teams.code.length;
+  if (!remaining.length) {
+    emit({ kind: "note", text: `\u{1F465} **Team** \u2014 every lens had approved; re-running the ${team.length} core lens(es) on the new code.` });
+  }
+  if (cleared.length) {
+    emit({ kind: "note", text: `\u{1F465} **Team** \u2014 ${team.length} lens(es) to re-run; ${cleared.length} approved on an earlier attempt.` });
+  }
+  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 approvedLenses = [
+    ...cleared,
+    ...assessments.filter((a) => !a.unverified && !a.findings.some((f) => f.severity === "critical")).map((a) => a.name)
+  ];
+  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] };
+  }
+  const corroborated = corroboratedCriticals(assessments);
+  if (crit > 0 && corroborated === 0) {
+    emit({ kind: "note", text: `\u2705 **Team** \u2014 ${crit} critical finding(s), none corroborated by a second lens \u2192 deferred to the revision pass.` });
+  }
+  if (corroborated === 0) {
+    const deferred = [...findingNotes(assessments, "code", ["critical"]), ...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: [], approvedLenses };
+      }
+    }
+    emit({ kind: "note", text: `\u2705 **Team** \u2014 nothing corroborated; ${deferred.length} note(s) deferred to the revision pass.` });
+    return { verdict: "pass", notes: [], deferred, approvedLenses };
+  }
+  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: [], approvedLenses };
+  }
+  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",
+      approvedLenses,
+      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: [], approvedLenses };
+  return { verdict: "fail", approvedLenses, notes: d.feedback.length ? d.feedback : blocking };
+}
+
+// src/engine/acceptance.ts
+import { z as z9 } from "zod";
+
+// src/engine/criterion-commands.ts
+import { spawn as spawn2 } from "child_process";
+var RUNNABLE_COMMANDS = [
+  "dotnet",
+  "npm",
+  "npx",
+  "pnpm",
+  "yarn",
+  "nx",
+  "prettier",
+  "eslint",
+  "tsc",
+  "cargo",
+  "go",
+  "make",
+  "mvn",
+  "gradle"
+];
+var SHELL_SYNTAX = /[;&|><$(){}\n]|`/;
+var CRITERION_TIMEOUT_MS = 10 * 60 * 1e3;
+var MAX_OUTPUT = 2e3;
+function commandsIn(criterion) {
+  const out = [];
+  for (const m of criterion.matchAll(/`([^`\n]+)`/g)) {
+    const span = m[1].trim();
+    if (!span || SHELL_SYNTAX.test(span)) continue;
+    const argv = span.split(/\s+/);
+    if (!RUNNABLE_COMMANDS.includes(argv[0])) continue;
+    out.push(argv);
+  }
+  return out;
+}
+async function runCommand(cwd, argv, timeoutMs = CRITERION_TIMEOUT_MS) {
+  const [bin, ...args] = argv;
+  return new Promise((resolve4) => {
+    let child;
+    try {
+      child = spawn2(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1" } });
+    } catch (e) {
+      resolve4({ argv, passed: false, exitCode: null, timedOut: false, output: e instanceof Error ? e.message : String(e) });
+      return;
+    }
+    let out = "";
+    const take = (d) => {
+      out += d.toString();
+      if (out.length > MAX_OUTPUT * 4) out = out.slice(-MAX_OUTPUT * 2);
+    };
+    child.stdout.on("data", take);
+    child.stderr.on("data", take);
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve4({ argv, passed: false, exitCode: null, timedOut: false, output: e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve4({ argv, passed: !timedOut && code === 0, exitCode: code, timedOut, output: out.slice(-MAX_OUTPUT) });
+    });
+  });
+}
+async function runCriterionCommands(cwd, criteria, timeoutMs = CRITERION_TIMEOUT_MS) {
+  const seen = /* @__PURE__ */ new Set();
+  const argvs = [];
+  for (const c of criteria) {
+    for (const argv of commandsIn(c)) {
+      const key2 = argv.join(" ");
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      argvs.push(argv);
+    }
+  }
+  const runs = [];
+  for (const argv of argvs) runs.push(await runCommand(cwd, argv, timeoutMs));
+  return runs;
+}
+function describeCommandRuns(runs) {
+  if (!runs.length) return "";
+  const lines = runs.map((r) => {
+    const cmd = `\`${r.argv.join(" ")}\``;
+    if (r.timedOut) return `- ${cmd} \u2014 TIMED OUT after ${Math.round(CRITERION_TIMEOUT_MS / 6e4)} minutes.`;
+    if (r.passed) return `- ${cmd} \u2014 SUCCEEDED (exit 0).`;
+    return `- ${cmd} \u2014 FAILED (exit ${r.exitCode ?? "none"}):
+\`\`\`
+${r.output.slice(-800)}
+\`\`\``;
+  });
+  return "The harness has already RUN the commands these criteria name, to completion, and this is what happened. Use this as the evidence for any criterion about one of them \u2014 do not run it again, and do not report a criterion unmet because you could not wait for it:\n" + lines.join("\n");
+}
+
+// src/engine/test-runner.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { spawn as spawn3 } from "child_process";
+import { join as join3 } from "path";
+var TEST_TIMEOUT_MS = 6e5;
+var MAX_TEST_OUTPUT = 12e3;
+var PLACEHOLDER = /no test specified/i;
+async function detectTestCommand(cwd) {
+  const pkgPath = join3(cwd, "package.json");
+  if (existsSync4(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
+      const script = pkg.scripts?.test;
+      if (script && !PLACEHOLDER.test(script)) {
+        const runner = existsSync4(join3(cwd, "pnpm-lock.yaml")) ? "pnpm" : existsSync4(join3(cwd, "yarn.lock")) ? "yarn" : existsSync4(join3(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 (existsSync4(join3(cwd, "pytest.ini")) || existsSync4(join3(cwd, "pyproject.toml")) || existsSync4(join3(cwd, "tox.ini"))) {
+    return { argv: ["python3", "-m", "pytest", "-q"], why: "a pytest configuration is present" };
+  }
+  if (existsSync4(join3(cwd, "go.mod"))) return { argv: ["go", "test", "./..."], why: "go.mod is present" };
+  if (existsSync4(join3(cwd, "Cargo.toml"))) return { argv: ["cargo", "test"], why: "Cargo.toml is present" };
+  if (existsSync4(join3(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((resolve4) => {
+    const child = spawn3(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);
+      resolve4({
+        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);
+      resolve4({
+        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
+function normalizeCriterion(s) {
+  return s.toLowerCase().replace(/[`*_]/g, "").replace(/\s+/g, " ").trim().replace(/[.,;:!?…]+$/, "");
+}
+var AcceptanceSchema = z9.object({
+  checks: z9.array(z9.object({
+    criterion: z9.string().describe(
+      "Copy the criterion VERBATIM from the numbered list you were given, including any backticks and punctuation. Do not paraphrase, renumber or reformat it \u2014 it is matched back to the task by text."
+    ),
+    met: z9.boolean(),
+    evidence: z9.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 PROMPT2 = `You are the acceptance gate for one implementation task. You are given the task's acceptance criteria and 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.
+- A criterion about a COMMAND is settled by the run reported to you above, not by looking and not by running it yourself. If that report says the command succeeded, the criterion is met; if it failed, quote the error. Never mark such a criterion unmet for want of waiting.
+- "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.
+- Report EVERY criterion you were given \u2014 one check each, none dropped.
+- Copy each criterion into the "criterion" field VERBATIM from the numbered list, including any backticks and punctuation. It is matched back to the task by text; a paraphrase loses the pairing.
+- Write the evidence in ENGLISH (it is a technical record).`;
+async function verifyAcceptance(deps, card, cwd, emit = () => {
+}, runCommands = runCriterionCommands) {
+  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 commandRuns = await telemetry().span(
+    "stage.criterion_commands",
+    { "hc.stage": "criterion commands" },
+    () => runCommands(cwd, card.acceptance)
+  );
+  for (const r of commandRuns) {
+    emit({ kind: "note", text: r.passed ? `\u2705 \`${r.argv.join(" ")}\` \u2014 exit 0` : `\u274C \`${r.argv.join(" ")}\` \u2014 ${r.timedOut ? "timed out" : `exit ${r.exitCode ?? "none"}`}` });
+  }
+  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)}
+
+${describeCommandRuns(commandRuns)}
+
+${describeDiff(diff)}` };
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    systemPrompt: `${PROMPT2}${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) => [normalizeCriterion(c.criterion), c]));
+  const paired = /* @__PURE__ */ new Map();
+  const usedChecks = /* @__PURE__ */ new Set();
+  const unpairedCriteria = [];
+  for (const c of card.acceptance) {
+    const key2 = normalizeCriterion(c);
+    const hit = byCriterion.get(key2) ?? checks.find((x) => normalizeCriterion(x.criterion).includes(key2.slice(0, 40)));
+    if (hit) {
+      paired.set(c, hit);
+      usedChecks.add(hit);
+    } else unpairedCriteria.push(c);
+  }
+  const unusedChecks = checks.filter((x) => !usedChecks.has(x));
+  if (unpairedCriteria.length === 1 && unusedChecks.length === 1) {
+    paired.set(unpairedCriteria[0], unusedChecks[0]);
+  }
+  const unmet = [];
+  for (const c of card.acceptance) {
+    const hit = paired.get(c);
+    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,
+    // Only what objected last time is asked again — see `runCodeReview`'s `cleared`.
+    card.clearedLenses ?? []
+  );
+  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] };
+  }
+  const approved = v.approvedLenses ?? [];
+  if (approved.length) board.markLensesCleared(taskId, approved);
+  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 z10 } from "zod";
+var MAX_STAGE_EVENTS = 200;
+var stageEventSchema = z10.object({
+  role: z10.string(),
+  action: z10.string(),
+  note: z10.string().optional()
+});
+var cardSchema = z10.object({
+  id: z10.string(),
+  title: z10.string(),
+  column: z10.enum(["TODO", "IN-PROGRESS", "REVIEW", "DONE", "MERGED", "PARKED", "ABANDONED"]),
+  worktree: z10.string().optional(),
+  deps: z10.array(z10.string()),
+  acceptance: z10.array(z10.string()).default([]),
+  // default: boards persisted before the gate existed still load
+  files: z10.array(z10.string()).default([]),
+  // ditto — a board written before file lists existed still loads
+  reviewNotes: z10.array(z10.string()),
+  // Optional rather than defaulted: a board written before this existed must round-trip unchanged, and an
+  // empty list is the same statement as no list at all.
+  clearedLenses: z10.array(z10.string()).optional(),
+  attempts: z10.number(),
+  stageHistory: z10.array(stageEventSchema)
+});
+var boardDataSchema = z10.object({ version: z10.literal(1), cards: z10.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],
+    ...c.clearedLenses?.length ? { clearedLenses: [...c.clearedLenses] } : {},
+    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?.();
+  }
+  /** Remember which lenses approved, so the next attempt does not ask them again. */
+  markLensesCleared(id, lenses) {
+    const c = this.require(id);
+    c.clearedLenses = [.../* @__PURE__ */ new Set([...c.clearedLenses ?? [], ...lenses])];
+    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 {
+  SHORT_CALL_MS,
+  LONG_CALL_MS,
+  CliProvider,
+  subjectOf,
+  asChoice,
+  buildTeamRegistry,
+  buildCouncilRegistry,
+  runReviewLoop,
+  writeFileTool,
+  editFileTool,
+  shellTool,
+  createDefaultRegistry,
+  changedByMerge,
+  refreshAfterChange,
+  routeTask,
+  normalizeQuestion,
+  extractChoicesFrom,
+  buildAskUserTool,
+  writerRegistry,
+  commitFile,
+  commitStep,
+  squashTask,
+  WHAT_IT_COST,
+  runImplementer,
+  RoleFitness,
+  worktreeState,
+  hasWorkAgainst,
+  runCycleWithRole,
+  runTaskCycle,
+  Board
+};