@hizliemre/horse-code 0.1.1 → 0.2.0

package/dist/{chunk-2DGO2BUB.js → chunk-23CLQ2KO.js}

@@ -1,15 +1,12 @@
 import {
-  buildAskUserTool,
-  extractChoicesFrom,
-  normalizeQuestion,
-  respondIn,
-  writerRegistry
-} from "./chunk-F2IALVBU.js";
+  respondIn
+} from "./chunk-M2RKCIGV.js";
 import {
   Board,
   LONG_CALL_MS,
   WHAT_IT_COST,
   applySkills,
+  buildAskUserTool,
   buildRememberTool,
   buildSkillTool,
   changedByMerge,
@@ -21,8 +18,10 @@ import {
   describeInherited,
   describeTopUp,
   editFileTool,
+  extractChoicesFrom,
   hasWorkAgainst,
   nextFeatureSlug,
+  normalizeQuestion,
   placedSkills,
   readOnlyRegistry,
   refreshAfterChange,
@@ -34,25 +33,27 @@ import {
   runReviewer,
   scaffoldFeature,
   squashTask,
+  subjectOf,
   worktreeState,
-  writeFileTool
-} from "./chunk-3XVZXTB6.js";
+  writeFileTool,
+  writerRegistry
+} from "./chunk-7JMWPTJ5.js";
 import {
   resolveMainBranch
 } from "./chunk-QF4MP6BS.js";
 import {
   askInUserLanguage,
   inUserLanguage
-} from "./chunk-HBSC2HT2.js";
+} from "./chunk-UGESK765.js";
 import {
   clearCheckpoint,
   isContinuePrompt,
   readCheckpoint,
   writeCheckpoint
-} from "./chunk-FGVJFMK5.js";
+} from "./chunk-ZSQ24YDJ.js";
 import {
   defaultGitRunner
-} from "./chunk-IW2KBAVZ.js";
+} from "./chunk-LPQU436C.js";
 import {
   BATCH_TOOLS_NOTE,
   SHORT_TTL_MS,
@@ -71,533 +72,32 @@ import {
   relationStrength,
   supersedes,
   verifyAnchors
-} from "./chunk-TOPZL5SU.js";
+} from "./chunk-LLL7QWXB.js";
 import {
   ToolRegistry,
   handedOver,
   runStructuredRole,
   runToCompletion,
-  sanitizeForJson,
   stripThinking,
   telemetry
-} from "./chunk-YILDXPSI.js";
+} from "./chunk-AE36LLL2.js";
 import {
   TRACE_INDEX,
   mergeTraceIndexes,
   parseTraceIndex,
   serializeTraceIndex,
   traceRootRel
-} from "./chunk-FFYBY2NA.js";
+} from "./chunk-KAGKX2YT.js";
 import {
   loadGraphSync
-} from "./chunk-PGOYDOI4.js";
+} from "./chunk-XEGQT5EN.js";
 import {
   inLinkedWorktree,
   sessionBase,
   stateRoot,
-  writableStateRoot
-} from "./chunk-SSDLHWSF.js";
-import {
+  writableStateRoot,
   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 };
-  }
-};
+} from "./chunk-6W4UH2BQ.js";
 
 // src/adapters/pr.ts
 import { spawn } from "child_process";
