@hizliemre/horse-code 0.1.0

package/dist/chunk-2DGO2BUB.js

@@ -0,0 +1,4490 @@
+import {
+  buildAskUserTool,
+  extractChoicesFrom,
+  normalizeQuestion,
+  respondIn,
+  writerRegistry
+} from "./chunk-F2IALVBU.js";
+import {
+  Board,
+  LONG_CALL_MS,
+  WHAT_IT_COST,
+  applySkills,
+  buildRememberTool,
+  buildSkillTool,
+  changedByMerge,
+  commitFile,
+  commitStep,
+  constitutionNote,
+  constitutionPath,
+  createDefaultRegistry,
+  describeInherited,
+  describeTopUp,
+  editFileTool,
+  hasWorkAgainst,
+  nextFeatureSlug,
+  placedSkills,
+  readOnlyRegistry,
+  refreshAfterChange,
+  routeSkills,
+  routeTask,
+  runCycleWithRole,
+  runImplementer,
+  runReviewLoop,
+  runReviewer,
+  scaffoldFeature,
+  squashTask,
+  worktreeState,
+  writeFileTool
+} from "./chunk-3XVZXTB6.js";
+import {
+  resolveMainBranch
+} from "./chunk-QF4MP6BS.js";
+import {
+  askInUserLanguage,
+  inUserLanguage
+} from "./chunk-HBSC2HT2.js";
+import {
+  clearCheckpoint,
+  isContinuePrompt,
+  readCheckpoint,
+  writeCheckpoint
+} from "./chunk-FGVJFMK5.js";
+import {
+  defaultGitRunner
+} from "./chunk-IW2KBAVZ.js";
+import {
+  BATCH_TOOLS_NOTE,
+  SHORT_TTL_MS,
+  confidenceOf,
+  contextTools,
+  deriveAnchors,
+  deriveTags,
+  hashAnchors,
+  importanceOf,
+  isExpired,
+  memoryHints,
+  projectToolsNote,
+  readFileTool,
+  reinforceTouched,
+  reinforceUsed,
+  relationStrength,
+  supersedes,
+  verifyAnchors
+} from "./chunk-TOPZL5SU.js";
+import {
+  ToolRegistry,
+  handedOver,
+  runStructuredRole,
+  runToCompletion,
+  sanitizeForJson,
+  stripThinking,
+  telemetry
+} from "./chunk-YILDXPSI.js";
+import {
+  TRACE_INDEX,
+  mergeTraceIndexes,
+  parseTraceIndex,
+  serializeTraceIndex,
+  traceRootRel
+} from "./chunk-FFYBY2NA.js";
+import {
+  loadGraphSync
+} from "./chunk-PGOYDOI4.js";
+import {
+  inLinkedWorktree,
+  sessionBase,
+  stateRoot,
+  writableStateRoot
+} from "./chunk-SSDLHWSF.js";
+import {
+  writeAtomic
+} from "./chunk-B67BK5GQ.js";
+
+// src/providers/sse.ts
+function* handleLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith("data:")) {
+    const payload = trimmed.slice(5).trim();
+    if (payload === "[DONE]") return true;
+    if (payload) yield { kind: "data", value: payload };
+    return false;
+  }
+  if (trimmed.startsWith(":")) {
+    const value = trimmed.slice(1).trim();
+    if (value) yield { kind: "comment", value };
+  }
+  return false;
+}
+async function* parseSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const isDone = yield* handleLine(line);
+        if (isDone) return;
+      }
+    }
+    if (buffer) {
+      yield* handleLine(buffer);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/providers/openai.ts
+function objectArgs(args) {
+  if (!args || !args.trim()) return "{}";
+  try {
+    const v = JSON.parse(args);
+    return v && typeof v === "object" && !Array.isArray(v) ? args : "{}";
+  } catch {
+    return "{}";
+  }
+}
+function toOpenAIMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      return {
+        role: "assistant",
+        content: m.content || null,
+        tool_calls: m.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: objectArgs(tc.arguments) }
+        }))
+      };
+    }
+    if (m.role === "tool") {
+      return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+    }
+    if (m.images?.length) {
+      const parts = [];
+      if (m.content) parts.push({ type: "text", text: m.content });
+      for (const url of m.images) parts.push({ type: "image_url", image_url: { url } });
+      const withImg = { role: m.role, content: parts };
+      if (m.name) withImg.name = m.name;
+      return withImg;
+    }
+    const base = { role: m.role, content: m.content };
+    if (m.name) base.name = m.name;
+    return base;
+  });
+}
+function toOpenAITools(tools) {
+  if (!tools.length) return void 0;
+  return tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+}
+function toOpenAIBody(req) {
+  const body = {
+    model: req.model,
+    messages: toOpenAIMessages(req.messages),
+    stream: true,
+    // Ask the backend to append a final chunk carrying token usage (streaming otherwise omits it).
+    stream_options: { include_usage: true }
+  };
+  const tools = toOpenAITools(req.tools);
+  if (tools) {
+    body.tools = tools;
+    body.tool_choice = "auto";
+    body.parallel_tool_calls = true;
+  }
+  return body;
+}
+function mapFinishReason(reason) {
+  if (reason === "tool_calls") return "tool_calls";
+  if (reason === "length") return "length";
+  return "stop";
+}
+
+// src/providers/anthropic.ts
+var MAX_OUTPUT_TOKENS = 64e3;
+function isAnthropicModel(model) {
+  return /(^|\/)(claude|fable|mythos)/i.test(model) || /claude/i.test(model);
+}
+function imageSource(uri) {
+  const m = /^data:([^;,]+);base64,(.*)$/s.exec(uri);
+  return m?.[1] && m[2] ? { type: "base64", media_type: m[1], data: m[2] } : void 0;
+}
+function toolInput(args) {
+  if (!args?.trim()) return {};
+  try {
+    const v = JSON.parse(args);
+    return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+  } catch {
+    return {};
+  }
+}
+function toAnthropicMessages(messages) {
+  const system = [];
+  const turns = [];
+  const push = (role, blocks) => {
+    if (!blocks.length) return;
+    const last = turns[turns.length - 1];
+    if (last && last.role === role) last.content.push(...blocks);
+    else turns.push({ role, content: blocks });
+  };
+  for (const m of messages) {
+    if (m.role === "system") {
+      if (m.content.trim()) system.push(m.content);
+      continue;
+    }
+    if (m.role === "tool") {
+      push("user", [{
+        type: "tool_result",
+        tool_use_id: m.toolCallId ?? "",
+        content: m.content || "(no output)"
+      }]);
+      continue;
+    }
+    const blocks = [];
+    for (const uri of m.images ?? []) {
+      const source = imageSource(uri);
+      if (source) blocks.push({ type: "image", source });
+    }
+    if (m.content.trim()) blocks.push({ type: "text", text: m.content });
+    for (const tc of m.toolCalls ?? []) {
+      blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: toolInput(tc.arguments) });
+    }
+    push(m.role === "assistant" ? "assistant" : "user", blocks);
+  }
+  return { system: system.join("\n\n"), turns };
+}
+function toAnthropicBody(req) {
+  const { system, turns } = toAnthropicMessages(req.messages);
+  const body = {
+    model: req.model,
+    max_tokens: MAX_OUTPUT_TOKENS,
+    stream: true,
+    messages: turns
+  };
+  if (system) body.system = system;
+  if (req.tools.length) {
+    body.tools = req.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters
+    }));
+  }
+  if (req.effort) body.output_config = { effort: req.effort };
+  return body;
+}
+function mapStopReason(reason) {
+  if (reason === "tool_use") return "tool_calls";
+  if (reason === "max_tokens") return "length";
+  return "stop";
+}
+var PROGRESS_EVERY = 64;
+function pathOf(partial) {
+  const m = /"(?:path|file|filename|target)"\s*:\s*"((?:[^"\\]|\\.)*)/.exec(partial);
+  return m?.[1] ? m[1].replace(/\\(.)/g, "$1") : void 0;
+}
+var AnthropicDecoder = class {
+  blocks = /* @__PURE__ */ new Map();
+  stop = "stop";
+  inTokens = 0;
+  outTokens = 0;
+  cachedTokens = 0;
+  sawUsage = false;
+  push(chunk) {
+    const c = chunk;
+    const out = [];
+    switch (c.type) {
+      case "message_start": {
+        const u = c.message?.usage;
+        if (u) {
+          this.sawUsage = true;
+          this.inTokens = u.input_tokens ?? 0;
+          this.cachedTokens = u.cache_read_input_tokens ?? 0;
+        }
+        break;
+      }
+      case "content_block_start": {
+        const b = c.content_block;
+        if (b && c.index !== void 0) {
+          this.blocks.set(c.index, {
+            type: b.type ?? "text",
+            id: b.id ?? "",
+            name: b.name ?? "",
+            args: "",
+            emitted: 0
+          });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const b = c.index === void 0 ? void 0 : this.blocks.get(c.index);
+        if (c.delta?.type === "text_delta" && c.delta.text) {
+          out.push({ type: "text-delta", text: c.delta.text });
+        } else if (c.delta?.type === "input_json_delta" && b) {
+          b.args += c.delta.partial_json ?? "";
+          if (b.name && b.args.length - b.emitted >= PROGRESS_EVERY) {
+            b.emitted = b.args.length;
+            out.push({ type: "tool-progress", name: b.name, chars: b.args.length, path: pathOf(b.args) });
+          }
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const b = c.index === void 0 ? void 0 : this.blocks.get(c.index);
+        if (b?.type === "tool_use") {
+          out.push({ type: "tool-call", toolCall: { id: b.id, name: b.name, arguments: b.args || "{}" } });
+        }
+        if (c.index !== void 0) this.blocks.delete(c.index);
+        break;
+      }
+      case "message_delta": {
+        if (c.delta?.stop_reason) this.stop = mapStopReason(c.delta.stop_reason);
+        if (c.usage) {
+          this.sawUsage = true;
+          this.outTokens = c.usage.output_tokens ?? this.outTokens;
+          if (!this.inTokens) this.inTokens = c.usage.input_tokens ?? 0;
+        }
+        break;
+      }
+      case "error": {
+        out.push({ type: "error", message: c.error?.message ?? "anthropic: stream error", retryable: true });
+        break;
+      }
+      default:
+        break;
+    }
+    return out;
+  }
+  /** Usage as the transport should report it, or undefined when the stream never said. */
+  usage() {
+    return this.sawUsage ? { promptTokens: this.inTokens, completionTokens: this.outTokens, cachedTokens: this.cachedTokens } : void 0;
+  }
+  finishReason() {
+    return this.stop;
+  }
+};
+
+// src/providers/omniroute.ts
+async function* withIdleTimeout(source, idleMs, onIdle) {
+  const it = source[Symbol.asyncIterator]();
+  for (; ; ) {
+    let timer;
+    const idle = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("idle"), idleMs);
+    });
+    const next = it.next();
+    next.catch(() => {
+    });
+    const winner = await Promise.race([next, idle]);
+    if (timer) clearTimeout(timer);
+    if (winner === "idle") {
+      onIdle?.();
+      void Promise.resolve(it.return?.(void 0)).catch(() => {
+      });
+      throw new Error(`omniroute: stream stalled (no data for ${Math.round(idleMs / 1e3)}s) \u2014 aborted`);
+    }
+    if (winner.done) return;
+    yield winner.value;
+  }
+}
+async function readErrorMessage(res) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return `omniroute ${res.status}`;
+  }
+  const err = body.error;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object" && "message" in err) {
+    return String(err.message);
+  }
+  return `omniroute ${res.status}`;
+}
+function isRetryableStatus(status) {
+  return status === 429 || status === 404 || status >= 500;
+}
+function isCapabilityError(message) {
+  return /long[- ]context|not (yet )?available for this subscription|context[- ](length|window)|too many tokens|maximum context|unsupported|not supported/i.test(message);
+}
+function isUnknownModelError(message) {
+  return /unable to determine provider for model|unknown model|model not found|no such model|invalid model/i.test(message);
+}
+function pathOf2(args) {
+  return args.match(/"path"\s*:\s*"([^"\\]+)"/)?.[1];
+}
+function argumentsComplete(args) {
+  if (!args.trim()) return true;
+  try {
+    JSON.parse(args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isCallerAbort(signal) {
+  return signal.aborted && signal.reason?.name !== "TimeoutError";
+}
+function isDeadline(signal) {
+  return signal.aborted && signal.reason?.name === "TimeoutError";
+}
+var OmniRouteProvider = class {
+  apiKey;
+  baseUrl;
+  fetchFn;
+  idleMs;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.fetchFn = opts.fetch ?? globalThis.fetch;
+    this.idleMs = opts.idleTimeoutMs ?? 12e4;
+  }
+  async *chat(req, signal) {
+    const native = isAnthropicModel(req.model);
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream"
+    };
+    if (native) headers["anthropic-version"] = "2023-06-01";
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    const idleAc = new AbortController();
+    const combined = AbortSignal.any([signal, idleAc.signal]);
+    let res;
+    try {
+      res = await this.fetchFn(`${this.baseUrl}${native ? "/v1/messages" : "/api/v1/chat/completions"}`, {
+        method: "POST",
+        headers,
+        // Sanitised at the socket, not at each of the dozens of places that build a prompt — see
+        // src/core/surrogates.ts for the four-hour run this cost.
+        body: JSON.stringify(sanitizeForJson(native ? toAnthropicBody(req) : toOpenAIBody(req))),
+        signal: combined
+      });
+    } catch (e) {
+      if (isCallerAbort(signal)) {
+        yield { type: "error", message: "cancelled", retryable: false };
+        return;
+      }
+      if (isDeadline(signal)) {
+        yield { type: "error", message: "the model did not answer within its deadline", retryable: true };
+        return;
+      }
+      yield { type: "error", message: e instanceof Error ? e.message : String(e), retryable: true };
+      return;
+    }
+    if (!res.ok) {
+      const message = await readErrorMessage(res);
+      const capability = isCapabilityError(message);
+      const unknownModel = isUnknownModelError(message);
+      yield {
+        type: "error",
+        message,
+        retryable: isRetryableStatus(res.status) || capability || unknownModel,
+        ...capability && { capability: true },
+        ...unknownModel && { noBench: true }
+      };
+      return;
+    }
+    const stream = res.body;
+    if (!stream) {
+      yield { type: "error", message: "omniroute: empty response body" };
+      return;
+    }
+    const decoder = native ? new AnthropicDecoder() : void 0;
+    const toolCalls = /* @__PURE__ */ new Map();
+    const lastProgress = /* @__PURE__ */ new Map();
+    let finishReason = "stop";
+    let sawText = false;
+    let usage;
+    const billed = {};
+    try {
+      for await (const line of withIdleTimeout(parseSSE(stream), this.idleMs, () => idleAc.abort())) {
+        if (line.kind === "comment") {
+          const m = line.value.match(/^x-omniroute-tokens-(in|out)\s*=\s*(\d+)/i);
+          if (m) billed[m[1] === "in" ? "in" : "out"] = Number(m[2]);
+          continue;
+        }
+        let chunk;
+        try {
+          chunk = JSON.parse(line.value);
+        } catch {
+          continue;
+        }
+        if (decoder) {
+          for (const ev of decoder.push(chunk)) yield ev;
+          continue;
+        }
+        const u = chunk.usage;
+        if (u) usage = {
+          promptTokens: u.prompt_tokens ?? 0,
+          completionTokens: u.completion_tokens ?? 0,
+          cachedTokens: u.prompt_tokens_details?.cached_tokens ?? 0
+        };
+        const choice = chunk?.choices?.[0];
+        if (!choice) continue;
+        const delta = choice.delta ?? {};
+        if (typeof delta.content === "string" && delta.content.length) {
+          sawText = true;
+          yield { type: "text-delta", text: delta.content };
+        }
+        const deltaCalls = delta.tool_calls;
+        if (Array.isArray(deltaCalls)) {
+          for (const tc of deltaCalls) {
+            const idx = tc.index ?? 0;
+            const acc = toolCalls.get(idx) ?? { id: "", name: "", arguments: "" };
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.name = tc.function.name;
+            if (tc.function?.arguments) acc.arguments += tc.function.arguments;
+            toolCalls.set(idx, acc);
+            if (acc.name && acc.arguments.length - (lastProgress.get(idx) ?? 0) >= 64) {
+              lastProgress.set(idx, acc.arguments.length);
+              yield { type: "tool-progress", name: acc.name, chars: acc.arguments.length, path: pathOf2(acc.arguments) };
+            }
+          }
+        }
+        if (choice.finish_reason) finishReason = mapFinishReason(choice.finish_reason);
+      }
+    } catch (e) {
+      if (isCallerAbort(signal)) {
+        yield { type: "error", message: "cancelled", retryable: false };
+        return;
+      }
+      if (isDeadline(signal)) {
+        yield { type: "error", message: "the model did not answer within its deadline", retryable: true };
+        return;
+      }
+      yield { type: "error", message: e instanceof Error ? e.message : String(e), retryable: true };
+      return;
+    }
+    const cut = sawText ? void 0 : [...toolCalls.values()].find((a) => !argumentsComplete(a.arguments));
+    if (cut) {
+      yield {
+        type: "error",
+        message: `the stream ended in the middle of ${cut.name || "a tool call"}'s arguments`,
+        retryable: true
+      };
+      return;
+    }
+    for (const acc of toolCalls.values()) {
+      const toolCall = { id: acc.id, name: acc.name, arguments: acc.arguments };
+      yield { type: "tool-call", toolCall };
+    }
+    if (decoder) {
+      finishReason = decoder.finishReason();
+      usage = decoder.usage() ?? usage;
+    }
+    if (billed.in !== void 0 || billed.out !== void 0) {
+      yield { type: "usage", promptTokens: billed.in ?? 0, completionTokens: billed.out ?? 0 };
+    } else if (usage) {
+      yield { type: "usage", promptTokens: usage.promptTokens, completionTokens: usage.completionTokens, cachedTokens: usage.cachedTokens };
+    } else {
+      const inHeader = res.headers.get("X-OmniRoute-Tokens-In");
+      const outHeader = res.headers.get("X-OmniRoute-Tokens-Out");
+      if (inHeader !== null || outHeader !== null) {
+        yield {
+          type: "usage",
+          promptTokens: Number(inHeader) || 0,
+          completionTokens: Number(outHeader) || 0
+        };
+      }
+    }
+    yield { type: "done", finishReason };
+  }
+};
+
+// src/adapters/pr.ts
+import { spawn } from "child_process";
+import { writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+var defaultCmdRunner = (cmd, args, cwd) => new Promise((resolve) => {
+  let stdout = "";
+  let stderr = "";
+  let child;
+  try {
+    child = spawn(cmd, args, { cwd });
+  } catch (e) {
+    resolve({ stdout, stderr: e instanceof Error ? e.message : String(e), code: -1 });
+    return;
+  }
+  child.stdout?.on("data", (d) => stdout += d.toString());
+  child.stderr?.on("data", (d) => stderr += d.toString());
+  child.on("error", (e) => resolve({ stdout, stderr: stderr + e.message, code: -1 }));
+  child.on("close", (code) => resolve({ stdout, stderr, code: code ?? -1 }));
+});
+function parsePRNumber(url) {
+  const m = url.match(/\/(?:pull|pullrequest)\/(\d+)/);
+  return m ? Number(m[1]) : void 0;
+}
+function joinComments(comments) {
+  return comments.map((c, i) => `${i + 1}. ${c}`).join("\n");
+}
+function ghAdapter(run, cwd) {
+  let prNumber;
+  return {
+    async createPR(input) {
+      const r = await run("gh", ["pr", "create", "--base", input.base, "--head", input.branch, "--title", input.title, "--body", input.body], cwd);
+      if (r.code !== 0) {
+        const open = await run("gh", ["pr", "list", "--head", input.branch, "--base", input.base, "--state", "open", "--json", "number,url"], cwd);
+        try {
+          const [first] = JSON.parse(open.stdout);
+          if (first?.number !== void 0) {
+            prNumber = first.number;
+            return { url: first.url ?? "", number: prNumber };
+          }
+        } catch {
+        }
+        throw new Error(`gh pr create failed (${r.code}): ${r.stderr.trim()}`);
+      }
+      const url = r.stdout.trim();
+      prNumber = parsePRNumber(url);
+      return { url, number: prNumber };
+    },
+    async postComments(comments, outcome) {
+      if (prNumber === void 0 || comments.length === 0 && outcome !== "approved") return void 0;
+      const r = await run("gh", ["pr", "comment", String(prNumber), "--body", reviewThreadBody(comments, outcome)], cwd);
+      if (r.code !== 0) throw new Error(`gh pr comment failed (${r.code}): ${r.stderr.trim()}`);
+      return void 0;
+    },
+    async replyAndResolve(_threadId, body) {
+      if (prNumber === void 0) return;
+      const r = await run("gh", ["pr", "comment", String(prNumber), "--body", body], cwd);
+      if (r.code !== 0) throw new Error(`gh pr comment failed (${r.code}): ${r.stderr.trim()}`);
+    },
+    async resolveOwnThreads() {
+    }
+  };
+}
+function isMachineTitle(title) {
+  return /^hc:\s/.test(title.trim());
+}
+var RESOLVED_STATUS = "fixed";
+function threadIdOf(stdout) {
+  try {
+    const id = JSON.parse(stdout).id;
+    return id === void 0 ? void 0 : String(id);
+  } catch {
+    return void 0;
+  }
+}
+var REVIEW_MARKER = "**horse-code review**";
+function ownOpenThreads(list) {
+  return (list.value ?? []).filter((t) => (t.status ?? "").toLowerCase() === "active").filter((t) => (t.comments ?? []).some((c) => (c.content ?? "").includes(REVIEW_MARKER))).map((t) => String(t.id ?? "")).filter(Boolean);
+}
+function reviewThreadBody(comments, outcome = "changes") {
+  if (outcome === "approved") {
+    return `${REVIEW_MARKER} \u2014 approved. The merged diff was reviewed and no changes are requested.` + (comments.length ? `
+
+${joinComments(comments)}` : "");
+  }
+  return `${REVIEW_MARKER} \u2014 ${comments.length} change(s) requested:
+
+${joinComments(comments)}`;
+}
+function azAdapter(run, cwd, log) {
+  let threadSeq = 0;
+  let prNumber;
+  let project;
+  let repositoryId;
+  return {
+    async createPR(input) {
+      const adopt = (j) => {
+        if (typeof j?.pullRequestId !== "number") return void 0;
+        prNumber = j.pullRequestId;
+        repositoryId = j.repository?.id;
+        project = j.repository?.project?.name;
+        return j.url ?? `(azure PR #${prNumber})`;
+      };
+      const r = await run("az", ["repos", "pr", "create", "--source-branch", input.branch, "--target-branch", input.base, "--title", input.title, "--description", input.body, "-o", "json"], cwd);
+      if (r.code !== 0) {
+        const open = await run("az", ["repos", "pr", "list", "--source-branch", input.branch, "--target-branch", input.base, "--status", "active", "-o", "json"], cwd);
+        try {
+          const existing = JSON.parse(open.stdout)[0];
+          const url2 = adopt(existing);
+          if (url2 !== void 0) {
+            if (isMachineTitle(existing?.title ?? "")) {
+              await run("az", ["repos", "pr", "update", "--id", String(prNumber), "--title", input.title, "--description", input.body, "-o", "none"], cwd);
+            }
+            return { url: url2, number: prNumber };
+          }
+        } catch {
+        }
+        throw new Error(`az repos pr create failed (${r.code}): ${r.stderr.trim()}`);
+      }
+      let url = "";
+      try {
+        url = adopt(JSON.parse(r.stdout)) ?? r.stdout.trim();
+      } catch {
+        url = r.stdout.trim() || "(azure PR)";
+      }
+      return { url, number: prNumber };
+    },
+    async postComments(comments, outcome) {
+      if (comments.length === 0 && outcome !== "approved") return void 0;
+      if (prNumber === void 0 || !project || !repositoryId) {
+        log(`Azure PR comments could not be addressed (no pull request identity):
+${joinComments(comments)}`);
+        return void 0;
+      }
+      const file = join(tmpdir(), `hc-pr-thread-${prNumber}-${process.pid}-${threadSeq++}.json`);
+      const body = {
+        comments: [{ parentCommentId: 0, content: reviewThreadBody(comments, outcome), commentType: "text" }],
+        status: outcome === "approved" ? "closed" : "active"
+      };
+      await writeFile(file, JSON.stringify(body), "utf8");
+      try {
+        const r = await run("az", [
+          "devops",
+          "invoke",
+          "--area",
+          "git",
+          "--resource",
+          "pullRequestThreads",
+          "--route-parameters",
+          `project=${project}`,
+          `repositoryId=${repositoryId}`,
+          `pullRequestId=${prNumber}`,
+          "--http-method",
+          "POST",
+          "--in-file",
+          file,
+          "--api-version",
+          "7.1",
+          "-o",
+          "json"
+        ], cwd);
+        if (r.code !== 0) throw new Error(`az devops invoke pullRequestThreads failed (${r.code}): ${r.stderr.trim()}`);
+        return threadIdOf(r.stdout);
+      } finally {
+        await rm(file, { force: true });
+      }
+    },
+    async replyAndResolve(threadId, body) {
+      if (prNumber === void 0 || !project || !repositoryId || !threadId) return;
+      const route = [
+        "--route-parameters",
+        `project=${project}`,
+        `repositoryId=${repositoryId}`,
+        `pullRequestId=${prNumber}`,
+        `threadId=${threadId}`
+      ];
+      const replyFile = join(tmpdir(), `hc-pr-reply-${prNumber}-${process.pid}-${threadSeq++}.json`);
+      await writeFile(replyFile, JSON.stringify({ parentCommentId: 1, content: body, commentType: "text" }), "utf8");
+      try {
+        const r = await run("az", [
+          "devops",
+          "invoke",
+          "--area",
+          "git",
+          "--resource",
+          "pullRequestThreadComments",
+          ...route,
+          "--http-method",
+          "POST",
+          "--in-file",
+          replyFile,
+          "--api-version",
+          "7.1",
+          "-o",
+          "none"
+        ], cwd);
+        if (r.code !== 0) {
+          log(`Could not reply to pull request thread ${threadId}: ${r.stderr.trim()}`);
+          return;
+        }
+      } finally {
+        await rm(replyFile, { force: true });
+      }
+      const statusFile = join(tmpdir(), `hc-pr-resolve-${prNumber}-${process.pid}-${threadSeq++}.json`);
+      await writeFile(statusFile, JSON.stringify({ status: RESOLVED_STATUS }), "utf8");
+      try {
+        const r = await run("az", [
+          "devops",
+          "invoke",
+          "--area",
+          "git",
+          "--resource",
+          "pullRequestThreads",
+          ...route,
+          "--http-method",
+          "PATCH",
+          "--in-file",
+          statusFile,
+          "--api-version",
+          "7.1",
+          "-o",
+          "none"
+        ], cwd);
+        if (r.code !== 0) log(`Could not resolve pull request thread ${threadId}: ${r.stderr.trim()}`);
+      } finally {
+        await rm(statusFile, { force: true });
+      }
+    },
+    async resolveOwnThreads() {
+      if (prNumber === void 0 || !project || !repositoryId) return;
+      const route = ["--route-parameters", `project=${project}`, `repositoryId=${repositoryId}`, `pullRequestId=${prNumber}`];
+      const list = await run("az", [
+        "devops",
+        "invoke",
+        "--area",
+        "git",
+        "--resource",
+        "pullRequestThreads",
+        ...route,
+        "--api-version",
+        "7.1",
+        "-o",
+        "json"
+      ], cwd);
+      if (list.code !== 0) {
+        log(`Could not read the pull request threads to resolve them: ${list.stderr.trim()}`);
+        return;
+      }
+      let ids = [];
+      try {
+        ids = ownOpenThreads(JSON.parse(list.stdout));
+      } catch {
+        log("The pull request thread list could not be read.");
+        return;
+      }
+      for (const id of ids) {
+        const file = join(tmpdir(), `hc-pr-resolve-${prNumber}-${process.pid}-${threadSeq++}.json`);
+        await writeFile(file, JSON.stringify({ status: RESOLVED_STATUS }), "utf8");
+        try {
+          const r = await run("az", [
+            "devops",
+            "invoke",
+            "--area",
+            "git",
+            "--resource",
+            "pullRequestThreads",
+            ...route,
+            `threadId=${id}`,
+            "--http-method",
+            "PATCH",
+            "--in-file",
+            file,
+            "--api-version",
+            "7.1",
+            "-o",
+            "none"
+          ], cwd);
+          if (r.code !== 0) log(`Could not resolve pull request thread ${id}: ${r.stderr.trim()}`);
+        } finally {
+          await rm(file, { force: true });
+        }
+      }
+    }
+  };
+}
+function detectPlatform(remoteUrl) {
+  if (remoteUrl.includes("github.com")) return "github";
+  if (remoteUrl.includes("dev.azure.com") || remoteUrl.includes("visualstudio.com")) return "azure";
+  return "unknown";
+}
+function makePRAdapter(opts) {
+  if (opts.platform === "github") return ghAdapter(opts.run, opts.cwd);
+  if (opts.platform === "azure") return azAdapter(opts.run, opts.cwd, opts.log);
+  return {
+    async createPR(input) {
+      opts.log(`PR (local \u2014 no remote/platform): ${input.branch} \u2192 ${input.base} \u2014 "${input.title}"`);
+      return { url: `(local: ${input.branch})` };
+    },
+    async postComments(comments, outcome) {
+      if (comments.length || outcome === "approved") opts.log(`PR review: ${reviewThreadBody(comments, outcome)}`);
+      return void 0;
+    },
+    async replyAndResolve(_threadId, body) {
+      opts.log(`PR thread reply: ${body}`);
+    },
+    async resolveOwnThreads() {
+    }
+  };
+}
+
+// src/engine/council.ts
+import { z } from "zod";
+var ArchitectPlanSchema = z.object({
+  rootCause: z.string(),
+  plan: z.array(z.string())
+});
+async function runEscalationCouncil(deps, board, taskId, cwd, family) {
+  const task = board.get(taskId);
+  const resolved = deps.roleRegistry.resolve("architect");
+  const history = task.stageHistory.map((s) => s.action).join(", ");
+  const diagnoseOpts = {
+    provider: deps.provider,
+    ...resolved,
+    tools: readOnlyRegistry(deps),
+    messages: [
+      {
+        role: "user",
+        content: `Task "${task.title}" keeps bouncing back from review.
+Reviewer notes:
+${task.reviewNotes.map((n) => `- ${n}`).join("\n")}
+History: ${history}
+Identify the root cause and produce a concrete plan.`
+      }
+    ],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd,
+    signal: deps.signal
+  };
+  const plan = await runStructuredRole(diagnoseOpts, ArchitectPlanSchema);
+  board.appendStage(taskId, { role: "architect", action: "council:diagnosed", note: plan.rootCause });
+  const senior = family === "designer" ? "senior-designer" : "senior-coder";
+  board.clearReviewNotes(taskId);
+  board.addReviewNote(taskId, plan.rootCause);
+  for (const step of plan.plan) board.addReviewNote(taskId, step);
+  board.move(taskId, "IN-PROGRESS", senior);
+  board.setWorker(taskId, senior, deps.roleRegistry.peekModel(senior));
+  const before = await worktreeState(defaultGitRunner, cwd);
+  await runImplementer(deps, senior, board.get(taskId), cwd);
+  const after = await worktreeState(defaultGitRunner, cwd);
+  const idle = before !== void 0 && after !== void 0 && before === after && !(deps.baseRef && await hasWorkAgainst(defaultGitRunner, cwd, deps.baseRef));
+  if (idle) {
+    const served = deps.roleRegistry.chainFor(senior, 0)[0] ?? "";
+    telemetry().event("implementer.no_changes", {
+      "hc.task.id": taskId,
+      "hc.role": senior,
+      "hc.model": served,
+      "hc.council": true
+    });
+    if (served) deps.fitness?.record(senior, served, "answered in prose instead of implementing");
+    board.appendStage(taskId, { role: senior, action: "no-changes", note: served ? `model: ${served}` : void 0 });
+    board.move(taskId, "TODO", senior);
+    deps.note?.(`\u26A0\uFE0F **${board.get(taskId).title}** \u2014 the council's \`${senior}\` wrote nothing; not sending an unchanged worktree to review.`);
+    return { verdict: "fail", notes: [
+      "The council's implementation produced NO file changes. Write the code with write_file/edit_file \u2014 describing it is not enough."
+    ] };
+  }
+  board.appendStage(taskId, { role: senior, action: "council:implemented" });
+  board.move(taskId, "REVIEW", senior);
+  const v = await telemetry().span("stage.code_review", {
+    "hc.stage": "code review",
+    "hc.task.id": taskId,
+    "hc.council": true
+  }, () => runReviewer(deps, board.get(taskId), cwd));
+  if (v.verdict === "pass") {
+    board.appendStage(taskId, { role: "code-reviewer", action: "reviewed:pass" });
+  } else {
+    board.appendStage(taskId, { role: "code-reviewer", action: "reviewed:fail", note: v.notes.join("; ") });
+  }
+  return v;
+}
+
+// src/engine/escalation.ts
+function autonomousAskHuman(maxRetries = 2) {
+  const retries = /* @__PURE__ */ new Map();
+  return async ({ card, verdict }) => {
+    const n = retries.get(card.id) ?? 0;
+    if (n >= maxRetries) return { action: "abandon" };
+    retries.set(card.id, n + 1);
+    const notes = verdict.notes.length > 0 ? verdict.notes : ["Address the review feedback and complete the task."];
+    return { action: "retry", notes };
+  };
+}
+function noChangeStreak(task) {
+  let n = 0;
+  for (let i = task.stageHistory.length - 1; i >= 0; i--) {
+    const a = task.stageHistory[i].action;
+    if (a === "no-changes") {
+      n += 1;
+      continue;
+    }
+    if (a.startsWith("\u2192") || a === "attempt-error") continue;
+    break;
+  }
+  return n;
+}
+function tierOf(attempts, rounds) {
+  return attempts < rounds ? 0 : attempts < 2 * rounds ? 1 : 2;
+}
+function attemptError(board, taskId, role, e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  board.appendStage(taskId, { role, action: "attempt-error", note: msg });
+  board.addReviewNote(taskId, `The previous attempt did not finish (${msg}). Complete the task within the turn budget.`);
+  board.move(taskId, "TODO", role);
+  return { verdict: "fail", notes: [msg] };
+}
+async function runTaskWithEscalation(deps, board, taskId, cwd, slot = 0) {
+  const task = board.get(taskId);
+  if (!task) throw new Error(`runTaskWithEscalation: unknown task: ${taskId}`);
+  const noChangeCount = noChangeStreak(task);
+  if (noChangeCount >= 3) {
+    const notes = ["Three attempts produced no file changes. The task needs a human decision before another agent is dispatched."];
+    board.appendStage(taskId, { role: "system", action: "human:required", note: notes[0] });
+    const decision = await deps.askHuman({ card: board.get(taskId), verdict: { verdict: "fail", notes } });
+    if (decision.action === "accept") {
+      board.appendStage(taskId, { role: "human", action: "human:accept" });
+      board.move(taskId, "DONE", "human");
+      return { verdict: "pass", notes: [] };
+    }
+    if (decision.action === "retry" && decision.notes.some((note) => note.trim())) {
+      board.appendStage(taskId, { role: "human", action: "human:retry", note: decision.notes.join("; ") });
+      board.clearReviewNotes(taskId);
+      for (const note of decision.notes) board.addReviewNote(taskId, note);
+      board.move(taskId, "TODO", "human");
+    } else {
+      board.appendStage(taskId, { role: "human", action: decision.action === "retry" ? "human:retry-blocked" : "human:abandon" });
+    }
+    return { verdict: "fail", notes };
+  }
+  const family = await routeTask(deps, task);
+  board.setWorktree(taskId, cwd);
+  for (; ; ) {
+    const attempts = board.get(taskId).attempts;
+    const tier = tierOf(attempts, deps.rounds);
+    telemetry().event("decision.tier", {
+      "hc.decision": "tier",
+      "hc.task.id": taskId,
+      "hc.tier": tier,
+      "hc.attempt": attempts,
+      "hc.family": family
+    });
+    if (tier < 2) {
+      const role = tier === 0 ? family : family === "designer" ? "senior-designer" : "senior-coder";
+      let v2;
+      try {
+        v2 = await runCycleWithRole(deps, board, taskId, cwd, role, void 0, slot);
+      } catch (e) {
+        if (deps.signal.aborted) throw e;
+        v2 = attemptError(board, taskId, role, e);
+      }
+      if (v2.verdict === "pass") return v2;
+      if (v2.noProgress) {
+        const tierStart = Math.floor(attempts / deps.rounds) * deps.rounds;
+        const target = attempts === tierStart ? attempts + 1 : tierStart + deps.rounds;
+        while (board.get(taskId).attempts < target) board.incrementAttempts(taskId);
+      } else {
+        board.incrementAttempts(taskId);
+      }
+      continue;
+    }
+    let v;
+    try {
+      v = await runEscalationCouncil(deps, board, taskId, cwd, family);
+    } catch (e) {
+      if (deps.signal.aborted) throw e;
+      v = attemptError(board, taskId, "code-reviewer", e);
+    }
+    if (v.verdict === "pass") {
+      board.clearReviewNotes(taskId);
+      board.move(taskId, "DONE", "code-reviewer");
+      return v;
+    }
+    const decision = await deps.askHuman({ card: board.get(taskId), verdict: v });
+    if (decision.action === "accept") {
+      board.appendStage(taskId, { role: "human", action: "human:accept" });
+      board.clearReviewNotes(taskId);
+      board.move(taskId, "DONE", "human");
+      return { verdict: "pass", notes: [] };
+    }
+    if (decision.action === "retry") {
+      board.appendStage(taskId, {
+        role: "human",
+        action: "human:retry",
+        note: decision.notes.join("; ")
+      });
+      board.clearReviewNotes(taskId);
+      for (const n of decision.notes) board.addReviewNote(taskId, n);
+      board.incrementAttempts(taskId);
+      continue;
+    }
+    board.appendStage(taskId, { role: "human", action: "human:abandon" });
+    return { verdict: "fail", notes: v.notes };
+  }
+}
+
+// src/engine/pr-summary.ts
+import { z as z2 } from "zod";
+var MAX_EXAMPLES = 12;
+var MERGED_PREFIX = /^Merged PR \d+:\s*/;
+var PR_SUMMARY_MAX_TURNS = 3;
+var PRSummarySchema = z2.object({
+  title: z2.string().min(1),
+  body: z2.string().min(1)
+});
+async function recentSubjects(git, cwd, base) {
+  const read = async (args) => {
+    const r = await git(args, cwd);
+    if (r.code !== 0) return [];
+    return r.stdout.split("\n").map((s) => s.replace(MERGED_PREFIX, "").trim()).filter(Boolean);
+  };
+  const merges = await read(["log", "--merges", "--format=%s", "-n", "40", base]);
+  const subjects = merges.length >= 3 ? merges : await read(["log", "--format=%s", "-n", "40", base]);
+  return subjects.slice(0, MAX_EXAMPLES);
+}
+function prAskMessage(request, tasks, examples) {
+  const convention = examples.length ? `Recent titles from THIS repository \u2014 follow their format, their language and their scope vocabulary:
+` + examples.map((e) => `- ${e}`).join("\n") : `No examples were found in this repository. Use Conventional Commits: \`type(scope): subject\`.`;
+  return [
+    `Write the title and description for the pull request that delivers this work.`,
+    ``,
+    `What was asked for:
+${request}`,
+    ``,
+    convention,
+    ``,
+    `The title is ONE conventional-commit line: \`type(scope): subject\`, in the same language as the examples,`,
+    `describing the OUTCOME \u2014 not the job, not a branch name, not a slug.`,
+    ``,
+    `The description is short prose for a human reviewer, in the same language: what this changes, and why it`,
+    `was needed. Two or three sentences, or a handful of bullets. It is NOT a task list and NOT a file list \u2014`,
+    `the tasks are appended separately. Do not describe internal roles, cards, or the process that produced it.`,
+    ``,
+    `The tasks that were completed, for your information only:
+${tasks.map((t) => `- ${t}`).join("\n")}`,
+    ``,
+    `Return {title, body} via submit.`
+  ].join("\n");
+}
+function withTaskList(body, tasks) {
+  if (!tasks.length) return body;
+  return `${body.trim()}
+
+<details>
+<summary>Completed tasks (${tasks.length})</summary>
+
+` + tasks.map((t) => `- ${t}`).join("\n") + `
+</details>
+`;
+}
+function fallbackPR(jobSlug, tasks) {
+  return { title: `hc: ${jobSlug}`, body: "Completed tasks:\n" + tasks.map((t) => `- ${t}`).join("\n") };
+}
+async function prSummary(deps, opts) {
+  const tasks = opts.cards.map((c) => c.title);
+  try {
+    const git = deps.git ?? defaultGitRunner;
+    const examples = await recentSubjects(git, opts.cwd, opts.base);
+    const resolved = deps.roleRegistry.resolve("operational");
+    const summary = await runStructuredRole(
+      {
+        provider: deps.provider,
+        ...resolved,
+        tools: new ToolRegistry(),
+        messages: [{ role: "user", content: prAskMessage(opts.request, tasks, examples) }],
+        permission: deps.permission,
+        approve: deps.approve,
+        cwd: opts.cwd,
+        signal: deps.signal,
+        maxTurns: PR_SUMMARY_MAX_TURNS
+      },
+      PRSummarySchema
+    );
+    return { title: summary.title.trim(), body: withTaskList(summary.body, tasks) };
+  } catch {
+    return fallbackPR(opts.jobSlug, tasks);
+  }
+}
+
+// src/engine/revision.ts
+import { z as z3 } from "zod";
+var REVISION_CARD = "__revision__";
+var PrincipalReviewSchema = z3.object({
+  decision: z3.enum(["approve", "request-changes"]).describe(
+    "`request-changes` only for what must change before merge; each comment is then applied by another agent and answered on the pull request. `approve` when nothing left would block the merge."
+  ),
+  comments: z3.array(z3.string())
+});
+var PrincipalFinalSchema = z3.object({
+  decision: z3.enum(["accept", "ask-human"]).describe(
+    "The rounds are over and findings remain. `accept`: they can merge as they stand. `ask-human`: only a person can settle it \u2014 this stops the run, so use it when the remaining finding is a real decision, not when it is merely unfinished."
+  ),
+  question: z3.string()
+});
+async function worktreeState2(deps, base) {
+  const git = deps.git ?? defaultGitRunner;
+  const head = await git(["rev-parse", "HEAD"], base);
+  if (head.code !== 0) return void 0;
+  const status = await git(["status", "--porcelain"], base);
+  return `${head.stdout.trim()}|${status.stdout.trim()}`;
+}
+async function principalReview(deps, base, prDiff, deferred) {
+  const resolved = deps.roleRegistry.resolve("principal-coder");
+  const carried = deferred?.length ? `
+
+The per-task code review deferred these non-blocking findings \u2014 judge which genuinely deserve a fix now and include those in your comments; ignore the ones that are not worth it:
+${deferred.map((d) => `- ${d}`).join("\n")}` : "";
+  const content = (prDiff ? `PR review: review the following diff:
+${prDiff}
+(use the read tools to inspect the worktree if needed.) Give approve or request-changes + concrete comments.` : "PR review: review all changes in the base worktree holistically. Give approve or request-changes + concrete comments.") + carried;
+  const hints = memoryHints(deps, content, { role: "principal-coder", operations: true });
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools: readOnlyRegistry(deps, { propose: true }),
+    proposeMemory: (t, k) => deps.proposeMemory?.(t, k, "principal-coder") ?? false,
+    messages: hints.message ? [{ role: "user", content: hints.message }, { role: "user", content }] : [{ role: "user", content }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: base,
+    signal: deps.signal
+  };
+  const review = await runStructuredRole(opts, PrincipalReviewSchema);
+  reinforceUsed(deps, hints.ids, review.comments.join(" "), "principal-coder");
+  return review;
+}
+async function principalFinal(deps, base) {
+  const resolved = deps.roleRegistry.resolve("principal-coder");
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    // The principal decides what ships; what it learns about this codebase outlives the round.
+    tools: readOnlyRegistry(deps, { remember: true }),
+    messages: [{ role: "user", content: "FINAL DECISION: Revision rounds are over and findings still remain. Give accept or ask-human (a question to ask the user)." }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: base,
+    signal: deps.signal
+  };
+  return runStructuredRole(opts, PrincipalFinalSchema);
+}
+var REVISE_TURNS_PER_COMMENT = 8;
+var REVISE_TURNS_MIN = 30;
+var REVISE_TURNS_MAX = 200;
+var TURN_LIMIT_RE = /maximum turn count exceeded/i;
+function reviseTurnBudget(commentCount) {
+  return Math.min(REVISE_TURNS_MAX, Math.max(REVISE_TURNS_MIN, commentCount * REVISE_TURNS_PER_COMMENT));
+}
+var MAX_REPLY_CHARS = 6e3;
+async function sayHowItEnded(deps, postComments, how, round, question) {
+  const said = how === "accepted" ? `The revision rounds are over after round ${round}. The remaining findings above were judged acceptable to merge as they stand \u2014 they were not silently dropped, and nothing further will be applied automatically.` : `The revision rounds are over after round ${round} and this needs a decision that is not mine to make. The question put to the user was:
+
+> ${question ?? "(not recorded)"}`;
+  try {
+    await postComments([said], "changes");
+  } catch (e) {
+    deps.note?.(`\u26A0\uFE0F Could not post how the revision ended (${e instanceof Error ? e.message : String(e)}).`);
+  }
+}
+function revisionReplyBody(round, account, commit) {
+  const head = `${REVIEW_MARKER} \u2014 round ${round} applied in \`${commit}\`.`;
+  const rest = account.ok ? "" : `
+
+_The reviser reached its turn budget on this round; what it changed is in the commit above and the next review round picks up the remainder._`;
+  const said = account.said.length > MAX_REPLY_CHARS ? `${account.said.slice(0, MAX_REPLY_CHARS)}\u2026` : account.said;
+  return said ? `${head}
+
+${said}${rest}` : `${head}
+
+_The reviser left no written account of the round; the commit is the record._${rest}`;
+}
+async function seniorRevise(deps, base, comments) {
+  const resolved = deps.roleRegistry.resolve("senior-coder");
+  const tools = createDefaultRegistry();
+  tools.register(buildSkillTool(deps.skillRegistry));
+  for (const t of contextTools(deps)) tools.register(t);
+  const hints = memoryHints(deps, comments.join(" "), { role: "senior-coder", operations: true });
+  const ask = { role: "user", content: `PR revision: address the following comments \u2014 fix each one, or say plainly which is wrong and why. Start by editing; you have already been given what to change:
+${comments.map((c) => `- ${c}`).join("\n")}` };
+  const spoken = [];
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools,
+    messages: hints.message ? [{ role: "user", content: hints.message }, ask] : [ask],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: base,
+    signal: deps.signal,
+    maxTurns: reviseTurnBudget(comments.length),
+    // The last code to enter the pull request: what the reviser says about each comment — fixed it, or why
+    // it is by design — is the argument the user is being asked to accept. Kept, not just shown: it is what
+    // gets posted back into the review thread.
+    onSay: (t) => {
+      spoken.push(t);
+      deps.note?.(t);
+    }
+  };
+  try {
+    await runToCompletion(opts);
+    return { ok: true, said: spoken.join("\n\n").trim() };
+  } catch (e) {
+    const why = e instanceof Error ? e.message : String(e);
+    if (TURN_LIMIT_RE.test(why)) {
+      deps.note?.(`\u26A0\uFE0F The reviser used its whole turn budget on ${comments.length} comment(s). What it changed is kept and committed with this round; the next review round reads the result and asks for the rest.`);
+      return { ok: false, said: spoken.join("\n\n").trim() };
+    }
+    deps.note?.(`\u26A0\uFE0F The revision pass stopped: ${why}. It had ${comments.length} comment(s) to address and its work up to that point is committed on the branch \u2014 re-run to continue from there.`);
+    throw e;
+  }
+}
+async function runRevision(deps, session, board, postComments, askUser, maxRounds, prDiff, deferred, resolveThreads, replyAndResolve) {
+  if (!board.get(REVISION_CARD)) board.addCard({ id: REVISION_CARD, title: "PR revision" });
+  const base = session.baseWorktree;
+  const rounds = Math.max(1, maxRounds);
+  let extra = 0;
+  const cap = rounds * 2;
+  for (let round = 1; round <= rounds + extra; round++) {
+    deps.note?.(`\u{1F501} PR revision, round ${round}/${rounds + extra} \u2014 the principal reviewer is reading the merged diff.`);
+    const v = await principalReview(deps, base, prDiff, round === 1 ? deferred : void 0);
+    if (v.decision === "approve") {
+      board.appendStage(REVISION_CARD, { role: "principal-coder", action: "pr:approved" });
+      deps.note?.(`\u2705 PR revision: the merged diff was reviewed and approved.`);
+      try {
+        await postComments(v.comments, "approved");
+      } catch (e) {
+        deps.note?.(`\u26A0\uFE0F Could not post the approval to the pull request (${e instanceof Error ? e.message : String(e)}).`);
+      }
+      try {
+        await resolveThreads?.();
+      } catch (e) {
+        deps.note?.(`\u26A0\uFE0F Could not resolve the review threads (${e instanceof Error ? e.message : String(e)}).`);
+      }
+      return { status: "approved", rounds: round - 1 };
+    }
+    board.appendStage(REVISION_CARD, { role: "principal-coder", action: "pr:changes", note: v.comments.join("; ") });
+    if (round === rounds + extra) {
+      const f = await principalFinal(deps, base);
+      if (f.decision === "accept") {
+        board.appendStage(REVISION_CARD, { role: "principal-coder", action: "pr:final:accept" });
+        await sayHowItEnded(deps, postComments, "accepted", round);
+        return { status: "accepted", rounds };
+      }
+      const answer = await askUser(f.question);
+      board.appendStage(REVISION_CARD, { role: "human", action: "pr:human", note: answer });
+      await sayHowItEnded(deps, postComments, "human", round, f.question);
+      return { status: "human", rounds, answer };
+    }
+    deps.note?.(`\u{1F501} Round ${round}: ${v.comments.length} change(s) requested \u2014 applying them.`);
+    let threadId;
+    try {
+      threadId = await postComments(v.comments);
+    } catch (e) {
+      deps.note?.(`\u26A0\uFE0F Could not post the review comments to the pull request (${e instanceof Error ? e.message : String(e)}) \u2014 applying them anyway.`);
+    }
+    const beforeRevise = await worktreeState2(deps, base);
+    const account = await seniorRevise(deps, base, v.comments);
+    if (!account.ok && rounds + extra < cap) extra++;
+    if (beforeRevise !== void 0 && await worktreeState2(deps, base) === beforeRevise) {
+      board.appendStage(REVISION_CARD, { role: "senior-coder", action: "pr:no-changes" });
+      const retry = await seniorRevise(deps, base, [...v.comments, "Your previous attempt changed NO files. Apply the fixes with write_file/edit_file, or state clearly which comment is wrong and why."]);
+      account.said = [account.said, retry.said].filter(Boolean).join("\n\n");
+      if (await worktreeState2(deps, base) === beforeRevise) {
+        const f = await principalFinal(deps, base);
+        if (f.decision === "accept") {
+          board.appendStage(REVISION_CARD, { role: "principal-coder", action: "pr:final:accept" });
+          await sayHowItEnded(deps, postComments, "accepted", round);
+          return { status: "accepted", rounds: round };
+        }
+        const answer = await askUser(f.question);
+        board.appendStage(REVISION_CARD, { role: "human", action: "pr:human", note: answer });
+        await sayHowItEnded(deps, postComments, "human", round, f.question);
+        return { status: "human", rounds: round, answer };
+      }
+    }
+    board.appendStage(REVISION_CARD, { role: "senior-coder", action: "pr:revised" });
+    deps.note?.(`\u{1F501} Round ${round}: revised and committed.`);
+    const headBefore = (await gitOf(deps)(["rev-parse", "HEAD"], base)).stdout.trim();
+    await deps.manager.commitMerge(session, `hc: revision ${round}`);
+    await refreshAfterRevision(deps, base, headBefore);
+    await deps.manager.push(session);
+    if (threadId && replyAndResolve) {
+      const body = revisionReplyBody(round, account, `hc: revision ${round}`);
+      try {
+        await replyAndResolve(threadId, body);
+      } catch (e) {
+        deps.note?.(`\u26A0\uFE0F Could not answer the review thread (${e instanceof Error ? e.message : String(e)}).`);
+      }
+    }
+  }
+  return { status: "accepted", rounds };
+}
+var gitOf = (deps) => deps.git ?? defaultGitRunner;
+async function refreshAfterRevision(deps, base, headBefore) {
+  const files = await changedByMerge(gitOf(deps), base, headBefore);
+  await refreshAfterChange({
+    cwd: base,
+    files,
+    provider: deps.provider,
+    models: deps.roleRegistry.chainFor("tracer", 0),
+    signal: deps.signal,
+    git: gitOf(deps),
+    ...deps.note ? { note: (t) => deps.note?.(t) } : {}
+  });
+}
+function closeRevision(board, result, failure) {
+  if (!board.get(REVISION_CARD)) return;
+  if (failure) board.appendStage(REVISION_CARD, { role: "principal-coder", action: "pr:failed", note: failure });
+  board.move(REVISION_CARD, "DONE", "principal-coder");
+}
+
+// src/engine/wave-task.ts
+async function runWaveTask(deps, session, board, taskId, slot = 0) {
+  const card = board.get(taskId);
+  if (!card) throw new Error(`runWaveTask: unknown task: ${taskId}`);
+  const git = deps.git ?? defaultGitRunner;
+  const ser = deps.serialize ?? ((f) => f());
+  const derive = () => ser(() => deps.manager.deriveTask(session, card.title));
+  const tw = await (deps.timings ? deps.timings.time("git", derive) : derive());
+  const rounds = Math.max(1, deps.rounds);
+  let v;
+  try {
+    v = await telemetry().span("task", {
+      "hc.task.id": taskId,
+      "hc.task.title": card.title.slice(0, 120),
+      "hc.slot": slot,
+      "hc.attempt": card.attempts
+    }, () => runTaskWithEscalation({ ...deps, rounds }, board, taskId, tw.worktree, slot));
+  } catch (e) {
+    if (deps.signal.aborted) throw e;
+    const msg = e instanceof Error ? e.message : String(e);
+    board.appendStage(taskId, { role: "team-lead", action: "task-failed", note: msg });
+    board.move(taskId, "ABANDONED", "team-lead");
+    return { status: "task-failed", task: tw };
+  }
+  deps.signal.throwIfAborted();
+  if (v.verdict === "fail") {
+    board.appendStage(taskId, { role: "team-lead", action: "task-failed" });
+    board.move(taskId, "ABANDONED", "team-lead");
+    return { status: "task-failed", task: tw };
+  }
+  const baseBefore = (await git(["rev-parse", "HEAD"], session.baseWorktree)).stdout.trim();
+  const land = async () => {
+    await deps.manager.commitTask(tw, `hc: ${card.title}`);
+    if (deps.baseRef) await squashTask(deps, tw.worktree, deps.baseRef, card.title);
+    return ser(async () => {
+      const r = await deps.manager.mergeTask(session, tw);
+      if (r.status === "conflict" && deps.resolveConflict) return deps.resolveConflict(tw, r.files);
+      return r;
+    });
+  };
+  const mr = await (deps.timings ? deps.timings.time("git", land) : land());
+  if (mr.status === "merged") {
+    board.move(taskId, "MERGED", "team-lead");
+    board.appendStage(taskId, { role: "team-lead", action: "merged" });
+    await refreshAfterMerge(deps, session, git, baseBefore);
+    return { status: "merged", task: tw };
+  }
+  board.appendStage(taskId, { role: "team-lead", action: "merge-conflict", note: mr.files.join(", ") });
+  return { status: "conflict", files: mr.files, task: tw };
+}
+async function refreshAfterMerge(deps, session, git, baseBefore) {
+  const files = await changedByMerge(git, session.baseWorktree, baseBefore);
+  await refreshAfterChange({
+    cwd: session.baseWorktree,
+    files,
+    provider: deps.provider,
+    models: deps.roleRegistry.chainFor("tracer", 0),
+    signal: deps.signal,
+    git,
+    ...deps.note ? { note: (t) => deps.note?.(t) } : {}
+  });
+}
+
+// src/engine/conflict.ts
+import { spawn as spawn2 } from "child_process";
+import { readFile } from "fs/promises";
+import { join as join2, dirname } from "path";
+function resolverRegistry(remember) {
+  const r = new ToolRegistry();
+  r.register(buildRememberTool(remember));
+  r.register(readFileTool);
+  r.register(writeFileTool);
+  r.register(editFileTool);
+  return r;
+}
+var RESOLVE_TURNS_PER_FILE = 6;
+var RESOLVE_TURNS_MIN = 12;
+function resolveTurnBudget(fileCount) {
+  return Math.max(RESOLVE_TURNS_MIN, fileCount * RESOLVE_TURNS_PER_FILE);
+}
+function conflictHunks(text, maxChars = 4e3) {
+  const out = [];
+  const re = /^<<<<<<<[^\n]*\n([\s\S]*?)^>>>>>>>[^\n]*$/gm;
+  let m;
+  let used = 0;
+  while ((m = re.exec(text)) !== null) {
+    const hunk = m[0];
+    if (used + hunk.length > maxChars) {
+      out.push("\u2026 (further conflicts in this file, not shown)");
+      break;
+    }
+    used += hunk.length;
+    out.push(hunk);
+  }
+  return out.join("\n\n");
+}
+async function hasConflictMarkers(baseWorktree, files) {
+  for (const f of files) {
+    try {
+      const content = await readFile(join2(baseWorktree, f), "utf8");
+      if (content.includes("<<<<<<<")) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var LOCKFILE = /(^|\/)(package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb|Cargo\.lock|poetry\.lock|Gemfile\.lock|composer\.lock|go\.sum)$/;
+var REGENERATE = [
+  { file: /package-lock\.json$|npm-shrinkwrap\.json$/, cmd: ["npm", "install", "--package-lock-only"] },
+  { file: /pnpm-lock\.yaml$/, cmd: ["pnpm", "install", "--lockfile-only"] },
+  { file: /Cargo\.lock$/, cmd: ["cargo", "generate-lockfile"] },
+  { file: /poetry\.lock$/, cmd: ["poetry", "lock", "--no-update"] },
+  { file: /Gemfile\.lock$/, cmd: ["bundle", "lock"] },
+  { file: /composer\.lock$/, cmd: ["composer", "update", "--lock"] },
+  { file: /go\.sum$/, cmd: ["go", "mod", "tidy"] }
+];
+var REGENERATE_TIMEOUT_MS = 18e4;
+function runCmd(cmd, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn2(cmd[0], cmd.slice(1), { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    const take = (d) => {
+      if (out.length < 8e3) out += d.toString();
+    };
+    child.stdout.on("data", take);
+    child.stderr.on("data", take);
+    const timer = setTimeout(() => child.kill("SIGKILL"), REGENERATE_TIMEOUT_MS);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      resolve({ ok: false, out: e.message });
+    });
+    child.on("close", (c) => {
+      clearTimeout(timer);
+      resolve({ ok: c === 0, out });
+    });
+  });
+}
+async function regenerateLockfile(file, baseWorktree) {
+  const rule = REGENERATE.find((r2) => r2.file.test(file));
+  if (!rule) return void 0;
+  const dir = join2(baseWorktree, dirname(file));
+  const r = await runCmd(rule.cmd, dir);
+  return r.ok ? `regenerated with \`${rule.cmd.join(" ")}\`` : `could not regenerate (\`${rule.cmd.join(" ")}\`: ${r.out.trim().split("\n").slice(-1)[0]?.slice(0, 120) ?? "failed"}) \u2014 kept the base's copy; run it yourself before merging`;
+}
+async function mergeConflictedTraceIndex(deps, session, file) {
+  if (!deps.manager.conflictSide || !deps.manager.resolveWith) return void 0;
+  try {
+    const ourText = await deps.manager.conflictSide(session, file, "ours");
+    const theirText = await deps.manager.conflictSide(session, file, "theirs");
+    if (ourText === void 0 || theirText === void 0) return void 0;
+    const ours = parseTraceIndex(ourText);
+    const theirs = parseTraceIndex(theirText);
+    if (!ours || !theirs) return void 0;
+    const merged = mergeTraceIndexes(ours, theirs);
+    await deps.manager.resolveWith(session, file, serializeTraceIndex(merged));
+    return Object.keys(merged.traces).length;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveGeneratedConflicts(deps, session, conflictedFiles) {
+  const base = session.baseWorktree;
+  const indexPath = `${traceRootRel().replace(/\\/g, "/")}/${TRACE_INDEX}`;
+  const rest = [];
+  let allConflicted = conflictedFiles;
+  for (const f of allConflicted) {
+    if (f !== indexPath) {
+      rest.push(f);
+      continue;
+    }
+    const merged = await mergeConflictedTraceIndex(deps, session, f);
+    if (merged === void 0) {
+      rest.push(f);
+      continue;
+    }
+    deps.note?.(`\u{1F5C2}\uFE0F \`${f}\` \u2014 trace index; combined both sides (${merged} entries).`);
+  }
+  allConflicted = rest;
+  const isTrace = (f) => {
+    const root = traceRootRel().replace(/\\/g, "/");
+    return f.startsWith(`${root}/`) && /\.[A-Za-z0-9]{1,5}\.md$/.test(f);
+  };
+  const generated = allConflicted.filter((f) => LOCKFILE.test(f) || isTrace(f));
+  const lockfiles = allConflicted.filter((f) => LOCKFILE.test(f));
+  const conflicted = allConflicted.filter((f) => !generated.includes(f));
+  const traces = generated.filter((f) => !LOCKFILE.test(f));
+  if (traces.length) {
+    deps.note?.(`\u{1F4DD} ${traces.length} trace file(s) conflicted \u2014 taking the base's copy; the refresh after this merge re-derives them from the code that just landed.`);
+    for (const f of traces) {
+      try {
+        await deps.manager.resolveWithBase(session, f);
+      } catch {
+      }
+    }
+  }
+  if (lockfiles.length) {
+    deps.note?.(`\u{1F512} ${lockfiles.join(", ")} \u2014 generated file, taking the base's copy and regenerating rather than merging it by hand.`);
+    for (const f of lockfiles) {
+      try {
+        await deps.manager.resolveWithBase(session, f);
+        const said = await regenerateLockfile(f, base);
+        if (said) deps.note?.(`   \`${f}\` \u2014 ${said}`);
+        await deps.manager.resolveWithBase(session, f);
+      } catch {
+      }
+    }
+  }
+  return { conflicted, generated };
+}
+async function handedHunks(files, cwd) {
+  const parts = [];
+  for (const f of files.slice(0, 10)) {
+    try {
+      const text = await readFile(join2(cwd, f), "utf8");
+      const hunks = conflictHunks(text);
+      if (hunks) parts.push(`--- ${f}
+${hunks}`);
+    } catch {
+    }
+  }
+  return parts.length ? `The conflicted regions:
+
+${parts.join("\n\n")}
+
+` : "";
+}
+async function runConflictResolver(deps, base, conflicted, notes = "") {
+  const op = deps.roleRegistry.resolve("operational");
+  const hints = memoryHints(deps, conflicted.join(" "), { role: "operational", operations: true });
+  const ask = { role: "user", content: `A git merge left conflicts in the base worktree. Resolve them: for EACH file, remove all conflict markers (<<<<<<<, =======, >>>>>>>) and combine BOTH sides' changes so the intent of each is preserved (don't just pick one side unless the changes are truly incompatible). Conflicted files: ${conflicted.join(", ")}.
+
+${await handedHunks(conflicted, base)}${notes}` };
+  const resolveOpts = {
+    provider: deps.provider,
+    ...op,
+    tools: resolverRegistry(deps.rememberFact),
+    messages: hints.message ? [{ role: "user", content: hints.message }, ask] : [ask],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: base,
+    signal: deps.signal,
+    perAttemptMs: LONG_CALL_MS,
+    // each model in the chain gets its own clock — see RoleAgentOptions
+    maxTurns: resolveTurnBudget(conflicted.length),
+    // It is combining two sides of the user's own code; how it read the conflict is the thing to check.
+    ...deps.note ? { onSay: (t) => deps.note?.(`  \u21B3 ${t}`) } : {}
+  };
+  await runToCompletion(resolveOpts);
+  reinforceTouched(deps, hints.ids, conflicted, "operational");
+}
+async function resolveMergeConflict(deps, session, board, taskId, task) {
+  if (!board.get(taskId)) throw new Error(`resolveMergeConflict: unknown task: ${taskId}`);
+  const rounds = Math.max(1, deps.rounds);
+  const base = session.baseWorktree;
+  const { conflicted, generated } = await resolveGeneratedConflicts(deps, session, await deps.manager.unmergedFiles(session));
+  if (!conflicted.length && generated.length) {
+    return { status: "resolved" };
+  }
+  deps.note?.(`\u{1F500} Merge conflict in ${conflicted.join(", ")} \u2014 operational resolving\u2026`);
+  for (; ; ) {
+    for (let i = 0; i < rounds; i++) {
+      const card = board.get(taskId);
+      const notes = card.reviewNotes.length ? `
+Hints from the last attempt:
+${card.reviewNotes.map((n) => `- ${n}`).join("\n")}` : "";
+      await runConflictResolver(deps, base, conflicted, notes);
+      board.appendStage(taskId, { role: "operational", action: "conflict:resolve-attempt" });
+      if (await hasConflictMarkers(base, conflicted)) {
+        board.clearReviewNotes(taskId);
+        board.addReviewNote(taskId, `conflict markers still present: ${conflicted.join(", ")}`);
+        continue;
+      }
+      const v = await runReviewer(deps, board.get(taskId), base);
+      if (v.verdict === "pass") {
+        await deps.manager.commitMerge(session, `chore: resolve merge conflict \u2014 ${card.title}`);
+        board.appendStage(taskId, { role: "operational", action: "conflict:merged" });
+        deps.note?.(`\u{1F516} chore: resolve merge conflict \u2014 ${card.title}`);
+        return { status: "resolved" };
+      }
+      board.clearReviewNotes(taskId);
+      for (const n of v.notes) board.addReviewNote(taskId, n);
+    }
+    const decision = await deps.askHuman({
+      card: board.get(taskId),
+      verdict: { verdict: "fail", notes: [`merge conflict not resolved in ${rounds} rounds`] }
+    });
+    if (decision.action === "retry") {
+      board.clearReviewNotes(taskId);
+      for (const n of decision.notes) board.addReviewNote(taskId, n);
+      continue;
+    }
+    await deps.manager.abortMerge(session);
+    board.appendStage(taskId, { role: "human", action: "conflict:aborted" });
+    deps.note?.(`\u26A0 Merge conflict could not be resolved after ${rounds} rounds \u2014 aborted.`);
+    return { status: "unresolved", task };
+  }
+}
+
+// src/engine/team-lead.ts
+import { z as z4 } from "zod";
+
+// src/engine/waves.ts
+function computeWaves(board) {
+  const cards = board.list();
+  const placed = /* @__PURE__ */ new Set();
+  const waves = [];
+  let remaining = cards;
+  while (remaining.length) {
+    const layer = remaining.filter((c) => c.deps.every((d) => placed.has(d)));
+    if (layer.length === 0) {
+      throw new Error("computeWaves: dependency cycle or unresolved dependency");
+    }
+    waves.push(layer.map((c) => c.id));
+    for (const c of layer) placed.add(c.id);
+    remaining = remaining.filter((c) => !placed.has(c.id));
+  }
+  return waves;
+}
+function normalizePath(p) {
+  return p.trim().replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+}
+function fileClashes(ids, board) {
+  const files = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const card = board.get(id);
+    if (card) files.set(id, new Set(card.files.map(normalizePath).filter(Boolean)));
+  }
+  const out = [];
+  for (let i = 0; i < ids.length; i++) {
+    for (let j = i + 1; j < ids.length; j++) {
+      const a = files.get(ids[i]), b = files.get(ids[j]);
+      if (!a || !b) continue;
+      const shared = [...a].filter((f) => b.has(f));
+      if (shared.length) out.push({ a: ids[i], b: ids[j], files: shared });
+    }
+  }
+  return out;
+}
+function splitFileConflicts(waves, board) {
+  const clashes = [];
+  const out = [];
+  for (const wave of waves) {
+    const found = fileClashes(wave, board);
+    clashes.push(...found);
+    if (found.length === 0) {
+      out.push(wave);
+      continue;
+    }
+    const bins = [];
+    for (const id of wave) {
+      const own = new Set((board.get(id)?.files ?? []).map(normalizePath).filter(Boolean));
+      const bin = bins.find((b) => ![...own].some((f) => b.files.has(f)));
+      if (bin) {
+        bin.ids.push(id);
+        for (const f of own) bin.files.add(f);
+      } else bins.push({ ids: [id], files: own });
+    }
+    out.push(...bins.map((b) => b.ids));
+  }
+  return { waves: out, clashes };
+}
+function waveStats(board, waves, clashes = []) {
+  const cards = board.list();
+  const count = (action) => cards.filter((c) => c.stageHistory.some((e) => e.action === action)).length;
+  return {
+    tasks: cards.length,
+    waves: waves.length,
+    width: waves.length ? Number((cards.length / waves.length).toFixed(1)) : 0,
+    widest: waves.reduce((n, w) => Math.max(n, w.length), 0),
+    clashes: clashes.length,
+    conflicts: count("merge-conflict"),
+    failed: count("task-failed"),
+    skipped: count("skipped"),
+    // A task that reached a senior/council tier cost several times what a first-pass task did.
+    escalated: cards.filter((c) => c.attempts > 1).length,
+    attempts: cards.reduce((n, c) => n + c.attempts, 0)
+  };
+}
+function describeWaves(s) {
+  const parts = [
+    `${s.tasks} task, ${s.waves} dependency layer(s) deep \u2014 ${s.width} per layer, widest ${s.widest}`,
+    s.clashes ? `${s.clashes} file clash(es) split apart` : "",
+    s.conflicts ? `${s.conflicts} merge conflict(s)` : "",
+    s.escalated ? `${s.escalated} task(s) took more than one attempt (${s.attempts} total)` : "",
+    s.failed ? `${s.failed} failed` : "",
+    s.skipped ? `${s.skipped} skipped` : ""
+  ];
+  return parts.filter(Boolean).join(" \xB7 ");
+}
+
+// src/engine/team-lead.ts
+var fix = z4.object({ task: z4.string(), needs: z4.string(), why: z4.string() });
+var DepAuditSchema = z4.object({
+  missing: z4.array(fix).default([]),
+  spurious: z4.array(fix).default([])
+});
+var AUDIT_TIMEOUT_MS = 9e4;
+var MAX_AUDIT_CARDS = 40;
+function describeCards(board, ids) {
+  return board.list().filter((c) => ids.has(c.id)).map((c) => {
+    const files = c.files.length ? `
+  writes: ${c.files.join(", ")}` : "";
+    const acc = c.acceptance.length ? `
+  done when: ${c.acceptance.join("; ")}` : "";
+    return `- ${c.id}: "${c.title}" deps=[${c.deps.join(", ")}]${files}${acc}`;
+  }).join("\n");
+}
+async function runTeamLead(opts, board) {
+  const suggested = computeWaves(board);
+  const parallel = suggested.filter((w) => w.length > 1);
+  if (parallel.length === 0) return { waves: suggested, added: [], suspected: [] };
+  const subject = new Set(parallel.flat());
+  for (const id of [...subject]) for (const d of board.get(id)?.deps ?? []) subject.add(d);
+  if (subject.size > MAX_AUDIT_CARDS) {
+    return { waves: suggested, added: [], suspected: [], skipped: `${subject.size} tasks would run in parallel \u2014 more than one reading can judge` };
+  }
+  const msg = {
+    role: "user",
+    content: `Tasks:
+${describeCards(board, subject)}
+
+Given those dependencies, these groups would run AT THE SAME TIME, in separate worktrees, each starting from the same base:
+${parallel.map((w) => `- ${w.join(", ")}`).join("\n")}
+
+Audit the dependencies. Two questions:
+1. missing \u2014 is there a task in one of those groups that CANNOT run yet, because it needs something another task in the same group creates (a function, a type, a table, a config key)? Report only what would BREAK the work, not what would merely be more convenient in a different order.
+2. spurious \u2014 is any declared dependency unnecessary, holding a task back for no reason?
+
+Both lists are normally empty. Return {missing, spurious} via submit; each entry is {task, needs, why} where "task" cannot start until "needs" is done.`
+  };
+  let audit;
+  try {
+    audit = await runStructuredRole({
+      ...opts,
+      messages: [...opts.messages, msg],
+      // Bounded: an advisory check must never be the reason a run does nothing.
+      signal: AbortSignal.any([opts.signal, AbortSignal.timeout(AUDIT_TIMEOUT_MS)])
+    }, DepAuditSchema);
+  } catch (e) {
+    if (opts.signal.aborted) throw e;
+    return { waves: suggested, added: [], suspected: [], skipped: "the check did not come back in time" };
+  }
+  const added = [];
+  for (const f of audit.missing) {
+    if (!board.addDep(f.task, f.needs)) continue;
+    try {
+      computeWaves(board);
+      added.push(f);
+    } catch {
+      board.removeDep(f.task, f.needs);
+    }
+  }
+  return { waves: computeWaves(board), added, suspected: audit.spurious };
+}
+
+// src/engine/timings.ts
+var Timings = class {
+  constructor(now = () => Date.now()) {
+    this.now = now;
+  }
+  now;
+  totals = /* @__PURE__ */ new Map();
+  record(stage, ms) {
+    const t = this.totals.get(stage) ?? { ms: 0, n: 0 };
+    t.ms += Math.max(0, ms);
+    t.n += 1;
+    this.totals.set(stage, t);
+  }
+  /** Times `fn`, recording it whether it succeeds or throws — a stage that fails still consumed the time. */
+  async time(stage, fn) {
+    const started = this.now();
+    try {
+      return await fn();
+    } finally {
+      this.record(stage, this.now() - started);
+    }
+  }
+  /** Every stage, heaviest first. */
+  summary() {
+    return [...this.totals.entries()].map(([stage, t]) => ({ stage, ms: t.ms, n: t.n })).sort((a, b) => b.ms - a.ms);
+  }
+  get empty() {
+    return this.totals.size === 0;
+  }
+};
+var minutes = (ms) => ms < 6e4 ? `${Math.round(ms / 1e3)}s` : `${Math.round(ms / 6e4)}m`;
+function describeTimings(t) {
+  const rows = t.summary();
+  if (!rows.length) return "";
+  const total = rows.reduce((n, r) => n + r.ms, 0);
+  if (total <= 0) return "";
+  const parts = rows.filter((r) => r.ms / total >= 0.01).map((r) => `${r.stage} ${minutes(r.ms)} (${Math.round(r.ms / total * 100)}% \xB7 ${r.n}\xD7)`);
+  return `\u23F1\uFE0F Slot time \u2014 ${parts.join(" \xB7 ")}`;
+}
+
+// src/engine/wave-engine.ts
+var MAX_PARALLEL_TASKS = 4;
+var TEAM_LEAD_MAX_TURNS = 3;
+var MAX_WAKES = 3;
+var RESTART_AFTER_CONFLICTS = 3;
+var MAX_RESTARTS = 2;
+function createMutex() {
+  let tail = Promise.resolve();
+  return (fn) => {
+    const result = tail.then(() => fn());
+    tail = result.then(() => void 0, () => void 0);
+    return result;
+  };
+}
+async function runReady(deps, session, board) {
+  const ser = createMutex();
+  const cards = board.list().filter((c) => c.id !== REVISION_CARD);
+  const done = new Set(cards.filter((c) => c.column === "MERGED").map((c) => c.id));
+  const merged = [...done];
+  const failed = [];
+  const skipped = [];
+  const parked = /* @__PURE__ */ new Map();
+  const restartOn = /* @__PURE__ */ new Map();
+  const conflictedAt = /* @__PURE__ */ new Map();
+  const conflictRuns = (cardId) => {
+    const h = board.get(cardId)?.stageHistory ?? [];
+    const since = h.map((e) => e.action).lastIndexOf("restarted");
+    return h.slice(since + 1).filter((e) => e.action === "conflict:resolve-failed").length;
+  };
+  const restartsSoFar = (cardId) => (board.get(cardId)?.stageHistory ?? []).filter((e) => e.action === "restarted").length;
+  const pending = new Set(cards.filter((c) => !done.has(c.id)).map((c) => c.id));
+  for (const id of pending) {
+    const c = board.get(id);
+    if (!c || c.attempts === 0) continue;
+    board.resetAttempts(id);
+  }
+  const busy = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Map();
+  const free = [];
+  let minted = 0;
+  const ceiling = () => Math.max(1, deps.maxParallel ?? MAX_PARALLEL_TASKS);
+  const depsOf = (id) => board.get(id)?.deps ?? [];
+  const filesOf = (id) => (board.get(id)?.files ?? []).map(normalizePath).filter(Boolean);
+  const park = (id, reason, on, startedAt) => {
+    parked.set(id, { reason, on, mergedAt: startedAt ?? merged.length, wakes: wakeCount.get(id) ?? 0 });
+    pending.delete(id);
+    board.appendStage(id, {
+      role: "team-lead",
+      action: "parked",
+      note: reason === "waiting" ? `waiting for ${on}` : reason === "conflict" ? "merge conflicted" : "ladder exhausted"
+    });
+    board.move(id, "PARKED", "team-lead");
+  };
+  const wake = () => {
+    let woken = 0;
+    for (const [id, p] of [...parked]) {
+      if (p.wakes >= MAX_WAKES) continue;
+      const ready = p.reason === "waiting" ? p.on !== void 0 && done.has(p.on) : merged.length > p.mergedAt;
+      if (!ready) continue;
+      parked.delete(id);
+      pending.add(id);
+      board.resetAttempts(id);
+      board.appendStage(id, { role: "team-lead", action: "woken", note: `${p.reason} \u2192 retrying (wake ${p.wakes + 1})` });
+      board.move(id, "TODO", "team-lead");
+      wakeCount.set(id, p.wakes + 1);
+      woken += 1;
+    }
+    return woken;
+  };
+  const wakeCount = /* @__PURE__ */ new Map();
+  const parkUnreachable = () => {
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const id of [...pending]) {
+        const blocker = depsOf(id).find((d) => parked.has(d));
+        if (blocker === void 0) continue;
+        park(id, "waiting", blocker);
+        changed = true;
+      }
+    }
+  };
+  while (pending.size > 0 || running.size > 0 || parked.size > 0) {
+    parkUnreachable();
+    const limit = ceiling();
+    for (const id of [...pending]) {
+      if (running.size >= limit) break;
+      if (!depsOf(id).every((d) => done.has(d))) continue;
+      const files = filesOf(id);
+      if (files.some((f) => busy.has(f))) continue;
+      pending.delete(id);
+      telemetry().event("decision.schedule", {
+        "hc.decision": "schedule",
+        "hc.task.id": id,
+        "hc.slot": free[free.length - 1] ?? minted,
+        "hc.running": running.size + 1,
+        "hc.limit": limit,
+        "hc.pending": pending.size
+      });
+      for (const f of files) busy.add(f);
+      const mergedAtStart = merged.length;
+      const slot = free.pop() ?? minted++;
+      running.set(slot, (async () => {
+        try {
+          const resolveConflict = async (tw, conflicted) => {
+            try {
+              const r = await resolveMergeConflict(deps, session, board, id, tw);
+              return r.status === "resolved" ? { status: "merged" } : { status: "conflict", files: conflicted };
+            } catch (e) {
+              if (deps.signal.aborted) throw e;
+              board.appendStage(id, {
+                role: "operational",
+                action: "conflict:resolve-failed",
+                note: e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200)
+              });
+              conflictedAt.set(id, tw);
+              if (conflictRuns(id) >= RESTART_AFTER_CONFLICTS && restartsSoFar(id) < MAX_RESTARTS) {
+                restartOn.set(id, tw);
+              }
+              try {
+                await deps.manager.abortMerge(session);
+              } catch {
+              }
+              return { status: "conflict", files: conflicted };
+            }
+          };
+          const res = await runWaveTask({ ...deps, serialize: ser, resolveConflict, baseRef: session.baseBranch }, session, board, id, slot);
+          if (res.status === "merged") {
+            merged.push(id);
+            done.add(id);
+            try {
+              await deps.manager.removeTask(session, res.task);
+            } catch {
+            }
+          } else if (res.status === "conflict" && restartOn.has(id)) {
+            const tw = restartOn.get(id);
+            restartOn.delete(id);
+            try {
+              const retired = await deps.manager.restartTask(session, tw);
+              board.appendStage(id, {
+                role: "team-lead",
+                action: "restarted",
+                note: `merge unresolvable after ${RESTART_AFTER_CONFLICTS} attempts \u2014 rewriting from the current base (the reviewed work is kept on ${retired})`
+              });
+              board.resetAttempts(id);
+              board.move(id, "TODO", "team-lead");
+              pending.add(id);
+            } catch (e) {
+              board.appendStage(id, {
+                role: "team-lead",
+                action: "restart-failed",
+                note: e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200)
+              });
+              park(id, "conflict", void 0, mergedAtStart);
+            }
+          } else park(id, res.status === "conflict" ? "conflict" : "exhausted", void 0, mergedAtStart);
+        } finally {
+          for (const f of files) busy.delete(f);
+          free.push(slot);
+        }
+        return slot;
+      })());
+    }
+    if (running.size === 0) {
+      if (wake() > 0) continue;
+      const stuck = [...parked].filter(([id, p]) => p.reason === "conflict" && conflictedAt.has(id) && restartsSoFar(id) < MAX_RESTARTS);
+      let rewrote = 0;
+      for (const [id] of stuck) {
+        const tw = conflictedAt.get(id);
+        conflictedAt.delete(id);
+        restartOn.delete(id);
+        try {
+          const retired = await deps.manager.restartTask(session, tw);
+          board.appendStage(id, {
+            role: "team-lead",
+            action: "restarted",
+            note: `merge unresolvable and nothing left to wake it \u2014 rewriting from the current base (the reviewed work is kept on ${retired})`
+          });
+          board.resetAttempts(id);
+          board.move(id, "TODO", "team-lead");
+          parked.delete(id);
+          pending.add(id);
+          rewrote++;
+        } catch (e) {
+          board.appendStage(id, {
+            role: "team-lead",
+            action: "restart-failed",
+            note: e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200)
+          });
+        }
+      }
+      if (rewrote > 0) continue;
+      for (const [id, p] of parked) {
+        (p.reason === "waiting" ? skipped : failed).push(id);
+        board.appendStage(id, {
+          role: "team-lead",
+          action: "abandoned",
+          note: p.wakes >= MAX_WAKES ? `out of wakes after ${p.wakes}` : `${p.reason}: nothing left that could change it`
+        });
+        board.move(id, "ABANDONED", "team-lead");
+      }
+      for (const id of pending) {
+        skipped.push(id);
+        board.appendStage(id, { role: "team-lead", action: "abandoned", note: "its dependencies never completed" });
+        board.move(id, "ABANDONED", "team-lead");
+      }
+      parked.clear();
+      pending.clear();
+      break;
+    }
+    running.delete(await Promise.race(running.values()));
+    wake();
+  }
+  return { merged, failed, skipped };
+}
+function teamLeadOpts(deps, session) {
+  const tl = deps.roleRegistry.resolve("team-lead");
+  const tools = new ToolRegistry();
+  tools.register(buildSkillTool(deps.skillRegistry));
+  return {
+    provider: deps.provider,
+    ...tl,
+    tools,
+    messages: [],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: session.baseWorktree,
+    signal: deps.signal,
+    /**
+     * The question is answerable from the prompt alone — the tasks, their files and their criteria are all
+     * in it. Left at the default fifty turns per attempt, a model that would not call `submit` walked its
+     * whole fallback chain instead: seventy-three calls and 1.5M tokens re-sending the same task list, four
+     * and a half minutes before a single agent started, and nothing on screen to say so.
+     */
+    maxTurns: TEAM_LEAD_MAX_TURNS
+  };
+}
+async function runWaves(deps, session, board, opts) {
+  const todo = board.list().filter((c) => c.column !== "MERGED").length;
+  deps.note?.(`\u{1F9ED} Planning the run \u2014 ${todo} task(s) left, up to ${deps.maxParallel ?? MAX_PARALLEL_TASKS} at a time. Checking their dependencies before scheduling.`);
+  const plan = await runTeamLead(teamLeadOpts(deps, session), board);
+  if (plan.skipped) deps.note?.(`\u{1F9ED} Dependency check skipped \u2014 ${plan.skipped}. Scheduling from the plan as written.`);
+  if (plan.added.length) {
+    deps.note?.(
+      `\u{1F517} ${plan.added.length} dependency the breakdown did not state \u2014 ${plan.added.map((f) => `${f.task} needs ${f.needs}`).join(", ")}. Those tasks no longer run together.`
+    );
+  }
+  if (plan.suspected.length) {
+    deps.note?.(
+      `\u{1F4A4} ${plan.suspected.length} dependency looks unnecessary and is holding work back: ${plan.suspected.map((f) => `${f.task}\u2192${f.needs}`).join(", ")}. Left in place.`
+    );
+  }
+  const { waves, clashes } = splitFileConflicts(plan.waves, board);
+  if (clashes.length) {
+    deps.note?.(
+      `\u{1F500} ${clashes.length} task pair(s) write the same file \u2014 they will not run at the same time: ${clashes.slice(0, 3).map((c) => `${c.a}/${c.b} (${c.files[0]})`).join(", ")}${clashes.length > 3 ? ", \u2026" : ""}`
+    );
+  }
+  const outcome = await runReady(deps, session, board);
+  const failed = outcome.failed;
+  const skipped = outcome.skipped;
+  const delivery = { branch: session.baseBranch, worktree: session.baseWorktree };
+  deps.note?.(`\u{1F4CA} ${describeWaves(waveStats(board, waves, clashes))}`);
+  if (deps.timings && !deps.timings.empty) deps.note?.(describeTimings(deps.timings));
+  const shape = waveStats(board, waves, clashes);
+  telemetry().event("run.summary", {
+    "hc.tasks": shape.tasks,
+    "hc.layers": shape.waves,
+    "hc.widest": shape.widest,
+    "hc.clashes": shape.clashes,
+    "hc.conflicts": shape.conflicts,
+    "hc.failed": shape.failed,
+    "hc.skipped": shape.skipped,
+    "hc.attempts": shape.attempts
+  });
+  if (failed.length === 0 && skipped.length === 0) {
+    await deps.manager.push(session);
+    if (await deps.manager.hasRemote(session)) {
+      const summary = await prSummary(deps, {
+        request: opts.request ?? session.jobSlug,
+        // …every card EXCEPT the revision row: it is bookkeeping, and it was published as work. Measured on
+        // PR #765, where the task list ended "- PR revision" among the 27 things that were actually built.
+        cards: board.list().filter((c) => c.id !== REVISION_CARD),
+        cwd: session.baseWorktree,
+        base: opts.base,
+        jobSlug: session.jobSlug
+      });
+      const pr = await deps.manager.openPR(session, deps.prAdapter, {
+        base: opts.base,
+        title: opts.prTitle ?? summary.title,
+        body: summary.body
+      });
+      return { status: "completed", session, pr, delivery, waves };
+    }
+    return { status: "completed", session, delivery, waves };
+  }
+  return { status: "partial", session, failed, skipped, delivery, waves };
+}
+
+// src/terminal.ts
+import { createInterface } from "readline/promises";
+function makeAskUser(read) {
+  return (question, opts) => {
+    const steps = opts?.steps ?? [];
+    if (!steps.length) return read(`
+[question] ${question}`, opts);
+    const body = steps.map((s, i) => `${i + 1}. ${s}`).join("\n");
+    return read(`
+[action] ${body}
+
+${question}`, opts);
+  };
+}
+function makeApprove(read) {
+  return async (req) => {
+    const ans = (await read(`
+[permission] ${req.preview}
+approve? (y/n)`)).trim().toLowerCase();
+    return ans === "y" || ans === "yes";
+  };
+}
+function nodeLineReader(input = process.stdin, output = process.stdout) {
+  const rl = createInterface({ input, output });
+  const buffered = [];
+  const waiters = [];
+  let closed = false;
+  rl.on("line", (line) => {
+    const w = waiters.shift();
+    if (w) w(line);
+    else buffered.push(line);
+  });
+  rl.on("close", () => {
+    closed = true;
+    while (waiters.length) waiters.shift()("");
+  });
+  const read = async (prompt, opts) => {
+    const shown = opts?.options?.length ? `${prompt}
+${opts.options.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` + (opts.multiSelect ? "\n(enter one or more numbers, comma-separated)" : "") : prompt;
+    rl.setPrompt(shown + "\n> ");
+    rl.prompt();
+    let line;
+    if (buffered.length) line = buffered.shift();
+    else if (closed) line = "";
+    else line = await new Promise((resolve) => {
+      waiters.push(resolve);
+    });
+    const options = opts?.options;
+    if (options?.length) {
+      const picks = line.split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+        const n = Number(s);
+        return Number.isInteger(n) && n >= 1 && n <= options.length ? options[n - 1] : s;
+      });
+      if (picks.length) return picks.join("; ");
+    }
+    return line;
+  };
+  return { read, close: () => rl.close() };
+}
+
+// src/session/memory.ts
+import { mkdir, writeFile as writeFile2, readFile as readFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { createHash } from "crypto";
+
+// src/engine/memory-dedupe.ts
+var CANDIDATE_BAR = 0.6;
+var MAX_GROUPS = 12;
+function duplicateCandidates(entries) {
+  const groups = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < entries.length; i++) {
+    const a = entries[i];
+    if (placed.has(a.id)) continue;
+    const group = [a];
+    for (let j = i + 1; j < entries.length; j++) {
+      const b = entries[j];
+      if (placed.has(b.id)) continue;
+      if ((a.kind ?? "fact") !== (b.kind ?? "fact")) continue;
+      if (relationStrength(a, b) < CANDIDATE_BAR) continue;
+      group.push(b);
+      placed.add(b.id);
+    }
+    if (group.length > 1) {
+      placed.add(a.id);
+      groups.push(group);
+    }
+  }
+  return groups.map((g) => ({ ids: g.map((e) => e.id), texts: g.map((e) => e.text) }));
+}
+var SYSTEM = "You reconcile a project's memory. You are conservative: two notes about the same file are not the same note, and you never merge claims that could both be true and separately useful.";
+var PROMPT = (groups) => `Each group below holds notes that MIGHT be the same thing said twice, by different workers that could not see each other.
+
+For each group, decide which notes state the SAME claim. Merge only those.
+
+- If they say the same thing, give ONE wording that keeps every specific detail from all of them (file names, identifiers, exceptions, numbers). Losing a detail is worse than keeping two notes.
+- If they are about the same subject but state DIFFERENT things, do not merge them.
+- If one is a strictly more complete version of another, merge into the complete one.
+
+` + groups.map((g, i) => `GROUP ${i}:
+${g.texts.map((t, j) => `  [${j}] ${t}`).join("\n")}`).join("\n\n") + `
+
+Answer with a fenced json block: {"merges":[{"group":0,"indexes":[0,1],"text":"..."}]}
+Include only the groups you are merging; omit the rest.`;
+function parse(out, groups) {
+  const fence = /```(?:json)?\s*([\s\S]*?)```/.exec(out);
+  const raw = fence ? fence[1] : out.slice(out.indexOf("{"));
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed.merges)) return [];
+  const out2 = [];
+  for (const m of parsed.merges) {
+    const g = groups[typeof m.group === "number" ? m.group : -1];
+    if (!g || typeof m.text !== "string" || !m.text.trim() || !Array.isArray(m.indexes)) continue;
+    const ids = m.indexes.filter((n) => typeof n === "number" && n >= 0 && n < g.ids.length).map((n) => g.ids[n]);
+    if (new Set(ids).size > 1) out2.push({ ids: [...new Set(ids)], text: m.text.trim() });
+  }
+  return out2;
+}
+async function dedupeMemories(opts) {
+  const groups = duplicateCandidates(opts.entries).slice(0, MAX_GROUPS);
+  if (!groups.length) return [];
+  for (const model of opts.models.filter(Boolean)) {
+    const req = {
+      model,
+      messages: [{ role: "system", content: SYSTEM }, { role: "user", content: PROMPT(groups) }],
+      tools: []
+    };
+    let out = "";
+    try {
+      for await (const ev of opts.provider.chat(req, opts.signal ?? new AbortController().signal)) {
+        if (ev.type === "text-delta") out += ev.text;
+        else if (ev.type === "error") throw new Error(ev.message);
+      }
+    } catch {
+      continue;
+    }
+    return parse(out, groups);
+  }
+  return [];
+}
+function applyMerges(entries, merges) {
+  const byId = new Map(entries.map((e) => [e.id, e]));
+  const dropped = /* @__PURE__ */ new Set();
+  for (const m of merges) {
+    const keeper = byId.get(m.ids[0]);
+    if (!keeper) continue;
+    const others = m.ids.slice(1).map((id) => byId.get(id)).filter((e) => !!e);
+    if (!others.length) continue;
+    keeper.text = m.text;
+    keeper.uses = (keeper.uses ?? 0) + others.reduce((n, o) => n + (o.uses ?? 0), 0);
+    keeper.injections = (keeper.injections ?? 0) + others.reduce((n, o) => n + (o.injections ?? 0), 0);
+    keeper.observedInjections = (keeper.observedInjections ?? 0) + others.reduce((n, o) => n + (o.observedInjections ?? 0), 0);
+    for (const o of others) dropped.add(o.id);
+  }
+  return { entries: entries.filter((e) => !dropped.has(e.id)), removed: dropped.size };
+}
+
+// src/session/memory.ts
+import { readFileSync, statSync } from "fs";
+
+// src/engine/memory-hygiene.ts
+var DAY = 24 * 60 * 60 * 1e3;
+var REVIEW_AGE_MS = 30 * DAY;
+var STALE_AGE_MS = 90 * DAY;
+var UNUSED_INJECTIONS = 10;
+var LOW_CONFIDENCE = 0.5;
+function normalizeTextKey(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]+/g, " ").replace(/\s+/g, " ").trim();
+}
+var union = (a, b) => [.../* @__PURE__ */ new Set([...a, ...b])];
+function absorb(keeper, loser) {
+  return {
+    ...keeper,
+    anchors: union(keeper.anchors, loser.anchors),
+    tags: union(keeper.tags, loser.tags),
+    uses: (keeper.uses ?? 0) + (loser.uses ?? 0),
+    injections: (keeper.injections ?? 0) + (loser.injections ?? 0),
+    importance: Math.max(importanceOf(keeper), importanceOf(loser)),
+    confidence: Math.max(confidenceOf(keeper), confidenceOf(loser)),
+    // The keeper's own fingerprints win: they describe the anchors its text was actually written against.
+    anchorHashes: { ...loser.anchorHashes, ...keeper.anchorHashes },
+    // A permanent duplicate makes the survivor permanent — the stronger claim on lifetime wins.
+    ...loser.persistence === "permanent" ? { persistence: "permanent" } : {}
+  };
+}
+function betterKeeper(a, b) {
+  if (importanceOf(a) !== importanceOf(b)) return importanceOf(a) > importanceOf(b) ? a : b;
+  if ((a.uses ?? 0) !== (b.uses ?? 0)) return (a.uses ?? 0) > (b.uses ?? 0) ? a : b;
+  return a.createdAt <= b.createdAt ? a : b;
+}
+function reviewReason(e, now) {
+  if (e.persistence === "permanent") return void 0;
+  const age = now - e.createdAt;
+  if (e.expiresAt !== void 0 && e.expiresAt <= now) return "expired";
+  if ((e.observedInjections ?? 0) >= UNUSED_INJECTIONS && (e.uses ?? 0) === 0 && age >= REVIEW_AGE_MS) return "injected-never-used";
+  if (confidenceOf(e) < LOW_CONFIDENCE && age >= REVIEW_AGE_MS) return "low-confidence";
+  if (e.stale && age >= STALE_AGE_MS) return "long-stale";
+  return void 0;
+}
+function hygiene(entries, now) {
+  const groups = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const e of entries) {
+    const key = `${e.kind ?? "fact"}::${normalizeTextKey(e.text)}`;
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      order.push(key);
+    }
+    groups.get(key).push(e);
+  }
+  const merged = [];
+  const kept = [];
+  for (const key of order) {
+    const group = groups.get(key);
+    if (group.length === 1) {
+      kept.push(group[0]);
+      continue;
+    }
+    const keeper = group.reduce(betterKeeper);
+    const losers = group.filter((e) => e.id !== keeper.id);
+    kept.push(losers.reduce(absorb, keeper));
+    merged.push({ keeper: keeper.id, absorbed: losers.map((l) => l.text) });
+  }
+  const candidates = [];
+  for (const e of kept) {
+    const reason = reviewReason(e, now);
+    if (reason) candidates.push({ id: e.id, text: e.text, reason });
+  }
+  return { entries: kept, merged, candidates };
+}
+
+// src/session/memory.ts
+var HASH_MAX_BYTES = 512 * 1024;
+var USAGE_FILE = "memory-usage.json";
+var MemoryStore = class {
+  file;
+  /** Per-id counters, machine-local. Loaded with the store, written when they change. */
+  usage = {};
+  now;
+  cache;
+  queue = Promise.resolve();
+  // serializes mutations (safe under parallel writers)
+  /** Runs a mutation with exclusive access → no interleaved read-modify-write across concurrent callers. */
+  serialize(fn) {
+    const run = this.queue.then(fn, fn);
+    this.queue = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  cwd;
+  lastVerify = 0;
+  /**
+   * Set while a JOB is running and its session has not opened yet — the window in which the root must not be
+   * touched. Not derived from the directory: a person typing `/remember` in chat is writing to the project on
+   * purpose, and that is the feature. This is only about what a run does as a SIDE EFFECT.
+   */
+  deferred = false;
+  /**
+   * Entries learned before a session existed, held until one does.
+   *
+   * The store is built when the process starts, and the only directory it can be given then is the PROJECT.
+   * Refining, sizing and triage all run in that window and all can learn something. Writing it at the root
+   * is what left `memory.jsonl` modified there for every later merge to trip over; dropping it would lose
+   * the lessons those phases paid for. So it waits, and lands in the session the moment one opens.
+   */
+  pending = [];
+  candidates = [];
+  // ids the last hygiene run put up for review
+  constructor(opts) {
+    this.now = opts.now ?? (() => Date.now());
+    this.cwd = opts.cwd;
+    this.file = join3(stateRoot(opts.cwd), ".horsecode", "memory.jsonl");
+  }
+  /**
+   * Hold everything learned from here until a session exists.
+   *
+   * Called when a job starts, because refining, sizing and triage all run before the worktree is opened and
+   * all can learn something. Writing it at the root left `memory.jsonl` modified in the project checkout —
+   * one of four files (with `graphify-out/` and the traces) that both sides of a merge regenerate, so every
+   * later pull refused to apply. Dropping it instead would lose what those phases paid for.
+   */
+  deferUntilSession() {
+    this.deferred = writableStateRoot(this.cwd) === void 0;
+  }
+  /**
+   * Points the store at a session's base worktree, or back at the project when the session ends.
+   *
+   * `stateRoot` resolves the right file for a given directory — but the store is built once, when the
+   * process starts, and the only directory it can be given then is the PROJECT. A session opens later, so
+   * the path computed in the constructor stayed the project's for the whole run.
+   *
+   * Measured on a real job: the session's inherited `memory.jsonl` was never written after the moment it was
+   * copied, while the project's gained 26 uses and 85 injections during the same hour. Everything the run
+   * learned landed in the reference copy and outside the pull request — the opposite of the rule that the
+   * root is read, and the session is what ships.
+   *
+   * The cache is dropped rather than carried across: the two files are separate records, and keeping entries
+   * loaded from one while writing to the other is how a session would overwrite the project's memory with a
+   * stale snapshot of itself.
+   */
+  retarget(cwd) {
+    if (writableStateRoot(cwd) !== void 0) this.deferred = false;
+    const next = join3(stateRoot(cwd), ".horsecode", "memory.jsonl");
+    if (next === this.file) return;
+    this.file = next;
+    this.cache = void 0;
+  }
+  /** Where entries are being written right now — for tests, and for anything that reports on state. */
+  filePath() {
+    return this.file;
+  }
+  /** Project-relative content fingerprint, used to detect that an anchored file moved on. */
+  anchorFs = {
+    fingerprint: (rel) => {
+      try {
+        const abs = join3(this.cwd, rel);
+        const st = statSync(abs);
+        if (!st.isFile()) return void 0;
+        if (st.size > HASH_MAX_BYTES) return `s${st.size}:${Math.floor(st.mtimeMs)}`;
+        return createHash("sha256").update(readFileSync(abs)).digest("hex").slice(0, 16);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+  /**
+   * Re-checks every entry's file anchors and flags the ones whose anchored code changed. Throttled: retrieval
+   * asks for `all()` on every turn, and re-hashing on each call would be pure waste.
+   */
+  verify(force = false) {
+    if (!this.cache) return;
+    const t = this.now();
+    if (!force && t - this.lastVerify < 2e3) return;
+    this.lastVerify = t;
+    for (const e of this.cache) {
+      const fresh = verifyAnchors(e, this.anchorFs);
+      if (e.stale !== !fresh) e.stale = !fresh;
+    }
+  }
+  /** Load entries from disk (memoized). Corrupt lines are skipped. */
+  async load() {
+    if (this.cache) return this.cache;
+    const out = [];
+    try {
+      const raw = await readFile2(this.file, "utf8");
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          out.push(JSON.parse(line));
+        } catch {
+        }
+      }
+    } catch {
+    }
+    this.cache = out;
+    await this.loadUsage(out);
+    if (!this.deferred && this.pending.length) {
+      for (const e of this.pending) out.push({ ...e, id: this.mintId() });
+      this.pending = [];
+      await this.persist();
+    }
+    const repaired = this.dedupeIds(out);
+    const retagged = this.retag(out);
+    if (repaired || retagged) await this.persist();
+    return out;
+  }
+  /**
+   * Re-derives tags for entries written under an older rule.
+   *
+   * Tags are stored, so fixing how they are derived does nothing for memories already on disk — and the rule
+   * that was fixed had been dropping the meaningful words: a fact about `DomainException` kept `types`,
+   * `must` and `including` while losing `domain` and `exception`, which is what a query would have matched.
+   * On the real pool that entry scored ZERO for the question it was written to answer.
+   *
+   * `deriveTags` is pure, so recomputing is safe and idempotent: an entry already tagged correctly produces
+   * exactly what it has. Returns whether anything changed.
+   */
+  retag(entries) {
+    let changed = false;
+    for (const e of entries) {
+      const fresh = deriveTags(e.text, e.anchors ?? []);
+      if (fresh.length === e.tags?.length && fresh.every((t, i) => e.tags[i] === t)) continue;
+      e.tags = fresh;
+      changed = true;
+    }
+    return changed;
+  }
+  /**
+   * Gives a fresh id to every entry that shares one, keeping the first.
+   *
+   * Files written before ids were minted uniquely already carry collisions — the real one measured 1471
+   * entries under 1344 ids — and nothing downstream can tell those rows apart: every consumer resolves an id
+   * with `find`, which returns the first match. Repairing on load fixes them without asking the user to
+   * notice a problem they cannot see.
+   *
+   * Returns whether anything changed, so a healthy file is never rewritten.
+   */
+  dedupeIds(entries) {
+    const seen = /* @__PURE__ */ new Set();
+    let changed = false;
+    for (const e of entries) {
+      if (!seen.has(e.id)) {
+        seen.add(e.id);
+        continue;
+      }
+      let id = `${e.id}-2`;
+      for (let n = 3; seen.has(id); n++) id = `${e.id}-${n}`;
+      e.id = id;
+      seen.add(id);
+      changed = true;
+    }
+    return changed;
+  }
+  /**
+   * Synchronous snapshot of the entries — LOADING them if nobody has yet.
+   *
+   * It used to be `this.cache ?? []`, which is a snapshot of whatever happened to have been read already, and
+   * `retarget` — the very call that points the store at a newly opened session — ends by clearing the cache.
+   * So from the moment a session opened, every retrieval saw an empty store, for the rest of the run.
+   *
+   * It was invisible for three runs because it looks exactly like a project with nothing worth recalling: the
+   * start-up banner said "746 entries" (read before the session existed), the file on disk had all of them,
+   * selection returned five hits when run by hand against the same file, and the injector reported nothing.
+   * What finally named it was recording the MISS: `reason: empty-store, available: 0` on a role whose store
+   * demonstrably had 721 selectable entries.
+   *
+   * Synchronous because every caller is: retrieval happens while a prompt is being assembled, and an `async`
+   * load there would mean changing every role's assembly for a file read that takes under a millisecond.
+   */
+  all() {
+    if (!this.cache) this.loadSync();
+    this.verify();
+    return this.cache ?? [];
+  }
+  /**
+   * The same read as {@link load}, without awaiting.
+   *
+   * Deliberately does NOT do `load`'s extra work — adopting `pending` entries and re-minting their ids writes
+   * to disk, and a read must not. Those still land through `load`, which every write path already awaits.
+   */
+  loadSync() {
+    const out = [];
+    try {
+      for (const line of readFileSync(this.file, "utf8").split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          out.push(JSON.parse(line));
+        } catch {
+        }
+      }
+    } catch {
+    }
+    this.cache = out;
+  }
+  /**
+   * Drops entries past their hard expiry. `permanent` is exempt by definition; everything else only expires if
+   * it was given an explicit TTL, so nothing silently disappears that was not marked short-lived.
+   */
+  async pruneExpired() {
+    return this.serialize(async () => {
+      await this.load();
+      const now = this.now();
+      const before = this.cache.length;
+      this.cache = this.cache.filter((e) => !isExpired(e, now));
+      const dropped = before - this.cache.length;
+      if (dropped > 0) await this.persist();
+      return dropped;
+    });
+  }
+  /**
+   * Reconciles the pool: merges duplicates and returns the entries now up for review. Never deletes — a wrong
+   * automatic deletion is unrecoverable here (the file is the only copy), so questionable entries are only
+   * flagged. Runs once per session and on demand.
+   */
+  async runHygiene(opts) {
+    return this.serialize(async () => {
+      await this.load();
+      this.verify(true);
+      const report = hygiene(this.cache, this.now());
+      let entries = report.entries;
+      let semantic = 0;
+      if (opts) {
+        const merges = await dedupeMemories({ ...opts, entries });
+        const applied = applyMerges(entries, merges);
+        entries = applied.entries;
+        semantic = applied.removed;
+      }
+      if (report.merged.length || semantic > 0) {
+        this.cache = entries;
+        await this.persist();
+      }
+      this.candidates = report.candidates.map((c) => c.id);
+      return { ...report, entries, semanticMerged: semantic };
+    });
+  }
+  /** Ids flagged by the last hygiene run — surfaced by /memories next to the lifecycle state. */
+  reviewCandidates() {
+    return [...this.candidates];
+  }
+  /**
+   * Records that these memories were put into a prompt. Without the count there is no way to tell a memory that
+   * is genuinely never relevant from one that has simply never come up — and the first should stop winning slots.
+   */
+  async recordInjection(ids) {
+    if (!ids.length) return;
+    return this.serialize(async () => {
+      await this.load();
+      let touched = false;
+      for (const id of ids) {
+        const e = this.cache.find((m) => m.id === id);
+        if (!e) continue;
+        e.injections = (e.injections ?? 0) + 1;
+        e.observedInjections = (e.observedInjections ?? 0) + 1;
+        this.usage[id] = { injections: e.injections, observedInjections: e.observedInjections };
+        touched = true;
+      }
+      if (touched) await this.persistUsage();
+    });
+  }
+  /** Entries currently flagged stale — surfaced by /memory so the user can re-confirm or delete them. */
+  stale() {
+    this.verify();
+    return (this.cache ?? []).filter((e) => e.stale);
+  }
+  /**
+   * A NEW id, unique against everything already held.
+   *
+   * The id used to be the millisecond clock alone, which is unique only while writes are seconds apart. A
+   * migration importing 1878 facts in one loop put several into the same millisecond: measured on the real
+   * file, 1471 entries carried 1344 distinct ids — 101 ids shared by up to five entries each.
+   *
+   * That is not cosmetic. Every consumer resolves an id with `find`, which returns the FIRST match: a use
+   * credited to one memory lands on another, an injection is counted against the wrong entry, and `/forget`
+   * deletes a memory the user was not looking at. The whole usage record silently describes the wrong rows.
+   */
+  mintId() {
+    const stamp = this.now();
+    const taken = new Set((this.cache ?? []).map((e) => e.id));
+    let id = `m${stamp}`;
+    for (let n = 2; taken.has(id); n++) id = `m${stamp}-${n}`;
+    return id;
+  }
+  usageFile() {
+    return join3(dirname2(this.file), USAGE_FILE);
+  }
+  /**
+   * Folds the machine-local counts onto the entries, and takes over any the shared file still carries.
+   *
+   * The shared file HAS these fields on every entry written before the sidecar existed. Taking the larger of
+   * the two is what makes the move lossless: the history already recorded stays, and it stops growing there.
+   */
+  async loadUsage(entries) {
+    try {
+      const raw = await readFile2(this.usageFile(), "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") this.usage = parsed;
+    } catch {
+    }
+    for (const e of entries) {
+      const u = this.usage[e.id] ?? {};
+      const injections = Math.max(u.injections ?? 0, e.injections ?? 0);
+      const observed = Math.max(u.observedInjections ?? 0, e.observedInjections ?? 0);
+      if (injections || observed) {
+        this.usage[e.id] = { injections, observedInjections: observed };
+        e.injections = injections;
+        e.observedInjections = observed;
+      }
+    }
+  }
+  /** Adds one name to an existing ignore list, once. Best-effort: an unreadable file is left alone. */
+  async ensureIgnored(file, name) {
+    try {
+      const raw = await readFile2(file, "utf8");
+      if (raw.split("\n").some((l) => l.trim() === name)) return;
+      await writeFile2(file, raw.endsWith("\n") ? `${raw}${name}
+` : `${raw}
+${name}
+`, "utf8");
+    } catch {
+    }
+  }
+  /** Best-effort, like every other save here: a lost count is a weaker heuristic, not a lost memory. */
+  async persistUsage() {
+    if (this.deferred) return;
+    try {
+      const dir = dirname2(this.file);
+      await mkdir(dir, { recursive: true });
+      if (existsSync(join3(dir, ".gitignore"))) await this.ensureIgnored(join3(dir, ".gitignore"), USAGE_FILE);
+      await writeAtomic(this.usageFile(), JSON.stringify(this.usage));
+    } catch {
+    }
+  }
+  async persist() {
+    if (this.deferred) {
+      telemetry().event("memory.deferred", {
+        "hc.memory.pending": this.pending.length,
+        "hc.memory.file": this.file
+      });
+      return;
+    }
+    const dir = dirname2(this.file);
+    await mkdir(dir, { recursive: true });
+    const gi = join3(dir, ".gitignore");
+    if (!existsSync(gi)) {
+      await writeFile2(gi, `# horse-code: local state stays out of git; memory.jsonl + skills are shared
+config.json
+sources.json
+worktrees/
+last-turn.json
+${USAGE_FILE}
+`, "utf8");
+    } else {
+      await this.ensureIgnored(gi, USAGE_FILE);
+    }
+    const ga = join3(dir, ".gitattributes");
+    if (!existsSync(ga)) {
+      await writeFile2(ga, "# Append-only: keep both sides of a merge, then let the dedupe pass reconcile them.\nmemory.jsonl merge=union\n", "utf8");
+    }
+    if (this.cache === void 0) return;
+    await writeAtomic(this.file, this.cache.map(({ injections: _i, observedInjections: _o, ...shared }) => JSON.stringify(shared)).join("\n") + "\n");
+  }
+  /**
+   * Remember a fact (anchors/tags auto-derived). A new fact that supersedes existing same-topic facts
+   * replaces them (returned in `superseded`) so contradictions don't accumulate.
+   */
+  async add(text, kind = "fact", opts = {}) {
+    return this.serialize(async () => {
+      await this.load();
+      const t = text.trim();
+      if (!t) return { ok: false, error: "empty memory" };
+      if (this.cache.some((e) => e.text === t)) return { ok: false, error: "already remembered" };
+      const anchors = deriveAnchors(t);
+      const hashes = hashAnchors(anchors, this.anchorFs);
+      const persistence = opts.persistence ?? (kind === "rule" ? "permanent" : "long");
+      const entry = {
+        id: this.mintId(),
+        text: t,
+        anchors,
+        tags: deriveTags(t, anchors),
+        createdAt: this.now(),
+        uses: 0,
+        kind,
+        persistence,
+        ...persistence === "short" ? { expiresAt: this.now() + SHORT_TTL_MS } : {},
+        ...opts.audience?.length ? { audience: opts.audience } : {},
+        ...opts.learnedBy ? { learnedBy: opts.learnedBy } : {},
+        // Stored only when the writer states them: an absent field means "the defaults for this kind apply",
+        // which is exactly right for a memory the user dictated.
+        ...opts.importance !== void 0 ? { importance: opts.importance } : {},
+        ...opts.confidence !== void 0 ? { confidence: opts.confidence } : {},
+        ...Object.keys(hashes).length ? { anchorHashes: hashes } : {}
+      };
+      const sameKind = (e) => (e.kind ?? "fact") === kind;
+      const superseded = this.cache.filter((e) => sameKind(e) && supersedes(entry, e)).map((e) => e.text);
+      this.cache = this.cache.filter((e) => !(sameKind(e) && supersedes(entry, e)));
+      this.cache.push(entry);
+      if (this.deferred) this.pending.push(entry);
+      await this.persist();
+      return { ok: true, entry, superseded };
+    });
+  }
+  /** Reinforce a memory the model actually cited (bumps its use count → ranks higher on future ties). */
+  async reinforce(id) {
+    return this.serialize(async () => {
+      await this.load();
+      const e = this.cache.find((m) => m.id === id);
+      if (!e) return;
+      e.uses = (e.uses ?? 0) + 1;
+      await this.persist();
+    });
+  }
+  /** Forget the 1-based N-th memory. Returns the removed entry text, or undefined if out of range. */
+  async remove(n) {
+    return this.serialize(async () => {
+      await this.load();
+      if (n < 1 || n > this.cache.length) return void 0;
+      const [removed] = this.cache.splice(n - 1, 1);
+      await this.persist();
+      return removed.text;
+    });
+  }
+};
+
+// src/engine/turn-effect.ts
+import { readFile as readFile3, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+var MAX_SNAPSHOT_BYTES = 512e3;
+var MAX_SNAPSHOT_FILES = 40;
+var TURN_FILE = join4(".horsecode", "last-turn.json");
+var path = (cwd) => join4(stateRoot(cwd), TURN_FILE);
+async function snapshot(cwd, file) {
+  const abs = join4(stateRoot(cwd), file);
+  if (!existsSync2(abs)) return { file, created: true };
+  try {
+    const before = await readFile3(abs, "utf8");
+    if (before.length > MAX_SNAPSHOT_BYTES) return { file, created: false };
+    return { file, before, created: false };
+  } catch {
+    return { file, created: false };
+  }
+}
+async function recordTurn(cwd, effect, now = Date.now()) {
+  const kept = effect.files.slice(0, MAX_SNAPSHOT_FILES);
+  const dropped = effect.files.slice(MAX_SNAPSHOT_FILES).map((f) => f.file);
+  const rec = {
+    version: 1,
+    at: now,
+    ...effect,
+    files: kept,
+    unsnapshotted: [...effect.unsnapshotted, ...dropped]
+  };
+  const p = path(cwd);
+  await mkdir2(dirname3(p), { recursive: true });
+  await writeAtomic(p, `${JSON.stringify(rec, null, 2)}
+`);
+}
+async function lastTurn(cwd) {
+  try {
+    const raw = JSON.parse(await readFile3(path(cwd), "utf8"));
+    return raw?.version === 1 && Array.isArray(raw.files) ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function clearTurn(cwd) {
+  try {
+    await writeAtomic(path(cwd), `${JSON.stringify({ version: 1, at: 0, prompt: "", kind: "none", files: [], unsnapshotted: [] })}
+`);
+  } catch {
+  }
+}
+async function undoTurn(cwd, effect) {
+  const out = { restored: [], removed: [], failed: [] };
+  if (effect?.kind === "branch") {
+    out.refused = `The last turn's work is on the branch \`${effect.branch ?? "?"}\`, not in your working tree. Nothing here was overwritten, so there is nothing to restore \u2014 drop the branch yourself if you want it gone.`;
+    return out;
+  }
+  if (!effect || effect.kind === "none" || !effect.files.length) {
+    out.refused = "There is nothing recorded to undo \u2014 the last turn changed no files in your working tree.";
+    return out;
+  }
+  const { rm: rm3 } = await import("fs/promises");
+  for (const f of effect.files) {
+    const abs = join4(stateRoot(cwd), f.file);
+    try {
+      if (f.created) {
+        await rm3(abs, { force: true });
+        out.removed.push(f.file);
+        continue;
+      }
+      if (f.before === void 0) {
+        out.failed.push({ file: f.file, error: "too large to snapshot \u2014 restore it from git" });
+        continue;
+      }
+      await mkdir2(dirname3(abs), { recursive: true });
+      await writeAtomic(abs, f.before);
+      out.restored.push(f.file);
+    } catch (e) {
+      out.failed.push({ file: f.file, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return out;
+}
+function describeForContext(effect) {
+  if (!effect || effect.kind === "none" || !effect.files.length && !effect.branch) return void 0;
+  if (effect.kind === "branch") {
+    return `Your previous turn produced work on the branch \`${effect.branch}\` for: "${effect.prompt}".`;
+  }
+  const names = effect.files.map((f) => f.file).join(", ");
+  return `Your previous turn wrote ${names} in the user's working tree, for: "${effect.prompt}". The previous contents are recorded, so a request to undo or revert refers to THESE files.`;
+}
+function describeUndo(r) {
+  if (r.refused) return r.refused;
+  const bits = [];
+  if (r.restored.length) bits.push(`**Restored** ${r.restored.map((f) => `\`${f}\``).join(", ")} to the version before the last change.`);
+  if (r.removed.length) bits.push(`**Removed** ${r.removed.map((f) => `\`${f}\``).join(", ")} \u2014 the last turn created ${r.removed.length === 1 ? "it" : "them"}.`);
+  if (r.failed.length) {
+    bits.push(`\u26A0\uFE0F Could not restore ${r.failed.map((f) => `\`${f.file}\` (${f.error})`).join(", ")}.`);
+  }
+  return bits.join("\n\n");
+}
+
+// src/engine/upstream.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { relative as relative3, dirname as dirname4 } from "path";
+
+// src/engine/refiner.ts
+import { z as z5 } from "zod";
+var RefinerSchema = z5.object({
+  refinedPrompt: z5.string().describe("The refined instruction, ALWAYS in English \u2014 translate from the user's language if needed; never output the user's original language here."),
+  /**
+   * The choice that decides what a run COSTS, described where it is made.
+   *
+   * The enum carried no descriptions at all: every definition lived in one dense paragraph of the system
+   * prompt, competing with the rules for refinedPrompt, language and title. Measured live — "canlı db ve loki
+   * kanıtlarını da sorgula ve işle", refined by this same call into "Query live database and Loki logs, and
+   * document the evidence in the test report", was classified `feature`. It then ran constitution and
+   * brainstorm and opened `specs/006-db-loki-evidence` before anyone noticed that producing a test report
+   * needs no specification. The prompt's own words for `verify` describe that request exactly; they were just
+   * nowhere near the field being filled in.
+   */
+  intent: z5.enum(["chat", "feature", "bugfix", "govern", "undo", "verify"]).describe(
+    "What the request PRODUCES, not what it mentions. `verify`: a record of what EXISTING software DID \u2014 running scenarios, querying the database or logs for evidence, writing or extending a test report. Anything whose output is findings rather than changed behaviour is verify, including a follow-up that only adds more evidence to a report already being written. `feature`: new or changed behaviour in the product. `bugfix`: existing behaviour is wrong and must be corrected. `govern`: the output is a governing document (constitution, conventions), no source changes. `undo`: reverse what the previous turn did. `chat`: a question or conversation, nothing to build. A verify request never needs a specification or a plan: if the answer is 'run it and write down what happened', it is verify."
+  ),
+  // The natural language the user wrote in (English name, e.g. "Turkish") → the coach replies in it.
+  language: z5.string().default("English"),
+  // A concise 2-5 word English kebab-case summary → used as the worktree/branch name (e.g. "add-login-page").
+  title: z5.string().default("task")
+});
+async function runRefiner(deps, prompt, history = []) {
+  const resolved = deps.roleRegistry.resolve("refiner");
+  const tools = new ToolRegistry();
+  tools.register(buildSkillTool(deps.skillRegistry));
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools,
+    messages: [...history, { role: "user", content: prompt }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: ".",
+    signal: deps.signal
+  };
+  return runStructuredRole(opts, RefinerSchema);
+}
+function routeIntent(intent) {
+  if (intent === "chat") return "chat";
+  if (intent === "undo") return "undo";
+  if (intent === "verify") return "verify";
+  return intent === "govern" ? "govern" : "pipeline";
+}
+
+// src/engine/compaction.ts
+var estTokens = (s) => Math.ceil(s.length / 4);
+function historyTokens(history) {
+  return history.reduce((a, m) => a + estTokens(m.content), 0);
+}
+var charsOf = (history) => history.reduce((a, m) => a + m.content.length, 0);
+var summaryMsg = (summary) => ({ role: "user", content: `[Summary of the earlier conversation]
+${summary}` });
+var render = (history) => history.map((m) => `${m.role}: ${m.content}`).join("\n\n");
+function cacheValid(cache, history, upTo) {
+  return !!cache && cache.coveredCount > 0 && cache.coveredCount <= upTo && charsOf(history.slice(0, cache.coveredCount)) === cache.coveredChars;
+}
+async function compactHistory(history, opts, cache) {
+  if (history.length <= opts.keepRecent + 1) return { messages: history, cache };
+  if (historyTokens(history) <= opts.maxTokens) return { messages: history, cache };
+  const ancientEnd = history.length - opts.keepRecent;
+  const recent = history.slice(ancientEnd);
+  const base = cacheValid(cache, history, ancientEnd) ? { coveredCount: cache.coveredCount, summary: cache.summary } : { coveredCount: 0, summary: "" };
+  const delta = history.slice(base.coveredCount, ancientEnd);
+  if (base.coveredCount > 0 && historyTokens(delta) < opts.reSummarizeTokens) {
+    return { messages: [summaryMsg(base.summary), ...delta, ...recent], cache };
+  }
+  const conversation = base.summary ? `Existing summary:
+${base.summary}
+
+Additional earlier turns to fold in:
+${render(delta)}` : render(delta);
+  const summary = await opts.summarize(conversation);
+  const next = { coveredCount: ancientEnd, coveredChars: charsOf(history.slice(0, ancientEnd)), summary };
+  return { messages: [summaryMsg(summary), ...recent], cache: next };
+}
+
+// src/engine/coach.ts
+var COMPACT_MAX_TOKENS = 1e5;
+var COMPACT_KEEP_RECENT = 8;
+var COMPACT_RESUMMARIZE_TOKENS = 4e3;
+async function summarizeConversation(deps, conversation) {
+  const model = deps.roleRegistry.peekModel("refiner") || deps.roleRegistry.peekModel("coach");
+  const opts = {
+    provider: deps.provider,
+    model,
+    systemPrompt: "You compress earlier conversation turns into a concise briefing. PRESERVE verbatim-important facts: decisions made, corrections, errors encountered, file paths, names, and the user's stated preferences. Drop pleasantries and filler. Output terse bullet points, no preamble.",
+    tools: new ToolRegistry(),
+    messages: [{ role: "user", content: `Summarize the earlier conversation below:
+
+${conversation}` }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: ".",
+    signal: deps.signal
+    /**
+     * Deliberately no `onSay`.
+     *
+     * This one is not talking to anyone: it compresses earlier turns into a briefing that goes back into the
+     * coach's own context. It has no tools, so it produces exactly one message, and that message IS the
+     * summary — printing it would show the user a condensed replay of the conversation they just had.
+     */
+  };
+  const msg = await runToCompletion(opts);
+  return msg.content;
+}
+async function runCoachChat(deps, prompt, cwd, history = [], language, images) {
+  const { model, fallbacks, systemPrompt, onExhausted, onFallback } = deps.roleRegistry.resolve("coach");
+  const pins = deps.pins?.() ?? [];
+  const pinBlock = pins.length ? `
+
+User pins (always honor these):
+${pins.map((p) => `- ${p}`).join("\n")}` : "";
+  const context = `
+
+Context: this session is powered by the "${model}" model.` + (language ? ` Respond in ${language}.` : "") + ` When it helps, end your reply with a <nextsteps> block: 2-4 short, concrete follow-up actions the user might pick next, one per line prefixed with "- ". Omit the block when there is no useful next step. If the user states a durable BEHAVIORAL RULE about HOW you should work \u2014 language, style, conventions, or an "always/never" directive (e.g. "always answer in Turkish", "keep code comments in English", "always use pnpm") \u2014 emit a <rule> block with 1-3 short rules, one per line prefixed with "- ". Separately, if the user states a durable FACT worth recalling (an endpoint, version, or decision \u2014 e.g. "the API base is X", "we target Node 22"), emit a <remember> block with 1-3 short facts, one per line prefixed with "- ". Never remember transient, trivial, or one-off things. Separately, if the user corrects you, points out a mistake, or an approach fails and is then fixed, emit a <lesson> block: 1-2 short lessons, each stating what went wrong AND the correct approach, one per line prefixed with "- ". Only for genuine corrections or failures \u2014 not routine answers.` + pinBlock;
+  const { messages: compacted, cache } = await compactHistory(
+    history,
+    {
+      maxTokens: COMPACT_MAX_TOKENS,
+      keepRecent: COMPACT_KEEP_RECENT,
+      reSummarizeTokens: COMPACT_RESUMMARIZE_TOKENS,
+      summarize: (conversation) => summarizeConversation(deps, conversation)
+    },
+    deps.compactionState?.value
+  );
+  if (deps.compactionState) deps.compactionState.value = cache;
+  const load = historyTokens(compacted) / COMPACT_MAX_TOKENS;
+  const hints = memoryHints(deps, prompt, { load, role: "coach" });
+  const memoryMsg = hints.message ? [{ role: "user", content: hints.message }] : [];
+  const opts = {
+    provider: deps.provider,
+    model,
+    fallbacks,
+    systemPrompt: systemPrompt + context,
+    onExhausted,
+    onFallback,
+    tools: readOnlyRegistry(deps, { remember: true, mcp: true, gitWrite: true }),
+    remember: deps.rememberFact,
+    messages: [...compacted, ...memoryMsg, { role: "user", content: prompt, ...images?.length ? { images } : {} }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd,
+    signal: deps.signal,
+    inbox: deps.inbox,
+    // "by-the-way" notes typed mid-run are folded into the coach's turn
+    /**
+     * What the coach says while it works, not only its verdict.
+     *
+     * A read-only exploration turn can run for minutes over a dozen tool calls, and until it finished the
+     * screen held a spinner and nothing else — no way to tell a coach reading the right files from one that
+     * is not, and no chance to redirect it before the tokens were spent.
+     */
+    // …but not the final message: the caller renders that as the reply.
+    ...deps.note ? { onSay: (t, final) => {
+      if (!final) deps.note?.(t);
+    } } : {}
+  };
+  const msg = await runToCompletion(opts);
+  reinforceUsed(deps, hints.ids, msg.content, "coach");
+  return msg.content;
+}
+
+// src/engine/next-steps.ts
+function extractListBlock(raw, tag) {
+  const re = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "i");
+  const m = raw.match(re);
+  if (!m || m.index === void 0) return { text: raw.trim(), items: [] };
+  const items = m[1].split("\n").map((l) => l.replace(/^\s*(?:[-*•]|\d+[.)])\s*/, "").trim()).filter(Boolean).slice(0, 6);
+  const text = (raw.slice(0, m.index) + raw.slice(m.index + m[0].length)).trim();
+  return { text, items };
+}
+
+// src/engine/review-notes.ts
+import { appendFileSync, existsSync as existsSync3, writeFileSync } from "fs";
+import { join as join5 } from "path";
+var REVIEW_NOTES_FILE = "review-notes.md";
+var HEADER = "# Deferred review notes\n\nMedium/low findings the review deliberately did not block on. They are carried to the next stage as context (spec \u2192 plan \u2192 tasks) and, for code findings, adjudicated in the PR revision pass. This file is the durable record so nothing is silently lost \u2014 prompt context alone is not a guarantee.\n";
+function appendReviewNotes(featureDir, notes) {
+  if (!notes.length) return false;
+  try {
+    const file = join5(featureDir, REVIEW_NOTES_FILE);
+    if (!existsSync3(file)) writeFileSync(file, HEADER, "utf8");
+    appendFileSync(file, `
+${notes.map((n) => `- ${n}`).join("\n")}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/speckit/phases.ts
+import { existsSync as existsSync4 } from "fs";
+import { relative } from "path";
+var SKIP = "The workspace is already scaffolded \u2014 do NOT run any shell scripts. Use write_file to write the output file exactly at the path given below.";
+var PHASE_MAX_TURNS = 200;
+var BRAINSTORM_COMMAND = "You are the brainstormer. Produce a decided design brief for the request below, then write it to the file named in the message. Explore the repo before proposing anything, ask only questions that change the design, and have the user choose between real alternatives.";
+async function runRole(p, role, command, message, extraTools = false, subject) {
+  const law = p.deps.home ? await constitutionNote({ ...p.deps, home: p.deps.home, note: p.deps.note }, p.workdir, { role, title: subject }) : "";
+  const { role: agentRole, model, fallbacks, onExhausted, onFallback } = p.deps.roleRegistry.fallbackOpts(role);
+  const tools = writerRegistry(p.deps.skillRegistry, [
+    ...extraTools ? [buildAskUserTool(p.askUser, (q) => normalizeQuestion(p.deps, q))] : [],
+    ...contextTools(p.deps),
+    // the spec and the plan are written about a codebase — let them see it
+    // A phase that reads the codebase to write about it is exactly where durable facts are found.
+    buildRememberTool(p.deps.rememberFact)
+  ]);
+  const hints = memoryHints(p.deps, subject ?? message, { role });
+  const routed = routeSkills(subject ?? message, p.deps.skillRegistry, [], { role, placed: placedSkills() });
+  if (routed.length) p.deps.note?.(`\u{1F4CE} \`${role}\` \xB7 ${routed.map((m) => `**${m.name}**`).join(", ")}`);
+  const opts = {
+    provider: p.deps.provider,
+    role: agentRole,
+    model,
+    fallbacks,
+    onExhausted,
+    onFallback,
+    // What a specification or plan may say is constrained by the project's own stack and boundaries.
+    systemPrompt: (routed.length ? applySkills(`${command}
+
+${SKIP}${p.deps.roleRegistry.ruleSuffix()}`, routed.map((m) => m.name), p.deps.skillRegistry) : `${command}
+
+${SKIP}${p.deps.roleRegistry.ruleSuffix()}`) + law + projectToolsNote(tools.list(), !!loadGraphSync(p.workdir)) + BATCH_TOOLS_NOTE + `
+
+${WHAT_IT_COST}` + respondIn(p.language),
+    tools,
+    maxTurns: PHASE_MAX_TURNS,
+    // Project memory (conventions/decisions/lessons) reaches the authoring roles too, not just the coach.
+    /**
+     * A screenshot named in the request comes with it, here as everywhere else.
+     *
+     * Measured from a live run: the request carried the path of a pasted screenshot, no image was attached,
+     * and the analyst did the only thing left to it — `read_file` on a PNG, which cannot read one. The
+     * evidence the user handed over never reached the model that needed it.
+     */
+    messages: (hints.message ? [{ role: "user", content: hints.message }] : []).concat([
+      { role: "user", ...handedOver(message, p.workdir) }
+    ]),
+    permission: p.deps.permission,
+    approve: p.deps.approve,
+    cwd: p.workdir,
+    signal: p.deps.signal,
+    onActivity: p.deps.onActivity,
+    onLiveActivity: p.deps.onLiveActivity,
+    onWrite: (path2) => commitFile(p.deps, p.workdir, path2).then(() => {
+    }),
+    // per-write conventional commit
+    /**
+     * A phase can be interrupted with a correction.
+     *
+     * These are the longest interactive stretches in the tool — writing a constitution, a spec, a plan — and
+     * they were the only ones a mid-run note could not reach. "Actually, keep it to one page" arriving four
+     * minutes in is worth more than the same sentence after the document is finished and reviewed.
+     */
+    inbox: p.deps.inbox,
+    /**
+     * What the role says reaches the user.
+     *
+     * A phase used to show tool cards and an artefact and nothing else. Reported twice in the same shape:
+     * the analyst offered "I'll show you the skeleton first and wait for approval", the user chose it, the
+     * analyst wrote the skeleton — and asked "do you approve the skeleton above?" with nothing above it.
+     * The model did exactly what it promised; the words were thrown away.
+     */
+    ...p.deps.note ? { onSay: p.deps.note } : {}
+  };
+  const said = await runToCompletion(opts);
+  reinforceUsed(p.deps, hints.ids, said.content, role);
+}
+async function runConstitution(p, request) {
+  const rel = relative(p.workdir, constitutionPath(p.workdir));
+  const asked = request?.trim() ? `What the user asked for:
+"${request.trim()}"
+
+` : "";
+  const exists = existsSync4(constitutionPath(p.workdir));
+  const msg = exists ? `${asked}The project already has a constitution at "${rel}". AMEND it: make the smallest change that satisfies the request, in the document's own language and style, and leave everything else exactly as it is. Bump the version and its amendment record the way the document itself prescribes. Do not reshape it to a template, do not re-derive principles it already ratified, and do not ask what to change when the request already says. If the request genuinely cannot be expressed as an amendment, say why in one sentence and stop.` : `${asked}Establish the project constitution. Ask the user about core principles with ask_user if needed.
+Follow this template:
+
+${p.templates.template("constitution")}
+
+Write it to "${rel}".`;
+  await runRole(p, "analyst", p.templates.command("constitution"), msg, true, request);
+}
+async function runBrainstorm(p, paths, prompt) {
+  const rel = relative(p.workdir, paths.brainstorm);
+  const msg = `Request: "${prompt}".
+
+Explore this repository first, then decide the approach WITH the user, then write the decision to "${rel}".`;
+  await runRole(p, "brainstormer", BRAINSTORM_COMMAND, msg, true, prompt);
+}
+function specifyMessage(prompt, specRel, briefRel, hasBrief, template, feedback) {
+  if (feedback?.length) {
+    return `Revise the spec at "${specRel}" with these reviewer notes:
+${feedback.map((f) => `- ${f}`).join("\n")}
+Original request: ${prompt}`;
+  }
+  const source = hasBrief ? `Read "${briefRel}" FIRST \u2014 the approach was already decided with the user there, and the spec must honor it (do not re-litigate the choice or reintroduce a rejected alternative).
+` : `There is no design brief for this work \u2014 none was written, and there is nothing to look for. Work from the request itself and from the code, and decide what the spec needs by reading the repository.
+`;
+  return `Feature request: "${prompt}". ${source}Ask clarifying questions with ask_user only if strictly necessary.
+Follow this template:
+
+${template}
+
+Write the spec to "${specRel}".`;
+}
+async function runSpecify(p, paths, prompt, feedback) {
+  const rel = relative(p.workdir, paths.spec);
+  const brief = relative(p.workdir, paths.brainstorm);
+  const msg = specifyMessage(prompt, rel, brief, existsSync4(paths.brainstorm), p.templates.template("spec"), feedback);
+  await runRole(p, "analyst", p.templates.command("specify"), msg, true, prompt);
+}
+async function runPlan(p, paths, feedback, carryOver) {
+  const rel = relative(p.workdir, paths.plan);
+  const specRel = relative(p.workdir, paths.spec);
+  const cRel = relative(p.workdir, constitutionPath(p.workdir));
+  const carried = carryOver?.length ? `
+
+Known non-blocking notes carried over from the spec review \u2014 address them in the plan where they apply (they are context, not blockers):
+${carryOver.map((c) => `- ${c}`).join("\n")}` : "";
+  const msg = feedback?.length ? `Revise the plan at "${rel}" with these reviewer notes:
+${feedback.map((f) => `- ${f}`).join("\n")}` : `Read the spec "${specRel}" and the constitution "${cRel}" (if present).
+Follow this template:
+
+${p.templates.template("plan")}
+
+Write the plan to "${rel}".${carried}`;
+  await runRole(p, "planner", p.templates.command("plan"), msg);
+}
+function tasksMessage(planRel, tasksRel, template, carryOver = []) {
+  const carried = carryOver.length ? `
+
+Known non-blocking notes carried over from the earlier reviews \u2014 fold them into a task only where they genuinely apply (they are context, not new requirements):
+${carryOver.map((c) => `- ${c}`).join("\n")}` : "";
+  return `Read the plan "${planRel}" and break it into an actionable task list.
+This codebase ALREADY EXISTS. The template below is written for a project being created from scratch, so its Setup and Foundational phases describe work that was done years ago here, and its Polish phase lists things that are not tasks. Take the template's FORMAT \u2014 ids, [P] markers, file paths, phases \u2014 and let the plan decide what is actually in it.
+Every task must leave the repository DIFFERENT \u2014 code, a test, a document. Looking at something is not a task: an implementer reads the code, checks the versions and finds its way around as part of doing the work, so "verify X", "inspect Y", "confirm Z" belong inside the task that needs the answer, not beside it. If the only thing a task would deliver is knowing something, it is not on the list.
+Nor is running a command: linting, formatting, building and typechecking are how a task is known to be FINISHED. Put them in the acceptance criteria of the tasks that changed the code \u2014 the implementer runs them there anyway \u2014 instead of giving each one a task of its own.
+And one file is usually one task. Tasks that write the same file cannot run at the same time, so splitting a single file across several of them buys nothing and pays for a full implement-and-review round each time. Split by what is genuinely independent, not by what is separately describable \u2014 the template's "one entity per task" examples are about creating new files, not changing existing ones.
+Follow this template:
+
+${template}
+
+Write the tasks to "${tasksRel}".${carried}`;
+}
+async function runTasks(p, paths, carryOver) {
+  const rel = relative(p.workdir, paths.tasks);
+  const planRel = relative(p.workdir, paths.plan);
+  const msg = tasksMessage(planRel, rel, p.templates.template("tasks"), carryOver ?? []);
+  await runRole(p, "project-manager", p.templates.command("tasks"), msg);
+}
+
+// src/speckit/clarify.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { relative as relative2 } from "path";
+import { z as z6 } from "zod";
+var ClarifyStepSchema = z6.object({
+  // The single most important clarifying question, or null when the spec is sufficiently clear.
+  nextQuestion: z6.string().nullable()
+});
+async function runClarify(p, paths, maxRounds = 5) {
+  const specRel = relative2(p.workdir, paths.spec);
+  const specText = () => existsSync5(paths.spec) ? readFileSync2(paths.spec, "utf8") : "";
+  const before = specText();
+  const { role: agentRole, model, fallbacks, onExhausted, onFallback } = p.deps.roleRegistry.fallbackOpts("analyst");
+  const qa = [];
+  for (let round = 0; round < maxRounds; round++) {
+    const context = qa.length ? `
+
+Answers so far:
+${qa.join("\n")}` : "";
+    const opts = {
+      provider: p.deps.provider,
+      role: agentRole,
+      model,
+      fallbacks,
+      onExhausted,
+      onFallback,
+      systemPrompt: `${p.templates.command("clarify")}
+
+Ask at most one question per turn.${p.deps.roleRegistry.ruleSuffix()}`,
+      tools: writerRegistry(p.deps.skillRegistry),
+      messages: [{
+        role: "user",
+        content: `Read the spec "${specRel}". Identify the single most important underspecified point and return it as nextQuestion, or null if the spec is clear enough. If you already have an answer below, first update the spec at "${specRel}" (write_file/edit_file) to incorporate it, then decide the next question.${context}`
+      }],
+      permission: p.deps.permission,
+      approve: p.deps.approve,
+      cwd: p.workdir,
+      signal: p.deps.signal,
+      onActivity: p.deps.onActivity
+    };
+    const step = await runStructuredRole(opts, ClarifyStepSchema);
+    if (!step.nextQuestion) break;
+    const structured = extractChoicesFrom(step.nextQuestion);
+    const answer = structured.choices.length >= 2 ? await p.askUser(structured.question, { options: structured.choices }) : await p.askUser(step.nextQuestion);
+    qa.push(`Q: ${step.nextQuestion}
+A: ${answer}`);
+  }
+  if (qa.length > 0 && specText() === before) {
+    const opts = {
+      provider: p.deps.provider,
+      role: agentRole,
+      model,
+      fallbacks,
+      onExhausted,
+      onFallback,
+      systemPrompt: `${p.templates.command("clarify")}${p.deps.roleRegistry.ruleSuffix()}`,
+      tools: writerRegistry(p.deps.skillRegistry),
+      messages: [{
+        role: "user",
+        content: `The clarification answers below were NOT written into the spec. Update "${specRel}" now with write_file/edit_file so every answer is reflected in the requirements \u2014 this is the only step that persists them.
+
+${qa.join("\n\n")}`
+      }],
+      permission: p.deps.permission,
+      approve: p.deps.approve,
+      cwd: p.workdir,
+      signal: p.deps.signal,
+      onActivity: p.deps.onActivity,
+      // Clarify rewrites the spec from the user's own answers; what it says about that is addressed to them.
+      ...p.deps.note ? { onSay: p.deps.note } : {}
+    };
+    await runToCompletion(opts);
+  }
+}
+
+// src/engine/upstream.ts
+var WANTS_WORKTREE = /\bworktree\b/i;
+function gitSync(cwd) {
+  return (args) => {
+    try {
+      return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+      return void 0;
+    }
+  };
+}
+async function documentWorkdir(cwd, prompt, ensureWorktree, nameHint) {
+  if (inLinkedWorktree(cwd, gitSync(cwd)) && !WANTS_WORKTREE.test(prompt)) return cwd;
+  return ensureWorktree(nameHint);
+}
+function laneCheckpoint(cwd, lane, resume, prompt, r) {
+  const root = sessionBase(cwd);
+  if (root === void 0) return;
+  writeCheckpoint(dirname4(root), {
+    rawPrompt: resume?.rawPrompt ?? prompt,
+    refinedPrompt: r.refinedPrompt,
+    title: r.title,
+    language: r.language,
+    featureSlug: resume?.featureSlug ?? "",
+    done: [],
+    lane,
+    intent: r.intent
+  });
+}
+function laneFor(r, prompt, resume) {
+  const intent = routeIntent(r.intent);
+  if (intent !== "chat") return intent;
+  return isContinuePrompt(prompt) && resume?.lane ? resume.lane : intent;
+}
+async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, history = [], emit = () => {
+}, images, resume, hasPreservedWork = false, workingIn) {
+  const PHASE_ROLE = { constitution: "analyst", brainstorm: "brainstormer", specify: "analyst", clarify: "analyst", plan: "planner", tasks: "project-manager" };
+  const emitPhase = (phase) => {
+    const role = PHASE_ROLE[phase];
+    const model = role ? deps.roleRegistry.peekModel(role) : "";
+    emit({ kind: "phase", phase, detail: role ? `${role} \xB7 ${model}` : void 0 });
+  };
+  const priorContext = describeForContext(await lastTurn(process.cwd()));
+  const withPrior = priorContext ? [{ role: "assistant", content: priorContext }, ...history] : history;
+  const r = resume ? { intent: resume.intent ?? "feature", refinedPrompt: resume.refinedPrompt, title: resume.title, language: resume.language } : await runRefiner(deps, prompt, withPrior);
+  emit({ kind: "refined", refinedPrompt: r.refinedPrompt });
+  if (!resume && routeIntent(r.intent) === "chat") {
+    emit({ kind: "phase", phase: "chat" });
+    const raw = await runCoachChat(deps, r.refinedPrompt, ".", withPrior, r.language, images);
+    const ns = extractListBlock(raw, "nextsteps");
+    const ru = extractListBlock(ns.text, "rule");
+    const rm3 = extractListBlock(ru.text, "remember");
+    const ls = extractListBlock(rm3.text, "lesson");
+    return { intent: r.intent, refinedPrompt: r.refinedPrompt, kind: "chat", response: ls.text, nextSteps: ns.items, rules: ru.items, remembered: rm3.items, lessons: ls.items };
+  }
+  if (!resume && routeIntent(r.intent) === "undo") {
+    const cwd = process.cwd();
+    const effect = await lastTurn(cwd);
+    const res = await undoTurn(cwd, effect);
+    if (!res.refused) await clearTurn(cwd);
+    return { intent: r.intent, refinedPrompt: r.refinedPrompt, kind: "undone", report: describeUndo(res) };
+  }
+  if (laneFor(r, prompt, resume) === "verify") {
+    emitPhase("verify");
+    const cwd = await documentWorkdir(process.cwd(), prompt, ensureWorktree, r.title);
+    laneCheckpoint(cwd, "verify", resume, prompt, r);
+    const { runVerify, describeVerify, currentBranchOf } = await import("./verify-WQ3GHION.js");
+    const branch = await currentBranchOf(cwd);
+    const res = await runVerify({
+      deps,
+      workdir: cwd,
+      prompt: r.refinedPrompt,
+      title: r.title,
+      askUser,
+      // The refined prompt is English by design; without this the tester answers a Turkish session in English.
+      language: r.language,
+      note: (text) => emit({ kind: "note", text })
+    });
+    return {
+      intent: r.intent,
+      refinedPrompt: r.refinedPrompt,
+      kind: "verified",
+      report: describeVerify(res, branch, cwd),
+      reportPath: res.reportPath,
+      written: res.reportWritten
+    };
+  }
+  if (laneFor(r, prompt, resume) === "govern") {
+    emitPhase("constitution");
+    const templates2 = await deps.specKit();
+    const cwd = await documentWorkdir(process.cwd(), prompt, ensureWorktree, r.title);
+    laneCheckpoint(cwd, "govern", resume, prompt, r);
+    const p2 = { deps, templates: templates2, workdir: cwd, askUser, ...r.language ? { language: r.language } : {} };
+    const rel = relative3(cwd, constitutionPath(cwd));
+    const before = await snapshot(cwd, rel);
+    await runConstitution(p2, r.refinedPrompt);
+    const path2 = constitutionPath(cwd);
+    const written = existsSync6(path2);
+    if (written) {
+      await recordTurn(cwd, { prompt: r.refinedPrompt, kind: "in-place", files: [before], unsnapshotted: [] });
+    }
+    if (!written) {
+      emit({ kind: "note", text: `\u26A0\uFE0F The constitution phase never wrote \`${relative3(cwd, path2)}\` \u2014 nothing was changed.` });
+    }
+    return { intent: r.intent, refinedPrompt: r.refinedPrompt, kind: "governed", path: path2, written };
+  }
+  if (!resume && !hasPreservedWork && routeIntent(r.intent) === "pipeline") {
+    const cwd = workingIn?.() ?? process.cwd();
+    emitPhase("sizing");
+    const { sizeRequest } = await import("./triage-2J3T5PVQ.js");
+    const size = await sizeRequest(deps, cwd, r.refinedPrompt);
+    let small = size.verdict === "small";
+    if (size.verdict === "unsure") {
+      const { describeSizeDoubt } = await import("./triage-2J3T5PVQ.js");
+      const answer = await askInUserLanguage(
+        deps,
+        askUser,
+        r.language,
+        `${describeSizeDoubt(r.refinedPrompt, size.reason)}
+
+Which is it?`,
+        [
+          { label: "Small \u2014 just do it", description: "Implemented, reviewed and checked against the acceptance criteria, in your working tree." },
+          { label: "Full piece of work", description: "Spec, plan, tasks, then waves \u2014 on its own branch." }
+        ]
+      );
+      small = /^small/i.test(answer.trim());
+    }
+    if (small) {
+      emitPhase("small change");
+      emit({ kind: "note", text: `\u26A1 Small change \u2014 ${size.reason}. No branch, no spec, no plan.` });
+      const { runSmallChange, describeSmallChange } = await import("./fix-HBBOTUWM.js");
+      const { currentBranchOf } = await import("./verify-WQ3GHION.js");
+      const res = await runSmallChange(deps, cwd, r.title, r.refinedPrompt, size);
+      return {
+        intent: r.intent,
+        refinedPrompt: r.refinedPrompt,
+        kind: "tweaked",
+        report: describeSmallChange(res, size.reason, await currentBranchOf(cwd)),
+        done: res.fixed
+      };
+    }
+  }
+  const workdir = await ensureWorktree(r.title);
+  const templates = await deps.specKit();
+  const p = { deps, templates, workdir, askUser, ...r.language ? { language: r.language } : {} };
+  const root = dirname4(workdir);
+  const prior = readCheckpoint(root);
+  const done = new Set(prior?.done ?? []);
+  const slug = prior?.featureSlug ?? nextFeatureSlug(workdir, r.title);
+  const paths = scaffoldFeature(workdir, slug);
+  const specRel = relative3(workdir, paths.spec);
+  const planRel = relative3(workdir, paths.plan);
+  let carryOver = prior?.carryOver ?? [];
+  const rawPrompt = prior?.rawPrompt ?? prompt;
+  const save = () => writeCheckpoint(root, { rawPrompt, refinedPrompt: r.refinedPrompt, title: r.title, language: r.language, intent: r.intent, featureSlug: slug, done: [...done], carryOver });
+  const mark = (phase) => {
+    done.add(phase);
+    save();
+  };
+  if (done.size > 0) emit({ kind: "note", text: `\u23E9 Resuming \u2014 already done: ${[...done].join(", ")}. Continuing from the next phase.` });
+  save();
+  const ensureWritten = async (file, rel, phase, run, optional = false) => {
+    if (existsSync6(file)) return;
+    emit({ kind: "note", text: `\u26A0\uFE0F The ${phase} phase produced no \`${rel}\` \u2014 retrying it once.` });
+    await run();
+    if (existsSync6(file)) return;
+    if (!optional) throw new Error(`${phase} did not produce ${rel} (the role never wrote the file)`);
+    emit({ kind: "note", text: `\u26A0\uFE0F Continuing without \`${rel}\` \u2014 the ${phase} phase never wrote it.` });
+  };
+  if (!done.has("constitution")) {
+    if (!existsSync6(constitutionPath(workdir))) {
+      emitPhase("constitution");
+      await runConstitution(p);
+      await ensureWritten(constitutionPath(workdir), relative3(workdir, constitutionPath(workdir)), "constitution", () => runConstitution(p), true);
+      await commitStep(deps, workdir, "establish the project constitution");
+    }
+    mark("constitution");
+  }
+  if (!done.has("brainstorm") && !existsSync6(paths.spec)) {
+    emitPhase("brainstorm");
+    await ensureWritten(
+      paths.brainstorm,
+      relative3(workdir, paths.brainstorm),
+      "brainstorm",
+      () => runBrainstorm(p, paths, r.refinedPrompt),
+      true
+    );
+    await commitStep(deps, workdir, "record the design decision");
+  }
+  mark("brainstorm");
+  if (!done.has("spec")) {
+    emitPhase("specify");
+    if (existsSync6(paths.spec)) {
+      emit({ kind: "note", text: `\u23E9 \`${specRel}\` already written \u2014 resuming at its review instead of rewriting it.` });
+    } else {
+      await runSpecify(p, paths, r.refinedPrompt);
+      await ensureWritten(paths.spec, specRel, "specify", () => runSpecify(p, paths, r.refinedPrompt));
+    }
+    const specOut = await runReviewLoop(deps, {
+      stage: "spec",
+      workdir,
+      target: specRel,
+      request: r.refinedPrompt,
+      revise: (fb) => runSpecify(p, paths, r.refinedPrompt, fb),
+      askUser,
+      maxRounds,
+      emit,
+      language: r.language
+    });
+    if (!specOut.approved) return { intent: r.intent, refinedPrompt: r.refinedPrompt, kind: "rejected", stage: "spec" };
+    carryOver = [...carryOver, ...specOut.deferred ?? []];
+    save();
+    if (appendReviewNotes(paths.dir, specOut.deferred ?? [])) emit({ kind: "note", text: `\u{1F4DD} ${specOut.deferred.length} deferred spec note(s) recorded in \`${relative3(workdir, paths.dir)}/review-notes.md\`.` });
+    if (!existsSync6(paths.spec)) throw new Error(`specify did not produce a spec: ${specRel}`);
+    await commitStep(deps, workdir, "add the feature specification");
+    mark("spec");
+  }
+  if (!done.has("clarify")) {
+    emitPhase("clarify");
+    await runClarify(p, paths);
+    await commitStep(deps, workdir, "clarify the feature specification");
+    mark("clarify");
+  }
+  if (!done.has("plan")) {
+    emitPhase("plan");
+    if (existsSync6(paths.plan)) {
+      emit({ kind: "note", text: `\u23E9 \`${planRel}\` already written \u2014 resuming at its review instead of rewriting it.` });
+    } else {
+      await runPlan(p, paths, void 0, carryOver);
+      await ensureWritten(paths.plan, planRel, "plan", () => runPlan(p, paths, void 0, carryOver));
+    }
+    const planOut = await runReviewLoop(deps, {
+      stage: "plan",
+      workdir,
+      target: planRel,
+      request: r.refinedPrompt,
+      revise: (fb) => runPlan(p, paths, fb),
+      askUser,
+      maxRounds,
+      emit,
+      language: r.language
+    });
+    if (!planOut.approved) return { intent: r.intent, refinedPrompt: r.refinedPrompt, kind: "rejected", stage: "plan" };
+    carryOver = [...carryOver, ...planOut.deferred ?? []];
+    save();
+    if (appendReviewNotes(paths.dir, planOut.deferred ?? [])) emit({ kind: "note", text: `\u{1F4DD} ${planOut.deferred.length} deferred plan note(s) recorded in \`${relative3(workdir, paths.dir)}/review-notes.md\`.` });
+    if (!existsSync6(paths.plan)) throw new Error(`plan did not produce a plan: ${planRel}`);
+    await commitStep(deps, workdir, "add the implementation plan");
+    mark("plan");
+  }
+  if (!done.has("tasks")) {
+    emitPhase("tasks");
+    await runTasks(p, paths, carryOver);
+    await ensureWritten(paths.tasks, relative3(workdir, paths.tasks), "tasks", () => runTasks(p, paths, carryOver));
+    await commitStep(deps, workdir, "break the plan into tasks");
+    mark("tasks");
+  }
+  return {
+    intent: r.intent,
+    refinedPrompt: r.refinedPrompt,
+    kind: "approved",
+    specPath: specRel,
+    planPath: planRel,
+    tasksPath: relative3(workdir, paths.tasks)
+  };
+}
+
+// src/engine/sync-main.ts
+var SYNC_RESOLVE_ROUNDS = 2;
+async function syncMainBranch(deps, session, opts) {
+  const branch = await resolveMainBranch({
+    cwd: deps.manager.projectRoot,
+    git: opts.git,
+    askUser: opts.askUser,
+    phrase: (t) => inUserLanguage(deps, t, opts.language),
+    ...deps.note ? { note: deps.note } : {}
+  });
+  if (!branch) return { status: "skipped", why: "no main branch is set for this project" };
+  const ref = await deps.manager.fetchBranch(branch);
+  if (await deps.manager.containsRef(session, ref)) return { status: "current", branch };
+  const commits = await deps.manager.commitsBehind(session, ref);
+  let merge;
+  try {
+    merge = await deps.manager.mergeRef(session, ref);
+  } catch (e) {
+    const why = e instanceof Error ? e.message.split("\n")[0] : String(e);
+    deps.note?.(`\u26A0 Could not sync \`${branch}\` into this session (${why}) \u2014 continuing on the branch as it is.`);
+    return { status: "skipped", why };
+  }
+  if (merge.status === "merged") {
+    deps.note?.(`\u{1F504} Synced \`${ref}\` into the session branch \u2014 ${commits} commit(s) brought in.`);
+    return { status: "synced", branch, commits, conflicts: [] };
+  }
+  const { conflicted } = await resolveGeneratedConflicts(deps, session, merge.files);
+  if (!conflicted.length) {
+    await deps.manager.commitMerge(session, `chore: sync ${branch} into session branch`);
+    deps.note?.(`\u{1F504} Synced \`${ref}\` \u2014 ${commits} commit(s); generated files re-derived rather than merged.`);
+    return { status: "synced", branch, commits, conflicts: merge.files };
+  }
+  deps.note?.(`\u{1F500} Syncing \`${ref}\` conflicts in ${conflicted.join(", ")} \u2014 operational resolving\u2026`);
+  for (let round = 0; round < SYNC_RESOLVE_ROUNDS; round++) {
+    const notes = round === 0 ? "" : `
+The last attempt left conflict markers in: ${conflicted.join(", ")}`;
+    await runConflictResolver(deps, session.baseWorktree, conflicted, notes);
+    if (await hasConflictMarkers(session.baseWorktree, conflicted)) continue;
+    await deps.manager.commitMerge(session, `chore: resolve conflicts syncing ${branch} into session branch`);
+    deps.note?.(`\u{1F504} Synced \`${ref}\` \u2014 ${commits} commit(s), ${conflicted.length} conflict(s) resolved.`);
+    return { status: "synced", branch, commits, conflicts: merge.files };
+  }
+  await deps.manager.abortMerge(session);
+  deps.note?.(`\u26A0 Could not merge \`${ref}\` cleanly (${conflicted.join(", ")}) \u2014 the sync was rolled back and the session continues on its own branch. Merge it by hand when you want those changes.`);
+  return { status: "conflicted", branch, files: conflicted };
+}
+
+// src/engine/project-manager.ts
+import { z as z7 } from "zod";
+var taskSchema = z7.object({
+  id: z7.string(),
+  title: z7.string(),
+  deps: z7.array(z7.string()),
+  /**
+   * Acceptance criteria: what must be OBSERVABLY true when this task is done — each one checkable against the
+   * worktree (a file exists and exports X, a command succeeds, a behavior is covered by a test). Without them
+   * "done" is whatever the implementer says it is; with them, completion is verified rather than asserted.
+   */
+  acceptance: z7.array(z7.string()).default([]).describe(
+    'What must be OBSERVABLY true when this task is done \u2014 each one checkable against the worktree (a file exists and exports X, a command succeeds, a behaviour is covered by a test). Without them "done" is whatever the implementer says it is.'
+  ),
+  /**
+   * The files this task is expected to create or modify, repo-relative.
+   *
+   * The task list already names them, and until now they stopped there. Wave planning needs them: two tasks
+   * that write the same file are not independent whichever way their `deps` read, and that is not something
+   * `deps` alone can be trusted to say — a missed dependency does not fail loudly, it surfaces hours later
+   * as a merge conflict.
+   */
+  files: z7.array(z7.string()).default([]).describe(
+    "Repo-relative files this task will CREATE or MODIFY, including its test file. Do not list files it only reads. This decides what may run in parallel: two tasks that write the same file are not independent whatever their `deps` say, and a miss does not fail loudly \u2014 it surfaces hours later as a merge conflict."
+  )
+});
+var TasksSchema = z7.object({ tasks: z7.array(taskSchema) }).superRefine((val, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const t of val.tasks) {
+    if (ids.has(t.id)) ctx.addIssue({ code: "custom", message: `duplicate task id: ${t.id}` });
+    ids.add(t.id);
+  }
+  for (const t of val.tasks) {
+    for (const d of t.deps) {
+      if (!ids.has(d)) {
+        ctx.addIssue({ code: "custom", message: `task ${t.id}: undefined dependency: ${d}` });
+      }
+    }
+  }
+});
+async function runProjectManager(opts) {
+  const { tasks } = await runStructuredRole(opts, TasksSchema);
+  const board = new Board();
+  for (const t of tasks) board.addCard({ id: t.id, title: t.title, deps: t.deps, acceptance: t.acceptance, files: t.files });
+  return board;
+}
+
+// src/engine/task-audit.ts
+import { z as z8 } from "zod";
+var CoverageSchema = z8.object({
+  missing: z8.array(z8.string()).default([]).describe(
+    "Plan requirements that NO task covers. Quote each one from the plan, so it can be found again."
+  ),
+  weak: z8.array(z8.object({ task: z8.string(), issue: z8.string() })).default([]).describe(
+    "Tasks whose acceptance criteria do not actually establish what the task claims to deliver \u2014 the work could be marked done without the requirement being met."
+  )
+});
+var words = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2);
+var CONCRETE = /[/\\]|\.[a-z]{1,4}\b|[a-z][A-Z]|_|\(\)|`|"|\d/;
+var FILLER = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "are",
+  "was",
+  "has",
+  "have",
+  "been",
+  "should",
+  "must",
+  "will",
+  "that",
+  "this",
+  "its",
+  "done",
+  "made",
+  "correctly",
+  "properly",
+  "successfully",
+  "works",
+  "working",
+  "task",
+  "implemented",
+  "implementation",
+  "complete",
+  "completed",
+  "created",
+  "added",
+  "exists",
+  "functional",
+  "built",
+  "written",
+  "wired",
+  "handled",
+  "supported",
+  "ready",
+  "present",
+  "available",
+  "correct"
+]);
+function restatesTitle(title, criterion) {
+  if (CONCRETE.test(criterion)) return false;
+  const t = new Set(words(title));
+  return words(criterion).filter((w) => !t.has(w)).every((w) => FILLER.has(w));
+}
+var INVESTIGATION = /^\s*(verify|inspect|check|confirm|review|investigate|explore|understand|analyz|analys|audit|assess|examine|survey|research|determine|identify|evaluate)\w*\b/i;
+function isInvestigation(title) {
+  return INVESTIGATION.test(title);
+}
+var CHORE = /^\s*(lint|format|prettier|typecheck|type-check|compile|run|validate|execute)\w*\b/i;
+var BUILD_CHORE = /^\s*build\s+(the\s+)?[\w@/.-]+\s+(project|target|app|workspace|bundle|production|package)\b/i;
+function isChore(title) {
+  return CHORE.test(title) || BUILD_CHORE.test(title);
+}
+var MAX_CARDS_PER_FILE = 2;
+function structuralFindings(board) {
+  const out = [];
+  const cards = board.list();
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const c of cards) {
+    const key = c.title.trim().toLowerCase();
+    byTitle.set(key, [...byTitle.get(key) ?? [], c]);
+    if (c.acceptance.length === 0) {
+      out.push({ task: c.id, issue: "has no acceptance criteria \u2014 nothing decides when it is done" });
+    } else {
+      const empty = c.acceptance.filter((a) => restatesTitle(c.title, a));
+      if (empty.length === c.acceptance.length) {
+        out.push({ task: c.id, issue: `every acceptance criterion restates the title ("${c.acceptance[0]}") \u2014 none names a file, export, command or behaviour` });
+      }
+    }
+    if (c.files.length === 0) {
+      out.push({ task: c.id, issue: "names no files \u2014 nothing can tell whether it collides with another task" });
+    }
+    if (isChore(c.title)) {
+      out.push({ task: c.id, issue: `runs a command and changes nothing \u2014 "${c.title.slice(0, 60)}". Linting, formatting and building are how a task is known to be finished: put them in the acceptance criteria of the cards that changed the code, where the implementer already runs them.` });
+    }
+    if (isInvestigation(c.title)) {
+      out.push({ task: c.id, issue: `produces no change \u2014 "${c.title.slice(0, 60)}" delivers an answer, not a difference. Fold the looking into the task that needs the answer, or drop it: an implementer reads the code anyway.` });
+    }
+  }
+  const soleFile = /* @__PURE__ */ new Map();
+  for (const c of cards) {
+    if (c.files.length !== 1) continue;
+    const f = c.files[0];
+    soleFile.set(f, [...soleFile.get(f) ?? [], c]);
+  }
+  for (const [file, group] of soleFile) {
+    if (group.length > MAX_CARDS_PER_FILE) {
+      out.push({ issue: `${group.length} tasks write nothing but the same file (${file}) \u2014 ${group.map((c) => c.id).join(", ")}. Tasks on one file cannot run in parallel, so each is another implementer, code review and acceptance gate in a queue for one coherent change. Make it one task unless they are genuinely independent.` });
+    }
+  }
+  for (const [, group] of byTitle) {
+    if (group.length > 1) {
+      out.push({ issue: `${group.map((c) => c.id).join(" and ")} have the same title ("${group[0].title}") \u2014 one of them is a duplicate, or they are not really separate tasks` });
+    }
+  }
+  return out;
+}
+async function auditBreakdown(opts, board, planText) {
+  const findings = structuralFindings(board);
+  if (findings.length > 0 || !opts) return { findings, asked: false };
+  const cards = board.list().map((c) => `- ${c.id}: "${c.title}"
+  writes: ${c.files.join(", ") || "(none)"}
+  done when: ${c.acceptance.join("; ")}`).join("\n");
+  const msg = {
+    role: "user",
+    content: `The plan:
+
+${planText}
+
+The tasks it was broken into:
+${cards}
+
+Two questions, and only these:
+1. missing \u2014 is there anything the plan REQUIRES that no task delivers? Quote the plan. Do not list work the plan does not ask for, however sensible it would be.
+2. weak \u2014 is there a task whose acceptance criteria would still be satisfied by an implementation that does not do what the task says?
+
+Both lists are usually empty on a good breakdown. Return {missing, weak} via submit.`
+  };
+  try {
+    const out = await runStructuredRole({ ...opts, messages: [...opts.messages, msg] }, CoverageSchema);
+    return {
+      asked: true,
+      findings: [
+        ...out.missing.map((m) => ({ issue: `the plan requires this and no task delivers it: ${m}` })),
+        ...out.weak.filter((w) => board.get(w.task)).map((w) => ({ task: w.task, issue: w.issue }))
+      ]
+    };
+  } catch (e) {
+    if (opts.signal.aborted) throw e;
+    return { findings: [], asked: false };
+  }
+}
+function repairRequest(findings) {
+  return `The task breakdown was audited before implementation and these problems were found:
+` + findings.map((f) => `- ${f.task ? `${f.task}: ` : ""}${f.issue}`).join("\n") + `
+
+Produce the whole breakdown again with these fixed. Keep every task that was fine, with its id, unchanged \u2014 this is a repair, not a rewrite.`;
+}
+
+// src/engine/progress.ts
+function snapshotBoard(board) {
+  return board.list().map((c) => ({ id: c.id, title: c.title, column: c.column, model: c.model, role: c.role }));
+}
+
+// src/engine/memory-consolidate.ts
+import { z as z9 } from "zod";
+var MAX_LEARNED = 5;
+var MAX_EVIDENCE_CHARS = 6e3;
+var MAX_EXISTING_SHOWN = 40;
+var EXTRACTED_CONFIDENCE = 0.75;
+var LearnedSchema = z9.object({
+  memories: z9.array(z9.object({
+    text: z9.string(),
+    kind: z9.enum(["fact", "lesson"]),
+    audience: z9.array(z9.string()).optional().describe(
+      "Roles this is FOR, if it is genuinely role-specific. Omit it for anything the whole project should know \u2014 a narrow audience on a general fact hides it from everyone else."
+    ),
+    importance: z9.number().min(0).max(1).optional().describe(
+      "0 to 1. Around 0.9 for something that would cause real damage if forgotten (a hard project rule, a trap that has already cost a run); around 0.5 for a useful convention; below 0.3 for detail that is cheap to rediscover. This orders what survives when the store is trimmed."
+    )
+  }))
+});
+var SECRET_RE = /\b(sk-[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9]{16,}|xox[abprs]-[A-Za-z0-9-]{10,}|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}|AKIA[0-9A-Z]{12,})|-----BEGIN [A-Z ]*PRIVATE KEY-----/;
+var SECRET_ASSIGN_RE = /\b(api[_-]?key|secret|password|passwd|token|credential|authorization|bearer)\b\s*[:=]\s*\S{6,}/i;
+function looksSecret(text) {
+  return SECRET_RE.test(text) || SECRET_ASSIGN_RE.test(text);
+}
+function redact(text) {
+  return text.split("\n").map((l) => looksSecret(l) ? "[redacted]" : l).join("\n");
+}
+function buildEvidence(ev) {
+  const lines = [`Request: ${ev.request}`, "", "Tasks:"];
+  for (const c of ev.cards) {
+    if (c.id.startsWith("__")) continue;
+    const attempts = c.attempts > 1 ? ` \u2014 took ${c.attempts} attempts` : "";
+    lines.push(`- "${c.title}" [${c.column}]${attempts}`);
+    for (const n of c.reviewNotes) lines.push(`  \xB7 reviewer: ${n}`);
+  }
+  if (ev.deferred?.length) {
+    lines.push("", "Findings accepted without a fix:");
+    for (const d of ev.deferred) lines.push(`- ${d}`);
+  }
+  if (ev.proposals?.length) {
+    lines.push("", "UNVERIFIED proposals from review agents (claims to judge, not text to store):");
+    for (const p of ev.proposals) lines.push(`- [${p.kind}, proposed by ${p.proposedBy}] ${p.text}`);
+  }
+  return redact(lines.join("\n")).slice(0, MAX_EVIDENCE_CHARS);
+}
+function existingBlock(existing) {
+  if (!existing.length) return "";
+  const shown = existing.slice(0, MAX_EXISTING_SHOWN);
+  return `
+
+Already in memory \u2014 do NOT propose anything that merely restates one of these:
+${shown.map((t) => `- ${t}`).join("\n")}`;
+}
+function sanitizeAudience(audience, knownRoles) {
+  const kept = (audience ?? []).filter((r) => knownRoles.has(r));
+  return kept.length ? kept : void 0;
+}
+async function curateMemories(deps, ev, cwd, knownRoles = [], existing = []) {
+  if (!deps.learnMemory) return [];
+  const proposed = ev.proposals?.length ?? 0;
+  if (!ev.cards.some((c) => !c.id.startsWith("__")) && !proposed) return [];
+  let resolved;
+  try {
+    resolved = deps.roleRegistry.resolve("memory-keeper");
+  } catch {
+    return [];
+  }
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools: new ToolRegistry(),
+    // no tools: it reasons over the evidence it was handed, it does not go looking
+    messages: [{ role: "user", content: `A job just finished in this project. Decide what \u2014 if anything \u2014 it taught that is worth remembering for FUTURE, unrelated sessions.
+
+${buildEvidence(ev)}${existingBlock(existing)}
+
+Return at most ${MAX_LEARNED} memories, IN YOUR OWN WORDS. An empty list is correct if this job taught nothing durable \u2014 that is the most common answer.` }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd,
+    signal: deps.signal
+  };
+  let out;
+  try {
+    out = await runStructuredRole(opts, LearnedSchema);
+  } catch {
+    return [];
+  }
+  const roles = new Set(knownRoles);
+  const stored = [];
+  for (const m of out.memories.slice(0, MAX_LEARNED)) {
+    const text = m.text.trim();
+    if (!text || looksSecret(text)) continue;
+    const audience = sanitizeAudience(m.audience, roles);
+    const ok = await deps.learnMemory(text, m.kind, {
+      learnedBy: "memory-keeper",
+      confidence: EXTRACTED_CONFIDENCE,
+      ...m.importance !== void 0 ? { importance: m.importance } : {},
+      ...audience ? { audience } : {}
+    });
+    if (ok) stored.push(text);
+  }
+  if (stored.length || proposed) deps.onMemory?.({ kind: "curated", proposed, stored });
+  return stored;
+}
+
+// src/board/persist.ts
+import { mkdir as mkdir3, readFile as readFile4 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var writers = /* @__PURE__ */ new Map();
+function saveBoard(board, path2) {
+  const w = writers.get(path2) ?? { chain: Promise.resolve(), queued: false };
+  writers.set(path2, w);
+  w.next = board;
+  if (w.queued) return w.chain;
+  w.queued = true;
+  w.chain = w.chain.then(async () => {
+    w.queued = false;
+    await mkdir3(dirname5(path2), { recursive: true });
+    await writeAtomic(path2, JSON.stringify(w.next.toJSON(), null, 2));
+  });
+  return w.chain;
+}
+function flushBoard(path2) {
+  return writers.get(path2)?.chain ?? Promise.resolve();
+}
+async function loadBoard(path2) {
+  const raw = await readFile4(path2, "utf8");
+  return Board.fromJSON(JSON.parse(raw));
+}
+
+// src/engine/job.ts
+import { existsSync as existsSync7 } from "fs";
+import { rm as rm2, readFile as readFile5 } from "fs/promises";
+import { dirname as dirname6, join as join6 } from "path";
+function moveNote(card, to, actor) {
+  const who = actor ?? card.role;
+  const title = `**${card.title}**`;
+  if (to === "IN-PROGRESS") return `\u{1F916} ${who ? `\`${who}\` picked up ${title}` : `${title} \u2192 in progress`}`;
+  if (to === "REVIEW") return `\u{1F50D} ${title} \u2014 ${who ? `\`${who}\` handed it to review` : "in review"}`;
+  if (to === "DONE") return `\u2705 ${who ? `\`${who}\` finished ${title}` : `${title} \u2014 reviewed`}`;
+  if (to === "MERGED") return `\u{1F6A2} ${title} \u2014 merged into the base branch`;
+  if (to === "ABANDONED") return `\u{1F6D1} ${title} \u2014 nothing left that could change it`;
+  if (to === "PARKED") return `\u23F8 ${title} \u2014 parked; it will be retried when the ground moves`;
+  return `\u21A9\uFE0E ${title} \u2014 sent back for rework`;
+}
+function pmOpts(deps, workdir, tasksPath) {
+  const resolved = deps.roleRegistry.resolve("project-manager");
+  const hints = memoryHints(deps, `task breakdown ${tasksPath}`, { role: "project-manager" });
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools: readOnlyRegistry(deps, { remember: true }),
+    messages: [...hints.message ? [{ role: "user", content: hints.message }] : [], { role: "user", content: `Read the "${tasksPath}" task list and turn it into board tasks (id, title, deps, acceptance, files).
+
+For EACH task also write its \`acceptance\` \u2014 2-4 concrete statements that will be OBSERVABLY true when the task is done, each checkable by reading the worktree: a named file exists and exports/contains X, a specific behavior is covered by a test, a config key is set. They are the completion gate: a task is only marked done when these are verified. Write conditions, not restatements of the title \u2014 "src/models/todo.ts defines a Todo type with id, title, done" is a criterion; "the model is implemented" is not.
+
+Also give each task its \`files\` \u2014 the repo-relative paths it will create or modify, taken from the task list (which already names them). List every file the task writes, including its test file. This decides what may run in parallel: two tasks that write the same file are not independent, and being wrong about that costs a merge conflict hours later rather than an error now. Do not list files a task only READS.` }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal
+  };
+  return { opts, ids: hints.ids };
+}
+function boardText(b) {
+  return b.list().map((c) => `${c.title} ${c.acceptance.join(" ")} ${c.files.join(" ")}`).join("\n");
+}
+var MAX_PLAN_CHARS = 24e3;
+var AUDIT_MAX_TURNS = 8;
+function auditOpts(deps, workdir) {
+  let resolved;
+  try {
+    resolved = deps.roleRegistry.resolve("task-auditor");
+  } catch {
+    return void 0;
+  }
+  return {
+    provider: deps.provider,
+    ...resolved,
+    tools: readOnlyRegistry(deps),
+    messages: [],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal,
+    // It may want to open a file the plan names; it has no business exploring for fifty turns. A gate that
+    // costs more than the work it guards is not a gate.
+    maxTurns: AUDIT_MAX_TURNS
+  };
+}
+async function gateBreakdown(deps, workdir, tasksPath, planPath, emit) {
+  const pm = pmOpts(deps, workdir, tasksPath);
+  let board = await runProjectManager(pm.opts);
+  reinforceUsed(deps, pm.ids, boardText(board), "project-manager");
+  let planText = "";
+  try {
+    planText = (await readFile5(join6(workdir, planPath), "utf8")).slice(0, MAX_PLAN_CHARS);
+  } catch {
+  }
+  const audit = await auditBreakdown(auditOpts(deps, workdir), board, planText);
+  if (audit.findings.length === 0) return board;
+  emit({ kind: "note", text: `\u{1F9FE} The task breakdown has ${audit.findings.length} problem(s) \u2014 sending it back before any of it is built:
+` + audit.findings.map((f) => `  \xB7 ${f.task ? `${f.task}: ` : ""}${f.issue}`).join("\n") });
+  try {
+    const repair = pmOpts(deps, workdir, tasksPath);
+    board = await runProjectManager({ ...repair.opts, messages: [...repair.opts.messages, { role: "user", content: repairRequest(audit.findings) }] });
+    reinforceUsed(deps, repair.ids, boardText(board), "project-manager");
+  } catch (e) {
+    if (deps.signal.aborted) throw e;
+    emit({ kind: "note", text: `\u26A0\uFE0F The repaired breakdown did not come back \u2014 continuing with the original.` });
+    return board;
+  }
+  const left = await auditBreakdown(auditOpts(deps, workdir), board, planText);
+  if (left.findings.length) {
+    emit({ kind: "note", text: `\u{1F9FE} ${left.findings.length} of those are still open after the repair \u2014 continuing anyway.` });
+  }
+  return board;
+}
+async function curate(deps, request, cards, deferred, cwd) {
+  try {
+    const proposals = deps.proposals?.drain() ?? [];
+    if (proposals.length === 0 && cards.length === 0) return;
+    await curateMemories(
+      deps,
+      { request, cards, ...deferred.length ? { deferred } : {}, ...proposals.length ? { proposals } : {} },
+      cwd,
+      [
+        ...deps.roleRegistry.names(),
+        ...deps.council.map((c) => c.name),
+        ...["spec", "plan", "code"].flatMap((s) => deps.teams[s].map((c) => c.name))
+      ],
+      (deps.memory?.() ?? []).map((m) => m.text)
+    );
+  } catch {
+  }
+}
+async function runCoachReport(deps, session, board) {
+  const resolved = deps.roleRegistry.resolve("coach");
+  const summary = board.list().map((c) => `- ${c.id} "${c.title}" [${c.column}]: ${c.stageHistory.map((s) => s.action).join(", ")}`).join("\n");
+  const opts = {
+    provider: deps.provider,
+    ...resolved,
+    tools: readOnlyRegistry(deps),
+    messages: [{ role: "user", content: `Work complete. Board state:
+${summary}
+Give the user a short final report (what happened in each task).` }],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: session.baseWorktree,
+    signal: deps.signal,
+    // The report itself is returned and rendered by the caller; only the working-out is noted.
+    ...deps.note ? { onSay: (t, final) => {
+      if (!final) deps.note?.(t);
+    } } : {}
+  };
+  const msg = await runToCompletion(opts);
+  return stripThinking(msg.content);
+}
+async function runJob(deps, opts) {
+  const onEvent = opts.onEvent;
+  const emit = onEvent ? (ev) => {
+    try {
+      onEvent(ev);
+    } catch {
+    }
+  } : () => {
+  };
+  let session;
+  const adopt = (s) => {
+    session = s;
+    deps.onSession?.(s.baseWorktree);
+    deps.onSessionOpened?.(s);
+    return s;
+  };
+  const workingIn = () => {
+    if (session) return session.baseWorktree;
+    if (opts.continueIn && existsSync7(opts.continueIn.baseWorktree)) {
+      adopt(opts.continueIn);
+      emit({ kind: "note", text: `\u21AA\uFE0F Continuing in \`${opts.continueIn.baseBranch}\` \u2014 the work from this session so far is already there.` });
+      return opts.continueIn.baseWorktree;
+    }
+    return void 0;
+  };
+  const ensureWorktree = async (nameHint) => {
+    workingIn();
+    if (!session) {
+      emit({ kind: "phase", phase: "worktree" });
+      const opened = adopt(await deps.manager.findResumable(opts.resumeKey ?? opts.prompt) ?? await deps.manager.openSession(opts.fromBranch, nameHint || opts.jobName));
+      const revised = opts.resumeKey !== void 0 && opts.resumeKey !== opts.prompt;
+      if (opened.resumed && revised) {
+        clearCheckpoint(opened.root);
+        emit({ kind: "note", text: `\u23E9 Keeping the work at \`${opened.baseWorktree}\` \u2014 the request changed, so the plan is re-derived.` });
+      } else if (opened.resumed) {
+        emit({ kind: "note", text: `\u23E9 Resuming earlier work at \`${opened.baseWorktree}\` \u2014 completed phases are skipped.` });
+      }
+      const carried = opened.inherited ? describeInherited(opened.inherited) : void 0;
+      if (carried) emit({ kind: "note", text: carried });
+      const topped = describeTopUp(opened.toppedUp ?? []);
+      if (topped) emit({ kind: "note", text: topped });
+    }
+    return session.baseWorktree;
+  };
+  let resume;
+  if (isContinuePrompt(opts.prompt)) {
+    const resumable = await deps.manager.findResumable(opts.prompt);
+    const cp = resumable ? readCheckpoint(resumable.root) : null;
+    if (resumable && cp) {
+      const at = cp.done.length ? `already done: ${cp.done.join(", ")}` : "nothing finished yet";
+      adopt(resumable);
+      resume = cp;
+      emit({ kind: "note", text: `\u23E9 Resuming "${cp.title}" at \`${resumable.baseWorktree}\` \u2014 ${at}.` });
+      await syncMainBranch(
+        { ...deps, note: (text) => emit({ kind: "note", text }) },
+        resumable,
+        { git: defaultGitRunner, askUser: opts.askUser, language: cp.language }
+      ).catch((e) => {
+        emit({ kind: "note", text: `\u26A0 Branch sync skipped (${e instanceof Error ? e.message : String(e)}).` });
+      });
+    } else {
+      return { kind: "chat", response: "There is no preserved work to continue \u2014 no resumable worktree with a checkpoint was found in this project. Tell me what to work on and I'll start it, or re-send the original request to pick it up." };
+    }
+  }
+  deps.onProgress = emit;
+  try {
+    emit({ kind: "phase", phase: "upstream" });
+    const preserved = resume ? true : !!await deps.manager.findResumable(opts.prompt).catch(() => null);
+    const up = await runUpstream(deps, ensureWorktree, opts.prompt, opts.askUser, opts.maxRounds, opts.history, emit, opts.images, resume, preserved, workingIn);
+    if (up.kind === "chat") {
+      return { kind: "chat", response: up.response, refinedPrompt: up.refinedPrompt, nextSteps: up.nextSteps, rules: up.rules, remembered: up.remembered, lessons: up.lessons };
+    }
+    if (up.kind === "governed") {
+      return { kind: "governed", path: up.path, written: up.written, refinedPrompt: up.refinedPrompt };
+    }
+    if (up.kind === "undone") return { kind: "undone", report: up.report, refinedPrompt: up.refinedPrompt };
+    if (up.kind === "tweaked") {
+      return { kind: "tweaked", report: up.report, done: up.done, refinedPrompt: up.refinedPrompt };
+    }
+    if (up.kind === "verified") {
+      return { kind: "verified", report: up.report, reportPath: up.reportPath, written: up.written, refinedPrompt: up.refinedPrompt };
+    }
+    if (up.kind === "rejected") {
+      emit({ kind: "phase", phase: "rejected", detail: up.stage });
+      if (session) {
+        clearCheckpoint(session.root);
+        const dir = await deps.manager.preserveSession(session, `hc: rejected ${up.stage} draft`);
+        emit({ kind: "note", text: `\u{1F4C4} The rejected ${up.stage} draft is kept at \`${dir}\` (branch \`${session.baseBranch}\`) \u2014 inspect the files there.` });
+      }
+      return { kind: "rejected", stage: up.stage, refinedPrompt: up.refinedPrompt };
+    }
+    if (!session) throw new Error("runJob: approved without an open worktree");
+    const workdir = session.baseWorktree;
+    emit({ kind: "phase", phase: "approved" });
+    await deps.manager.commitMerge(session, "hc: spec + plan");
+    emit({ kind: "phase", phase: "board" });
+    const boardPath = join6(session.root, "board.json");
+    let board;
+    if (existsSync7(boardPath)) {
+      board = await loadBoard(boardPath);
+      const interrupted = board.list().filter((c) => c.id !== REVISION_CARD && (c.column === "IN-PROGRESS" || c.column === "REVIEW"));
+      for (const c of interrupted) board.reopen(c.id);
+      const neverTried = board.list().filter((c) => c.id !== REVISION_CARD && c.column === "ABANDONED" && (c.attempts ?? 0) === 0);
+      const rev = board.get(REVISION_CARD);
+      if (rev && rev.column !== "TODO") board.move(REVISION_CARD, "TODO", "team-lead");
+      for (const c of neverTried) board.reopen(c.id);
+      const done = board.list().filter((c) => c.column === "MERGED").length;
+      emit({ kind: "note", text: `\u23E9 Resuming the board \u2014 ${done}/${board.list().length} task(s) already done.` + (interrupted.length ? ` ${interrupted.length} was interrupted mid-flight and goes back in the queue.` : "") + (neverTried.length ? ` ${neverTried.length} was blocked behind a failure and never tried \u2014 back in the queue too.` : "") });
+    } else {
+      board = await gateBreakdown(deps, workdir, up.tasksPath, up.planPath, emit);
+      await saveBoard(board, boardPath);
+    }
+    emit({ kind: "board", cards: snapshotBoard(board) });
+    board.onChange = () => {
+      emit({ kind: "board", cards: snapshotBoard(board) });
+      void saveBoard(board, boardPath).catch(() => {
+      });
+    };
+    board.onMove = (card, _from, to, actor) => emit({ kind: "note", text: moveNote(card, to, actor) });
+    emit({ kind: "phase", phase: "waves" });
+    const wave = await runWaves(deps, session, board, { base: opts.fromBranch, prTitle: opts.prTitle, request: opts.prompt });
+    emit({ kind: "phase", phase: "waves-done", detail: wave.status });
+    let revision;
+    let deferredAll = [];
+    const reviewable = board.list().some((c) => c.column === "MERGED");
+    if (reviewable) {
+      emit({ kind: "phase", phase: "pr", detail: wave.pr?.url ?? wave.delivery.branch });
+      const prDiff = await deps.manager.diff(session, opts.fromBranch);
+      const deferred = board.list().flatMap((c) => c.stageHistory.filter((h) => h.action === "deferred").map((h) => h.note ?? "").filter(Boolean));
+      deferredAll = deferred;
+      if (deferred.length) {
+        appendReviewNotes(join6(workdir, dirname6(up.specPath)), deferred);
+        emit({ kind: "note", text: `\u{1F4DD} ${deferred.length} deferred code note(s) handed to the PR revision pass (and recorded in review-notes.md).` });
+      }
+      emit({ kind: "phase", phase: "revision" });
+      try {
+        revision = await runRevision(
+          deps,
+          session,
+          board,
+          (c, outcome) => deps.prAdapter.postComments(c, outcome),
+          opts.askUser,
+          opts.revisionRounds ?? 3,
+          prDiff,
+          deferred,
+          () => deps.prAdapter.resolveOwnThreads(),
+          (threadId, body) => deps.prAdapter.replyAndResolve(threadId, body)
+        );
+        emit({ kind: "phase", phase: "revision-done", detail: revision.status });
+        closeRevision(board, revision);
+      } catch (e) {
+        if (deps.signal.aborted) throw e;
+        emit({ kind: "note", text: `\u26A0\uFE0F The PR revision pass could not run (${e instanceof Error ? e.message : String(e)}). The merged work is unaffected \u2014 it is delivered below, and the deferred notes are in review-notes.md.` });
+        closeRevision(board, void 0, e instanceof Error ? e.message : String(e));
+      }
+    }
+    if (!wave.pr && reviewable) {
+      const landed = await deps.manager.deliverLocally(session, opts.fromBranch);
+      if (landed.ok) {
+        wave.delivery.mergedInto = opts.fromBranch;
+        emit({ kind: "note", text: `\u{1F4E6} Merged into \`${opts.fromBranch}\` \u2014 the files are in your working copy.` });
+      } else {
+        wave.delivery.notMerged = landed.why;
+        emit({ kind: "note", text: `\u{1F4E6} Not merged (${landed.why}) \u2014 the work is on \`${wave.delivery.branch}\`.` });
+      }
+    }
+    await curate(deps, up.refinedPrompt ?? opts.prompt, board.list(), deferredAll, session.baseWorktree);
+    emit({ kind: "phase", phase: "report" });
+    const report = await runCoachReport(deps, session, board);
+    await flushBoard(boardPath);
+    const unfinished = board.list().filter((c) => c.id !== REVISION_CARD && c.column !== "MERGED");
+    if (!unfinished.length) {
+      clearCheckpoint(session.root);
+      await rm2(join6(session.root, "board.json"), { force: true }).catch(() => {
+      });
+    } else {
+      emit({ kind: "note", text: `\u23F8 ${unfinished.length} task(s) were not finished. The board is kept \u2014 say **continue** to pick them up without redoing the ${board.list().length - unfinished.length} that are done.` });
+    }
+    emit({ kind: "phase", phase: "done" });
+    await recordTurn(process.cwd(), {
+      prompt: up.refinedPrompt,
+      kind: "branch",
+      files: [],
+      unsnapshotted: [],
+      branch: wave.delivery.branch
+    }).catch(() => {
+    });
+    return { kind: "done", wave, revision, report, session, refinedPrompt: up.refinedPrompt };
+  } catch (e) {
+    if (session) emit({ kind: "note", text: `\u{1F4C4} Work so far is kept at \`${session.baseWorktree}\` (branch \`${session.baseBranch}\`). Re-run the same request to resume from where it stopped.` });
+    if (session) await curate(deps, opts.prompt, [], [], session.baseWorktree);
+    throw e;
+  } finally {
+    deps.onSession?.(void 0);
+  }
+}
+
+// src/tui/restore-terminal.ts
+import { spawnSync } from "child_process";
+import { openSync, closeSync } from "fs";
+var RESET_SEQUENCE = "\x1B[?2004l\x1B[<u\x1B[?1049l\x1B[?25h";
+function sttySane() {
+  if (process.platform === "win32") return;
+  let fd;
+  try {
+    fd = openSync("/dev/tty", "r+");
+    spawnSync("stty", ["sane"], { stdio: [fd, "ignore", "ignore"] });
+  } catch {
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function restoreTerminal(h) {
+  try {
+    if (h.stdin.isTTY && typeof h.stdin.setRawMode === "function") h.stdin.setRawMode(false);
+  } catch {
+  }
+  try {
+    h.write(RESET_SEQUENCE);
+  } catch {
+  }
+  try {
+    h.sane?.();
+  } catch {
+  }
+}
+function restoreOnExit(h, proc = process, onInterrupt) {
+  const onExit = () => restoreTerminal(h);
+  const handlers = /* @__PURE__ */ new Map();
+  const install = (sig, negotiable) => {
+    const fn = () => {
+      if (negotiable && onInterrupt?.()) {
+        proc.once(sig, handlers.get(sig));
+        return;
+      }
+      restoreTerminal(h);
+      proc.kill(proc.pid, sig);
+    };
+    handlers.set(sig, fn);
+    proc.once(sig, fn);
+  };
+  install("SIGINT", true);
+  install("SIGTERM", false);
+  install("SIGHUP", false);
+  proc.once("exit", onExit);
+  return () => {
+    proc.removeListener("exit", onExit);
+    for (const [sig, fn] of handlers) proc.removeListener(sig, fn);
+  };
+}
+
+export {
+  isAnthropicModel,
+  isUnknownModelError,
+  OmniRouteProvider,
+  defaultCmdRunner,
+  detectPlatform,
+  makePRAdapter,
+  autonomousAskHuman,
+  Timings,
+  MAX_PARALLEL_TASKS,
+  makeAskUser,
+  makeApprove,
+  nodeLineReader,
+  MemoryStore,
+  runJob,
+  sttySane,
+  restoreTerminal,
+  restoreOnExit
+};