@@ -912,8 +412,12 @@ function makePRAdapter(opts) {
 // src/engine/council.ts
 import { z } from "zod";
 var ArchitectPlanSchema = z.object({
-  rootCause: z.string(),
-  plan: z.array(z.string())
+  rootCause: z.string().describe(
+    "Why the earlier attempts failed \u2014 the underlying reason, not a summary of what they tried. One paragraph, naming the file, symbol or assumption that is actually wrong."
+  ),
+  plan: z.array(z.string()).describe(
+    'The steps to fix it, as an ARRAY OF STRINGS \u2014 one instruction per element, in the order they should be carried out. Each names what to change and where, e.g. "add IOrderDeliveryPipe to src/domain/Suppliers/Abstractions/". Not prose, not a single string, not a document: the senior implementer executes these one at a time.'
+  )
 });
 async function runEscalationCouncil(deps, board, taskId, cwd, family) {
   const task = board.get(taskId);
@@ -981,6 +485,127 @@ Identify the root cause and produce a concrete plan.`
   return v;
 }
 
+// src/core/failures.ts
+function isProviderOutage(message) {
+  return /no active credentials for provider:?\s*[\w.-]+/i.test(message) || /provider\s+'?[\w.-]+'?\s+is not configured/i.test(message) || /all\s+[\w.-]+\s+accounts have exhausted their quota/i.test(message) || /shared egress ip quota exhausted/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 isCatalogRejection(message) {
+  return /not (?:currently )?available in the [^.]{0,40}catalog/i.test(message);
+}
+
+// src/engine/split-card.ts
+import { z as z2 } from "zod";
+var SPLIT_AFTER_ATTEMPTS = 5;
+var MIN_PIECES = 2;
+var MAX_PIECES = 4;
+function failureSubjects(card) {
+  const seen = [];
+  for (const h of card.stageHistory) {
+    if (h.action !== "reviewed:fail") continue;
+    const s = subjectOf(String(h.note ?? ""));
+    if (s && !seen.includes(s)) seen.push(s);
+  }
+  return seen;
+}
+function shouldSplit(card, after = SPLIT_AFTER_ATTEMPTS) {
+  return !wasSplit(card) && reviewFailures(card) >= after;
+}
+function wasSplit(card) {
+  return card.stageHistory.some((h) => h.action === "split:into");
+}
+function reviewFailures(card) {
+  return card.stageHistory.filter((h) => h.action === "reviewed:fail").length;
+}
+var PiecesSchema = z2.object({
+  pieces: z2.array(z2.object({
+    title: z2.string().describe("What this piece delivers, in the same voice as the original card's title."),
+    acceptance: z2.array(z2.string()).default([]).describe(
+      "What must be OBSERVABLY true when this piece is done \u2014 checkable against the worktree."
+    ),
+    files: z2.array(z2.string()).default([]).describe(
+      "Repo-relative files this piece creates or modifies. Two pieces that write the same file are not independent, so say so honestly rather than spreading one file across several."
+    )
+  }))
+});
+function splitRequest(card) {
+  const subjects = failureSubjects(card);
+  const notes = card.reviewNotes.slice(0, 12).map((n) => `- ${n}`).join("\n");
+  return (
+    // `attempts` is reset each run; the lifetime count is the number that means anything to a reader.
+    `This task has failed review ${reviewFailures(card)} times and is being CUT UP rather than attempted again.
+
+Task: ${card.title}
+` + (card.acceptance.length ? `
+It must still deliver:
+${card.acceptance.map((a) => `- ${a}`).join("\n")}
+` : "") + (subjects.length ? `
+Its review failures have named these areas, which is the evidence of where the seams are:
+${subjects.map((s) => `- ${s}`).join("\n")}
+` : "") + (notes ? `
+The findings still open:
+${notes}
+` : "") + `
+Cut it into ${MIN_PIECES}-${MAX_PIECES} pieces that together deliver exactly what the original did \u2014 no more, no less. Cut along the seams above: a second concern, a second layer, a second story. Each piece must be something one reviewer can judge whole, and must leave the repository different on its own. Do not invent work the original did not ask for, and do not leave any of its acceptance criteria unclaimed.
+Return {pieces} via submit.`
+  );
+}
+async function proposeSplit(opts, card) {
+  const { pieces } = await runStructuredRole(
+    { ...opts, messages: [...opts.messages, { role: "user", content: splitRequest(card) }] },
+    PiecesSchema
+  );
+  return pieces.slice(0, MAX_PIECES);
+}
+function applySplit(board, parentId, pieces) {
+  if (pieces.length < MIN_PIECES) return [];
+  const parent = board.get(parentId);
+  if (!parent) return [];
+  const ids = [];
+  let previous;
+  for (const [i, piece] of pieces.entries()) {
+    const id = freeId(board, parentId, i);
+    board.addCard({
+      id,
+      title: piece.title,
+      // The first piece inherits what the parent waited for; each later one waits for the piece before it.
+      deps: previous ? [previous] : [...parent.deps],
+      acceptance: piece.acceptance,
+      files: piece.files
+    });
+    board.appendStage(id, { role: "team-lead", action: "split:from", note: `${parentId} \u2014 ${parent.title}` });
+    ids.push(id);
+    previous = id;
+  }
+  const last = ids[ids.length - 1];
+  for (const c of board.list()) {
+    if (c.id === parentId || ids.includes(c.id) || !c.deps.includes(parentId)) continue;
+    board.removeDep(c.id, parentId);
+    board.addDep(c.id, last);
+  }
+  board.appendStage(parentId, {
+    role: "team-lead",
+    action: "split:into",
+    // The LIFETIME count, for the same reason the brief uses it: `attempts` is reset each run, so the record
+    // of why this card was cut would have read "0 attempts" on the very run that cut it. It did.
+    note: `${reviewFailures(parent)} review failures over ${failureSubjects(parent).length} areas \u2192 ${ids.join(", ")}`
+  });
+  board.move(parentId, "ABANDONED", "team-lead");
+  return ids;
+}
+function freeId(board, parentId, index) {
+  for (let n = index; n < index + 26; n++) {
+    const id = `${parentId}${String.fromCharCode(97 + n)}`;
+    if (!board.get(id)) return id;
+  }
+  return `${parentId}-${index}`;
+}
+function humanAbandoned(card) {
+  return card.column === "ABANDONED" && card.stageHistory.some((h) => h.action === "human:abandon");
+}
+
 // src/engine/escalation.ts
 function autonomousAskHuman(maxRetries = 2) {
   const retries = /* @__PURE__ */ new Map();
@@ -1008,16 +633,47 @@ function noChangeStreak(task) {
 function tierOf(attempts, rounds) {
   return attempts < rounds ? 0 : attempts < 2 * rounds ? 1 : 2;
 }
+function isFleetFailure(message) {
+  return isCatalogRejection(message) || isProviderOutage(message) || isUnknownModelError(message) || /capacity is (?:temporarily unavailable|busy)|retry shortly/i.test(message) || /did not accept a connection in time|upstream request failed/i.test(message) || /is an image-generation model|only available hosted/i.test(message) || /not (?:yet )?available for this subscription/i.test(message);
+}
+var FLEET_PATIENCE = 3;
+function consecutiveFleetFailures(board, taskId) {
+  const h = board.get(taskId)?.stageHistory ?? [];
+  let n = 0;
+  for (let i = h.length - 1; i >= 0; i--) {
+    const { action, note } = h[i];
+    if (action === "attempt-error") {
+      if (!isFleetFailure(note ?? "")) break;
+      n += 1;
+      continue;
+    }
+    if (action.startsWith("\u2192")) continue;
+    break;
+  }
+  return n;
+}
 function attemptError(board, taskId, role, e) {
   const msg = e instanceof Error ? e.message : String(e);
+  const fleet = isFleetFailure(msg);
   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.addReviewNote(taskId, fleet ? `The previous attempt never reached a model (${msg}). Nothing is known about the work yet \u2014 start it fresh.` : `The previous attempt did not finish (${msg}). Complete the task within the turn budget.`);
   board.move(taskId, "TODO", role);
-  return { verdict: "fail", notes: [msg] };
+  if (!fleet) return { verdict: "fail", notes: [msg] };
+  return consecutiveFleetFailures(board, taskId) >= FLEET_PATIENCE ? { verdict: "fail", notes: [msg], fleetDown: true } : { verdict: "fail", notes: [msg], fleetFailure: true };
 }
 async function runTaskWithEscalation(deps, board, taskId, cwd, slot = 0) {
   const task = board.get(taskId);
   if (!task) throw new Error(`runTaskWithEscalation: unknown task: ${taskId}`);
+  if (shouldSplit(task) && deps.splitCard) {
+    const pieces = await deps.splitCard(task);
+    const ids = applySplit(board, taskId, pieces);
+    if (ids.length) {
+      const note = `${reviewFailures(task)} review failures over ${failureSubjects(task).length} areas \u2192 split into ${ids.join(", ")}`;
+      deps.note?.(`\u2702\uFE0F **${taskId}** ${note}`);
+      return { verdict: "fail", notes: [note], split: ids };
+    }
+    board.appendStage(taskId, { role: "team-lead", action: "split:declined", note: "nothing separable found" });
+  }
   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."];
@@ -1060,6 +716,8 @@ async function runTaskWithEscalation(deps, board, taskId, cwd, slot = 0) {
         v2 = attemptError(board, taskId, role, e);
       }
       if (v2.verdict === "pass") return v2;
+      if (v2.fleetDown) return v2;
+      if (v2.fleetFailure) continue;
       if (v2.noProgress) {
         const tierStart = Math.floor(attempts / deps.rounds) * deps.rounds;
         const target = attempts === tierStart ? attempts + 1 : tierStart + deps.rounds;
@@ -1105,13 +763,13 @@ async function runTaskWithEscalation(deps, board, taskId, cwd, slot = 0) {
 }
 
 // src/engine/pr-summary.ts
-import { z as z2 } from "zod";
+import { z as z3 } 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)
+var PRSummarySchema = z3.object({
+  title: z3.string().min(1),
+  body: z3.string().min(1)
 });
 async function recentSubjects(git, cwd, base) {
   const read = async (args) => {
@@ -1188,19 +846,19 @@ async function prSummary(deps, opts) {
 }
 
 // src/engine/revision.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var REVISION_CARD = "__revision__";
-var PrincipalReviewSchema = z3.object({
-  decision: z3.enum(["approve", "request-changes"]).describe(
+var PrincipalReviewSchema = z4.object({
+  decision: z4.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())
+  comments: z4.array(z4.string())
 });
-var PrincipalFinalSchema = z3.object({
-  decision: z3.enum(["accept", "ask-human"]).describe(
+var PrincipalFinalSchema = z4.object({
+  decision: z4.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()
+  question: z4.string()
 });
 async function worktreeState2(deps, base) {
   const git = deps.git ?? defaultGitRunner;
@@ -1444,6 +1102,10 @@ async function runWaveTask(deps, session, board, taskId, slot = 0) {
     return { status: "task-failed", task: tw };
   }
   deps.signal.throwIfAborted();
+  if (v.verdict === "fail" && v.fleetDown) {
+    board.appendStage(taskId, { role: "team-lead", action: "fleet-down", note: v.notes[0]?.slice(0, 200) });
+    return { status: "fleet-down", task: tw };
+  }
   if (v.verdict === "fail") {
     board.appendStage(taskId, { role: "team-lead", action: "task-failed" });
     board.move(taskId, "ABANDONED", "team-lead");
@@ -1718,7 +1380,7 @@ ${card.reviewNotes.map((n) => `- ${n}`).join("\n")}` : "";
 }
 
 // src/engine/team-lead.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/engine/waves.ts
 function computeWaves(board) {
@@ -1810,10 +1472,10 @@ function describeWaves(s) {
 }
 
 // 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 fix = z5.object({ task: z5.string(), needs: z5.string(), why: z5.string() });
+var DepAuditSchema = z5.object({
+  missing: z5.array(fix).default([]),
+  spurious: z5.array(fix).default([])
 });
 var AUDIT_TIMEOUT_MS = 9e4;
 var MAX_AUDIT_CARDS = 40;
@@ -1944,11 +1606,12 @@ async function runReady(deps, session, board) {
     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));
+  const pending = new Set(cards.filter((c) => !done.has(c.id) && !humanAbandoned(c)).map((c) => c.id));
   for (const id of pending) {
     const c = board.get(id);
     if (!c || c.attempts === 0) continue;
     board.resetAttempts(id);
+    if (c.column === "ABANDONED") board.reopen(id);
   }
   const busy = /* @__PURE__ */ new Set();
   const running = /* @__PURE__ */ new Map();
@@ -1963,7 +1626,7 @@ async function runReady(deps, session, board) {
     board.appendStage(id, {
       role: "team-lead",
       action: "parked",
-      note: reason === "waiting" ? `waiting for ${on}` : reason === "conflict" ? "merge conflicted" : "ladder exhausted"
+      note: reason === "waiting" ? `waiting for ${on}` : reason === "conflict" ? "merge conflicted" : reason === "fleet" ? "no model could be reached" : "ladder exhausted"
     });
     board.move(id, "PARKED", "team-lead");
   };
@@ -1971,7 +1634,7 @@ async function runReady(deps, session, board) {
     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;
+      const ready = p.reason === "waiting" ? p.on !== void 0 && done.has(p.on) : p.reason === "fleet" ? true : merged.length > p.mergedAt;
       if (!ready) continue;
       parked.delete(id);
       pending.add(id);
@@ -1995,7 +1658,27 @@ async function runReady(deps, session, board) {
       }
     }
   };
+  const known = /* @__PURE__ */ new Set([...pending, ...done]);
+  const absorbNewCards = () => {
+    for (const c of board.list()) {
+      if (wasSplit(c) || humanAbandoned(c)) {
+        pending.delete(c.id);
+        parked.delete(c.id);
+        known.add(c.id);
+        continue;
+      }
+      if (c.id === REVISION_CARD || known.has(c.id)) continue;
+      known.add(c.id);
+      if (c.column === "MERGED") {
+        done.add(c.id);
+        continue;
+      }
+      pending.add(c.id);
+      deps.note?.(`\u2795 **${c.id}** ${c.title}`);
+    }
+  };
   while (pending.size > 0 || running.size > 0 || parked.size > 0) {
+    absorbNewCards();
     parkUnreachable();
     const limit = ceiling();
     for (const id of [...pending]) {
@@ -2068,7 +1751,12 @@ async function runReady(deps, session, board) {
               });
               park(id, "conflict", void 0, mergedAtStart);
             }
-          } else park(id, res.status === "conflict" ? "conflict" : "exhausted", void 0, mergedAtStart);
+          } else park(
+            id,
+            res.status === "conflict" ? "conflict" : res.status === "fleet-down" ? "fleet" : "exhausted",
+            void 0,
+            mergedAtStart
+          );
         } finally {
           for (const f of files) busy.delete(f);
           free.push(slot);
@@ -2106,7 +1794,7 @@ async function runReady(deps, session, board) {
       }
       if (rewrote > 0) continue;
       for (const [id, p] of parked) {
-        (p.reason === "waiting" ? skipped : failed).push(id);
+        (p.reason === "waiting" || p.reason === "fleet" ? skipped : failed).push(id);
         board.appendStage(id, {
           role: "team-lead",
           action: "abandoned",
@@ -2900,6 +2588,31 @@ ${USAGE_FILE}
   }
 };
 
+// src/engine/tally.ts
+var DELIVERED_SHARE = 0.5;
+function describeTally(t) {
+  const total = t.merged + t.failed + t.blocked + t.unfinished;
+  if (!total) return "no tasks were planned";
+  const parts = [
+    t.failed ? `${t.failed} failed` : "",
+    t.blocked ? `${t.blocked} blocked behind them` : "",
+    t.unfinished ? `${t.unfinished} still open` : ""
+  ].filter(Boolean).join(", ");
+  const head = `${t.merged} of ${total} tasks merged`;
+  if (t.merged === total) return head;
+  return t.merged / total < DELIVERED_SHARE ? `\u26A0\uFE0F ${head} \u2014 ${parts}. Most of the plan did not land; the feature is not built.` : `${head} \u2014 ${parts}.`;
+}
+function tallyBoard(cards, revisionCardId = "__revision__") {
+  const t = { merged: 0, failed: 0, blocked: 0, unfinished: 0 };
+  for (const c of cards) {
+    if (c.id === revisionCardId) continue;
+    if (c.column === "MERGED") t.merged++;
+    else if (c.column === "ABANDONED") (c.attempts ?? 0) > 0 ? t.failed++ : t.blocked++;
+    else t.unfinished++;
+  }
+  return t;
+}
+
 // src/engine/turn-effect.ts
 import { readFile as readFile3, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
@@ -3006,9 +2719,9 @@ 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."),
+import { z as z6 } from "zod";
+var RefinerSchema = z6.object({
+  refinedPrompt: z6.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.
    *
@@ -3020,13 +2733,13 @@ var RefinerSchema = z5.object({
    * 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(
+  intent: z6.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"),
+  language: z6.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")
+  title: z6.string().default("task")
 });
 async function runRefiner(deps, prompt, history = []) {
   const resolved = deps.roleRegistry.resolve("refiner");
@@ -3345,7 +3058,11 @@ ${carryOver.map((c) => `- ${c}`).join("\n")}` : "";
 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.
+Size a task to a coherent piece of BEHAVIOUR someone can review as a whole, not to a file. ONE entity with its configuration, its migration and its tests is one task: nobody can review those apart and none of them is deliverable alone.
+But ONE entity, not the data model: a task nobody can hold in their head at once comes back from review again and again, and each return costs another full round of the team. Measured on one board, by review calls spent: 2 files 35, 3 files 45, 6 files 40, 19 files 116 across six attempts.
+Do not count files. What costs is BREADTH: how many separate decisions a reviewer must hold at once. A card that adds one entity end to end is narrow even across several files; a card that touches four files belonging to four different concerns is broad, and it was a four-file card that cost the most per file on that board. Split along the seam a reviewer would look for anyway \u2014 a second concern, a second layer, a second story \u2014 not at a file boundary.
+Every task carries a full implement-and-review round whatever it holds, so splitting finer does not divide that cost \u2014 but a task nobody can review in one sitting does not avoid it either, it pays it repeatedly.
+Never split one file across two tasks, and that includes across PHASES \u2014 creating a file empty in Setup and filling it in later is one task, not two. Split only where the parts are genuinely independent: they can be reviewed and merged on their own, or they must run at the same time in different worktrees. "They are separately describable" is not independence, and the template's "one entity per task" examples are about creating new files, not about sizing work in a repository that already exists.
 Follow this template:
 
 ${template}
@@ -3362,10 +3079,10 @@ async function runTasks(p, paths, carryOver) {
 // 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({
+import { z as z7 } from "zod";
+var ClarifyStepSchema = z7.object({
   // The single most important clarifying question, or null when the spec is sufficiently clear.
-  nextQuestion: z6.string().nullable()
+  nextQuestion: z7.string().nullable()
 });
 async function runClarify(p, paths, maxRounds = 5) {
   const specRel = relative2(p.workdir, paths.spec);
@@ -3500,7 +3217,7 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
     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 { runVerify, describeVerify, currentBranchOf } = await import("./verify-6SC4I77M.js");
     const branch = await currentBranchOf(cwd);
     const res = await runVerify({
       deps,
@@ -3543,11 +3260,11 @@ async function runUpstream(deps, ensureWorktree, prompt, askUser, maxRounds, his
   if (!resume && !hasPreservedWork && routeIntent(r.intent) === "pipeline") {
     const cwd = workingIn?.() ?? process.cwd();
     emitPhase("sizing");
-    const { sizeRequest } = await import("./triage-2J3T5PVQ.js");
+    const { sizeRequest } = await import("./triage-FCYHD2AQ.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 { describeSizeDoubt } = await import("./triage-FCYHD2AQ.js");
       const answer = await askInUserLanguage(
         deps,
         askUser,
@@ -3565,8 +3282,8 @@ Which is it?`,
     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 { runSmallChange, describeSmallChange } = await import("./fix-JOIXQFVP.js");
+      const { currentBranchOf } = await import("./verify-6SC4I77M.js");
       const res = await runSmallChange(deps, cwd, r.title, r.refinedPrompt, size);
       return {
         intent: r.intent,
@@ -3750,17 +3467,17 @@ The last attempt left conflict markers in: ${conflicted.join(", ")}`;
 }
 
 // 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()),
+import { z as z8 } from "zod";
+var taskSchema = z8.object({
+  id: z8.string(),
+  title: z8.string(),
+  deps: z8.array(z8.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(
+  acceptance: z8.array(z8.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.'
   ),
   /**
@@ -3771,11 +3488,11 @@ var taskSchema = z7.object({
    * `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(
+  files: z8.array(z8.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) => {
+var TasksSchema = z8.object({ tasks: z8.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}` });
@@ -3797,13 +3514,29 @@ async function runProjectManager(opts) {
 }
 
 // src/engine/task-audit.ts
-import { z as z8 } from "zod";
-var CoverageSchema = z8.object({
-  missing: z8.array(z8.string()).default([]).describe(
+import { z as z9 } from "zod";
+var CoverageSchema = z9.object({
+  missing: z9.array(z9.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(
+  weak: z9.array(z9.object({ task: z9.string(), issue: z9.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."
+  ),
+  /**
+   * The question this audit was not asking, and the one that cost a 16-hour run.
+   *
+   * Coverage was checked in one direction only: is every requirement covered? Measured live on a 124-task
+   * breakdown, the expensive gap was the other direction. `T001 — Backend: Supplier entity model` invented a
+   * `Supplier` entity and a `SupplierContext` that the spec never described; the spec asks for
+   * `SupplierRelationship`. The implementer built what the task said and the code reviewer rejected it for
+   * not matching the spec — six times, across two roles, until the task was abandoned. 117 further tasks
+   * were parked behind it and never attempted. Four of 124 landed.
+   *
+   * A task nothing asked for is not merely wasted work: it deadlocks, because the two halves of the
+   * pipeline are reading different documents and each is right about its own.
+   */
+  fabricated: z9.array(z9.object({ task: z9.string(), issue: z9.string() })).default([]).describe(
+    "Tasks that deliver something the plan does not ask for \u2014 an entity, a module or a behaviour that appears in the task and nowhere in the plan. Name what the task invents and what the plan says instead. A task that merely IMPLEMENTS a plan requirement in a reasonable way is not fabricated."
   )
 });
 var words = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2);
@@ -3908,9 +3641,9 @@ function structuralFindings(board) {
   }
   return out;
 }
-async function auditBreakdown(opts, board, planText) {
+async function auditBreakdown(opts, board, planText, alwaysAsk = false) {
   const findings = structuralFindings(board);
-  if (findings.length > 0 || !opts) return { findings, asked: false };
+  if (findings.length > 0 && !alwaysAsk || !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");
@@ -3923,19 +3656,29 @@ ${planText}
 The tasks it was broken into:
 ${cards}
 
-Two questions, and only these:
+Three 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?
+3. fabricated \u2014 the reverse of 1: is there a task that delivers something the plan never asks for? An entity, module or behaviour named in the task and nowhere in the plan. Name what the task invents AND what the plan says instead. Implementing a plan requirement in a reasonable way is not fabrication; inventing the requirement is.
 
-Both lists are usually empty on a good breakdown. Return {missing, weak} via submit.`
+All three lists are usually empty on a good breakdown. Return {missing, weak, fabricated} via submit.`
   };
   try {
     const out = await runStructuredRole({ ...opts, messages: [...opts.messages, msg] }, CoverageSchema);
     return {
       asked: true,
+      // Structural findings are carried through: on the second pass they are still open and still true, and
+      // dropping them here would report a repaired board as clean.
       findings: [
+        ...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 }))
+        ...out.weak.filter((w) => board.get(w.task)).map((w) => ({ task: w.task, issue: w.issue })),
+        // Filtered against the board like `weak`: an auditor naming a task that does not exist has answered
+        // about something else, and acting on it would repair a card nobody planned.
+        ...out.fabricated.filter((f) => board.get(f.task)).map((f) => ({
+          task: f.task,
+          issue: `the plan does not ask for this: ${f.issue}`
+        }))
       ]
     };
   } catch (e) {
@@ -3956,19 +3699,19 @@ function snapshotBoard(board) {
 }
 
 // src/engine/memory-consolidate.ts
-import { z as z9 } from "zod";
+import { z as z10 } 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(
+var LearnedSchema = z10.object({
+  memories: z10.array(z10.object({
+    text: z10.string(),
+    kind: z10.enum(["fact", "lesson"]),
+    audience: z10.array(z10.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(
+    importance: z10.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."
     )
   }))
@@ -4086,7 +3829,7 @@ async function loadBoard(path2) {
 }
 
 // src/engine/job.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync3 } 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) {
@@ -4167,7 +3910,7 @@ async function gateBreakdown(deps, workdir, tasksPath, planPath, emit) {
     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);
+  const left = await auditBreakdown(auditOpts(deps, workdir), board, planText, true);
   if (left.findings.length) {
     emit({ kind: "note", text: `\u{1F9FE} ${left.findings.length} of those are still open after the repair \u2014 continuing anyway.` });
   }
@@ -4213,6 +3956,15 @@ Give the user a short final report (what happened in each task).` }],
   const msg = await runToCompletion(opts);
   return stripThinking(msg.content);
 }
+function tallyOnDisk(sessionRoot) {
+  try {
+    const raw = JSON.parse(readFileSync3(join6(sessionRoot, "board.json"), "utf8"));
+    const cards = Array.isArray(raw) ? raw : raw.cards;
+    return Array.isArray(cards) && cards.length ? tallyBoard(cards) : void 0;
+  } catch {
+    return void 0;
+  }
+}
 async function runJob(deps, opts) {
   const onEvent = opts.onEvent;
   const emit = onEvent ? (ev) => {
@@ -4315,7 +4067,7 @@ async function runJob(deps, opts) {
       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 neverTried = board.list().filter((c) => c.id !== REVISION_CARD && c.column === "ABANDONED" && (c.attempts ?? 0) === 0 && !humanAbandoned(c));
       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);
@@ -4333,7 +4085,12 @@ async function runJob(deps, opts) {
     };
     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 });
+    const wave = await runWaves(
+      { ...deps, askUser: opts.askUser },
+      session,
+      board,
+      { base: opts.fromBranch, prTitle: opts.prTitle, request: opts.prompt }
+    );
     emit({ kind: "phase", phase: "waves-done", detail: wave.status });
     let revision;
     let deferredAll = [];
@@ -4370,18 +4127,23 @@ async function runJob(deps, opts) {
       }
     }
     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}\`.` });
-      }
+      emit({ kind: "note", text: `\u{1F4E6} The work is on \`${wave.delivery.branch}\` \u2014 merge it when you are ready.` });
     }
-    await curate(deps, up.refinedPrompt ?? opts.prompt, board.list(), deferredAll, session.baseWorktree);
+    const afterDelivery = async (what, run) => {
+      try {
+        await run();
+      } catch (e) {
+        if (deps.signal.aborted) throw e;
+        emit({ kind: "note", text: `\u26A0\uFE0F ${what} could not run (${e instanceof Error ? e.message : String(e)}). The delivered work is unaffected.` });
+      }
+    };
+    const live = session;
+    await afterDelivery("Memory curation", () => curate(deps, up.refinedPrompt ?? opts.prompt, board.list(), deferredAll, live.baseWorktree));
     emit({ kind: "phase", phase: "report" });
-    const report = await runCoachReport(deps, session, board);
+    let report = "";
+    await afterDelivery("The closing report", async () => {
+      report = await runCoachReport(deps, live, board);
+    });
     await flushBoard(boardPath);
     const unfinished = board.list().filter((c) => c.id !== REVISION_CARD && c.column !== "MERGED");
     if (!unfinished.length) {
@@ -4402,7 +4164,11 @@ async function runJob(deps, opts) {
     });
     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) {
+      const tally = tallyOnDisk(session.root);
+      if (tally) emit({ kind: "note", text: `\u{1F4CA} ${describeTally(tally)}` });
+      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 {
@@ -4470,12 +4236,11 @@ function restoreOnExit(h, proc = process, onInterrupt) {
 }
 
 export {
-  isAnthropicModel,
-  isUnknownModelError,
-  OmniRouteProvider,
   defaultCmdRunner,
   detectPlatform,
   makePRAdapter,
+  isUnknownModelError,
+  proposeSplit,
   autonomousAskHuman,
   Timings,
   MAX_PARALLEL_TASKS,
@@ -4483,6 +4248,7 @@ export {
   makeApprove,
   nodeLineReader,
   MemoryStore,
+  describeTally,
   runJob,
   sttySane,
   restoreTerminal,