@ordewell/core 0.5.5 → 0.5.6

package/dist/{chunk-KLN7ELXO.mjs → chunk-ROVYWEBI.mjs}

@@ -10,7 +10,7 @@ import {
   renumberTasks,
   stripTrailingCommas,
   updateTaskInPlan
-} from "./chunk-HD2FWPRV.mjs";
+} from "./chunk-EDGUFCIR.mjs";
 
 // src/models/Usage.ts
 function partedPromptUsage(parts) {
@@ -59,732 +59,1147 @@ function plannerContextFill(usage) {
   return { usedTokens: usage.lastPromptTokens, windowTokens: usage.contextWindow };
 }
 
-// src/services/ModelAllowlistResolver.ts
-function effectiveAllowlist(allowlist, runner, modelsByRunner) {
-  if (!allowlist || allowlist.length === 0) return void 0;
-  if (!modelsByRunner) return allowlist;
-  const own = new Set((modelsByRunner[runner] ?? []).map((m) => m.modelId));
-  const elsewhere = /* @__PURE__ */ new Set();
-  for (const [other, models] of Object.entries(modelsByRunner)) {
-    if (other === runner) continue;
-    for (const m of models ?? []) elsewhere.add(m.modelId);
+// src/services/harness/agentTools.ts
+var KNOWN_TOOLS = {
+  // Claude Code
+  read: "read_file",
+  grep: "grep",
+  glob: "glob",
+  bash: "bash",
+  ls: "list_dir",
+  webfetch: "fetch",
+  websearch: "web_search",
+  // Codex — its sandboxed command tool is a shell by another name
+  shell: "bash",
+  exec_command: "bash",
+  local_shell: "bash",
+  // OpenCode
+  list: "list_dir",
+  fetch: "fetch"
+};
+function mapAgentTool(name) {
+  const normalized = name.trim().toLowerCase().replace(/[_-]/g, "");
+  const direct = KNOWN_TOOLS[normalized] ?? KNOWN_TOOLS[name.trim().toLowerCase()];
+  if (direct) {
+    return { tool: direct, toolLabel: name };
   }
-  const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
-  return kept.length > 0 ? kept : void 0;
+  return { tool: "agent_tool", toolLabel: name };
 }
-function filterModelsForPrompt(modelsByRunner, perRunnerAllowlist) {
-  const result = {};
-  for (const [runner, models] of Object.entries(modelsByRunner)) {
-    if (!models) continue;
-    const allowed = effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
-    if (!allowed) {
-      result[runner] = models;
-      continue;
+function normalizeAgentArgs(tool, args) {
+  const out = { ...args };
+  const alias = (from, to) => {
+    if (out[to] === void 0 && out[from] !== void 0) out[to] = out[from];
+  };
+  if (tool === "read_file" || tool === "list_dir") {
+    alias("filePath", "path");
+    alias("file_path", "path");
+    alias("target", "path");
+  }
+  if (tool === "bash") {
+    alias("cmd", "command");
+    alias("script", "command");
+    if (typeof out.command !== "string" && Array.isArray(out.command)) {
+      out.command = out.command.join(" ");
     }
-    const allowedSet = new Set(allowed);
-    const intersection = models.filter((m) => allowedSet.has(m.modelId));
-    const covered = new Set(intersection.map((m) => m.modelId));
-    const missing = allowed.filter((id) => !covered.has(id)).map((id) => ({ modelId: id, modelLabel: id.split("/").pop() || id, variants: [] }));
-    result[runner] = [...intersection, ...missing];
   }
-  return result;
+  if (tool === "fetch") alias("uri", "url");
+  if (tool === "web_search") alias("q", "query");
+  return out;
 }
-var EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
-var EFFORT_ALIASES = { disabled: "none", adaptive: "medium" };
-function clampThinkingEffort(effort, variants) {
-  if (!effort) return void 0;
-  if (variants.length === 0) return void 0;
-  const ids = new Set(variants.map((v) => v.id));
-  if (ids.has(effort)) return effort;
-  const canon = EFFORT_ALIASES[effort] ?? effort;
-  if (ids.has(canon)) return canon;
-  const idx = EFFORT_LADDER.indexOf(canon);
-  if (idx < 0) return void 0;
-  for (let d = 1; d < EFFORT_LADDER.length; d++) {
-    const lower = EFFORT_LADDER[idx - d];
-    if (lower && ids.has(lower)) return lower;
-    const higher = EFFORT_LADDER[idx + d];
-    if (higher && ids.has(higher)) return higher;
-  }
-  return void 0;
+
+// src/services/terminalRender.ts
+var ANSI_OR_CTRL_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[()][AB012]|\x1b[=>]|[\x00-\x08\x0b-\x1f\x7f]/g;
+function flattenTerminalOutput(raw) {
+  return raw.replace(ANSI_OR_CTRL_RE, "").replace(/[─-▟]/g, "").replace(/\s+/g, "");
 }
-function coerceAssignments(tasks, perRunnerAllowlist, allowedRunners, modelsByRunner) {
-  const clampVariant = (task) => {
-    if (!task.assignedModel || !modelsByRunner) return task;
-    const model = modelsByRunner[task.assignedRunner]?.find(
-      (m) => m.modelId === task.assignedModel.modelId
-    );
-    if (!model) return task;
-    const clamped = clampThinkingEffort(task.assignedModel.thinkingEffort, model.variants);
-    return {
-      ...task,
-      assignedModel: {
-        ...task.assignedModel,
-        thinkingEffort: clamped,
-        availableVariants: model.variants.map((v) => v.id)
-      }
-    };
-  };
-  const allowedFor = (runner) => effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
-  const assignmentFor = (runner, modelId) => {
-    const known = modelsByRunner?.[runner]?.find((m) => m.modelId === modelId);
-    return {
-      modelId,
-      modelLabel: known?.modelLabel ?? modelId,
-      thinkingEffort: void 0,
-      ...known ? { availableVariants: known.variants.map((v) => v.id) } : {}
-    };
+function renderTerminalOutput(raw) {
+  const rows = /* @__PURE__ */ new Map();
+  let row = 1;
+  let col = 1;
+  let savedRow = 1;
+  let savedCol = 1;
+  const cells = (r) => {
+    let line = rows.get(r);
+    if (!line) {
+      line = [];
+      rows.set(r, line);
+    }
+    return line;
   };
-  return tasks.map((task) => {
-    if (task.type === "user") return task;
-    if (allowedRunners && !allowedRunners.includes(task.assignedRunner)) {
-      const fallbackRunner = allowedRunners[0];
-      const fallbackModels = allowedFor(fallbackRunner);
-      const fallbackModel = fallbackModels?.length ? assignmentFor(fallbackRunner, fallbackModels[0]) : modelsByRunner?.[fallbackRunner]?.[0] ? assignmentFor(fallbackRunner, modelsByRunner[fallbackRunner][0].modelId) : task.assignedModel;
-      return clampVariant({
-        ...task,
-        assignedRunner: fallbackRunner,
-        assignedModel: fallbackModel
-      });
+  const firstParam = (params, fallback = 1) => params[0] || fallback;
+  const eraseLine = (mode) => {
+    const line = cells(row);
+    if (mode === 2) {
+      rows.set(row, []);
+    } else if (mode === 1) {
+      for (let c = 0; c < col; c++) line[c] = " ";
+    } else {
+      line.length = Math.max(0, col - 1);
     }
-    const allowlist = allowedFor(task.assignedRunner);
-    if (!task.assignedModel) {
-      if (allowlist && allowlist.length > 0) {
-        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) });
-      }
-      const discovered = modelsByRunner?.[task.assignedRunner]?.[0];
-      if (discovered) {
-        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, discovered.modelId) });
+  };
+  for (let i = 0; i < raw.length; ) {
+    const ch = raw[i];
+    if (ch === "\x1B") {
+      const kind = raw[i + 1];
+      if (kind === "[") {
+        let end = i + 2;
+        while (end < raw.length) {
+          const code = raw.charCodeAt(end);
+          if (code >= 64 && code <= 126) break;
+          end++;
+        }
+        if (end >= raw.length) break;
+        const final = raw[end];
+        const body = raw.slice(i + 2, end).replace(/^[?<>=!]+/, "");
+        const params = body.split(";").map((p) => Number.parseInt(p, 10) || 0);
+        switch (final) {
+          case "H":
+          case "f":
+            row = params[0] || 1;
+            col = params[1] || 1;
+            break;
+          case "G":
+            col = firstParam(params);
+            break;
+          case "d":
+            row = firstParam(params);
+            break;
+          case "A":
+            row = Math.max(1, row - firstParam(params));
+            break;
+          case "B":
+            row += firstParam(params);
+            break;
+          case "C":
+            col += firstParam(params);
+            break;
+          case "D":
+            col = Math.max(1, col - firstParam(params));
+            break;
+          case "E":
+            row += firstParam(params);
+            col = 1;
+            break;
+          case "F":
+            row = Math.max(1, row - firstParam(params));
+            col = 1;
+            break;
+          case "s":
+            savedRow = row;
+            savedCol = col;
+            break;
+          case "u":
+            row = savedRow;
+            col = savedCol;
+            break;
+          case "K":
+            eraseLine(params[0] || 0);
+            break;
+          case "J":
+            if ((params[0] || 0) === 2 || (params[0] || 0) === 3) rows.clear();
+            break;
+          case "X": {
+            const line = cells(row);
+            for (let c = 0; c < firstParam(params); c++) line[col - 1 + c] = " ";
+            break;
+          }
+          case "P": {
+            cells(row).splice(col - 1, firstParam(params));
+            break;
+          }
+          case "@": {
+            cells(row).splice(col - 1, 0, ...Array(firstParam(params)).fill(" "));
+            break;
+          }
+          default:
+            break;
+        }
+        i = end + 1;
+        continue;
       }
-      return task;
-    }
-    if (!allowlist || allowlist.length === 0) return clampVariant(task);
-    if (allowlist.includes(task.assignedModel.modelId)) return clampVariant(task);
-    return { ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) };
-  });
-}
-
-// src/services/TaskOps.ts
-import { v4 as uuidv4 } from "uuid";
-
-// src/services/TaskEditValidator.ts
-var AI_ONLY_FIELDS = ["assignedModel", "thinkingEffort", "taskMode", "autonomy"];
-function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
-  if (!catalog) return { ok: true };
-  if (assignedModel) {
-    const models = catalog.modelsByRunner[runner];
-    if (models) {
-      const modelId = assignedModel.modelId;
-      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
-      if (!models.some((m) => m.modelId === modelId) && !allowed?.includes(modelId)) {
-        return { ok: false, error: `Runner "${runner}" does not offer model "${modelId}"` };
+      if (kind === "]" || kind === "P" || kind === "^" || kind === "_") {
+        let end = i + 2;
+        while (end < raw.length && raw[end] !== "\x07" && !(raw[end] === "\x1B" && raw[end + 1] === "\\")) end++;
+        if (end >= raw.length) break;
+        i = raw[end] === "\x07" ? end + 1 : end + 2;
+        continue;
       }
-      if (allowed && !allowed.includes(modelId)) {
-        return { ok: false, error: `Model "${modelId}" is excluded by the allowlist for runner "${runner}"` };
+      if (kind === "7") {
+        savedRow = row;
+        savedCol = col;
+      } else if (kind === "8") {
+        row = savedRow;
+        col = savedCol;
+      } else if (kind === "c") {
+        rows.clear();
+        row = 1;
+        col = 1;
       }
+      i += kind === "(" || kind === ")" ? 3 : 2;
+      continue;
     }
-  }
-  if (taskMode !== void 0) {
-    const modes = catalog.runnerModes[runner];
-    if (modes && modes.length > 0 && !modes.some((m) => m.id === taskMode)) {
-      return { ok: false, error: `Runner "${runner}" has no task mode "${taskMode}" \u2014 valid modes: ${modes.map((m) => m.id).join(", ")}` };
+    if (ch === "\r") {
+      col = 1;
+      i++;
+      continue;
     }
-  }
-  return { ok: true };
-}
-function typeCoherenceCheck(target, changes) {
-  if (!changes.type || changes.type === target.type) return null;
-  if (changes.type === "user") {
-    if (!Array.isArray(changes.userSteps) || changes.userSteps.length === 0) {
-      return { ok: false, error: `"${target.title}" cannot become a manual task without user steps \u2014 include "userSteps" in this edit` };
+    if (ch === "\n") {
+      row++;
+      i++;
+      continue;
     }
-    return { ok: true, clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0) };
-  }
-  if (!changes.prompt || !changes.prompt.trim()) {
-    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt \u2014 include "prompt" in this edit` };
+    if (ch === "\b") {
+      col = Math.max(1, col - 1);
+      i++;
+      continue;
+    }
+    if (ch === "	") {
+      col += 8 - (col - 1) % 8;
+      i++;
+      continue;
+    }
+    if (ch < " " || ch === "\x7F") {
+      i++;
+      continue;
+    }
+    cells(row)[col - 1] = ch;
+    col++;
+    i++;
   }
-  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
+  const populated = [...rows.keys()].sort((a, b) => a - b);
+  return populated.map((r) => cells(r).join("")).join("\n");
 }
-function validateTaskEdit(actor, tasks, taskId, changes, catalog) {
-  const target = tasks.find((t) => t.id === taskId);
-  if (!target) return { ok: false, error: "Task not found" };
-  if (actor === "planner") {
-    if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be modified` };
-    if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be modified` };
-  }
-  if (changes.dependencies) {
-    const depCheck = canSetDependencies(tasks, taskId, changes.dependencies);
-    if (!depCheck.ok) return depCheck;
+function renderCleanCapture(raw, doneToken) {
+  const rendered = renderTerminalOutput(raw).replace(/[\s─-▟]+$/gm, "");
+  if (!doneToken) return rendered.trim();
+  const lines = rendered.split("\n");
+  const flat = (s) => flattenTerminalOutput(s);
+  for (let i = 0; i < lines.length; i++) {
+    const own = flat(lines[i]).includes(doneToken);
+    if (own) return lines.slice(0, i).join("\n").trim();
+    const window = flat(lines[i]) + (i + 1 < lines.length ? flat(lines[i + 1]) : "");
+    if (window.includes(doneToken)) return lines.slice(0, i + 1).join("\n").trim();
   }
-  const coherence = typeCoherenceCheck(target, changes);
-  if (coherence && !coherence.ok) return coherence;
-  const runner = changes.assignedRunner ?? target.assignedRunner;
-  const validity = checkModelAndModeValidity(runner, changes.assignedModel, changes.taskMode, catalog);
-  if (!validity.ok) return validity;
-  return coherence ?? { ok: true };
+  return rendered.trim();
 }
 
-// src/services/TaskOps.ts
-var UPDATABLE_FIELDS = [
-  "title",
-  "description",
-  "prompt",
-  "dependencies",
-  "assignedRunner",
-  "assignedModel",
-  "taskMode",
-  "thinkingEffort",
-  "type",
-  "userSteps",
-  "autonomy",
-  "sliceType"
-];
-function taskOpsProtocol(executionNote = "") {
-  const updateChanges = UPDATABLE_FIELDS.map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
-  return [
-    "- To modify specific tasks, reply with ONLY this JSON object:",
-    '  {"taskOps": [',
-    `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
-    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?},"handle"?:"<name>"},',
-    '    {"op":"remove","taskId":"<id or #order>"},',
-    '    {"op":"reorder","taskIds":["<id or #order>", "... every task exactly once"]},   // only to re-prioritise INDEPENDENT tasks',
-    '    {"op":"merge","taskIds":["<id or #order>", "..."],"merged":{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...},"handle"?:"<name>"},',
-    '    {"op":"split","taskId":"<id or #order>","parts":[{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...}, ...],"handle"?:"<name>"},',
-    `    {"op":"rearm","taskId":"<id or #order>","changes"?:{${updateChanges}}}`,
-    "  ]}",
-    '- For sweeping changes, you may instead emit a full {"tasks":[...]} plan JSON.',
-    'Every "<id or #order>" ref in a batch resolves against the plan shown above, before any op in the batch runs \u2014 an earlier remove/merge/split never shifts what a later "#N" means.',
-    'Give "add", "merge", or "split" a "handle" (any name you choose, unused elsewhere in this batch) to let a LATER op in the same batch reference the task it produces \u2014 for "split", the handle names its last part. A handle used before its defining op is rejected.',
-    'When creating or changing tasks, set "assignedRunner" and "assignedModel" ({"modelId","modelLabel","thinkingEffort"?}) using only the runners and models listed in <available_models>.',
-    'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
-    'Just declare the dependencies you want \u2014 display order is repaired for you afterwards, so a rewire or a newly added prerequisite never needs a "reorder" op. Only a task that is running or completed cannot be shifted, so an edit that would need one to move is rejected.' + executionNote,
-    'Flipping "type" between "ai" and "user" is a content change, not just a label: an update to "user" needs "userSteps" in the SAME op, and an update to "ai" needs "prompt" in the SAME op \u2014 the model/mode/effort/autonomy fields (flipping to "user") or the userSteps (flipping to "ai") are cleared automatically.',
-    '"rearm" puts a failed OR completed task back to pending \u2014 verdict and output summary are cleared, any dependents it had blocked are released, and it may carry field changes (e.g. a corrected "prompt") applied in the same op. A running task cannot be re-armed. Never rearm a task just to relabel it \u2014 only when it should actually run again.'
-  ];
+// src/conversation/format.ts
+var DISPLAY_NAMES = {
+  read_file: "Read",
+  read_files: "Read",
+  list_dir: "List",
+  glob: "Glob",
+  grep: "Grep",
+  find_symbol: "Symbol",
+  bash: "Bash",
+  fetch: "Fetch",
+  web_search: "WebSearch",
+  spawn_research_agent: "Agent"
+};
+var HINT_FIELDS = ["file_path", "filePath", "path", "url", "pattern", "query", "command", "description", "prompt"];
+function parseArgs(args) {
+  try {
+    const parsed = JSON.parse(args);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
 }
-function textHasTaskOps(text2) {
-  return text2.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
+function oneLine(text2) {
+  return text2.replace(/\s+/g, " ").trim();
 }
-function parseTaskOpsJson(text2) {
-  const { matches, fallback } = extractObjectsWithKey(text2, TASK_OPS_ENVELOPE_KEY);
-  const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];
-  let lastError = null;
-  for (const json of candidates) {
-    try {
-      return parseTaskOpsObject(json, text2);
-    } catch (err) {
-      if (!(err instanceof PlanParseError)) throw err;
-      if (!lastError) lastError = err;
-    }
-  }
-  throw lastError ?? new PlanParseError("No JSON object found in task-ops reply", text2);
+function firstLineOf(command) {
+  const lines = command.trim().split(/\r?\n/);
+  const more = lines.length - 1;
+  return more > 0 ? `${lines[0]} \u2026 +${more} line${more === 1 ? "" : "s"}` : lines[0];
 }
-function parseTaskOpsObject(json, text2) {
-  let parsed;
-  try {
-    parsed = JSON.parse(escapeControlCharsInStrings(stripTrailingCommas(json)));
-  } catch (err) {
-    throw new PlanParseError(`Task-ops JSON is invalid: ${err instanceof Error ? err.message : String(err)}`, text2);
-  }
-  const ops = parsed.taskOps;
-  if (!Array.isArray(ops) || ops.length === 0) {
-    throw new PlanParseError('"taskOps" must be a non-empty array', text2);
-  }
-  for (const op of ops) {
-    if (typeof op !== "object" || op === null || typeof op.op !== "string") {
-      throw new PlanParseError('Every task op needs an "op" field (update | add | remove | reorder | merge | split)', text2);
-    }
-  }
-  return ops;
+function text(value) {
+  return typeof value === "string" ? value : "";
 }
-function resolveRef(ref, originalScope, liveScope, handleOwner, handleId, opIndex) {
-  if (typeof ref !== "string" && typeof ref !== "number") return { error: `invalid reference "${String(ref)}"` };
-  const s = String(ref).trim();
-  const ownerIdx = handleOwner.get(s);
-  if (ownerIdx !== void 0) {
-    if (ownerIdx >= opIndex) {
-      return { error: `handle "${s}" is defined later in this batch (op ${ownerIdx + 1}) and cannot be referenced yet` };
-    }
-    const id = handleId.get(s);
-    if (!id) return { error: `handle "${s}" was never resolved` };
-    return { id };
-  }
-  const byLiveId = liveScope.find((t) => t.id === s);
-  if (byLiveId) return { id: byLiveId.id };
-  const orderStr = s.startsWith("#") ? s.slice(1) : s;
-  if (/^\d+$/.test(orderStr)) {
-    const order = Number(orderStr);
-    const byOrder = originalScope.filter((t) => t.order === order);
-    if (byOrder.length === 1) return { id: byOrder[0].id };
+function searchArg(pattern, path, include = "") {
+  return `${pattern}${path ? ` in ${path}` : ""}${include ? ` (${include})` : ""}`;
+}
+function hintArg(args) {
+  for (const field of HINT_FIELDS) {
+    const value = text(args[field]);
+    if (value) return field === "command" ? firstLineOf(value) : oneLine(value);
   }
-  const byTitle = originalScope.find((t) => t.title === s);
-  if (byTitle) return { id: byTitle.id };
-  return { error: `task "${s}" not found` };
+  const firstText = Object.values(args).find((v) => typeof v === "string" && v.trim() !== "");
+  return firstText ? oneLine(firstText) : "";
 }
-function taskOpRefs(op) {
-  switch (op.op) {
-    case "update":
-    case "remove":
-    case "split":
-    case "rearm":
-      return [op.taskId];
-    case "merge":
-    case "reorder":
-      return op.taskIds;
-    case "add":
-      return [];
+function keyArgOf(tool, args) {
+  switch (tool) {
+    case "bash":
+      return firstLineOf(text(args.command));
+    case "read_file":
+    case "list_dir":
+      return text(args.path);
+    case "read_files":
+      return Array.isArray(args.paths) ? args.paths.map(String).join(", ") : "";
+    case "glob":
+      return searchArg(text(args.pattern), text(args.path));
+    case "grep":
+      return searchArg(text(args.pattern), text(args.path), text(args.include));
+    case "find_symbol":
+      return `${text(args.symbol)}${text(args.language) ? ` [${text(args.language)}]` : ""}`;
+    case "fetch":
+      return text(args.url);
+    case "web_search":
+      return oneLine(text(args.query));
+    case "spawn_research_agent":
+      return oneLine(text(args.prompt));
+    default:
+      return hintArg(args);
   }
 }
-function refMatchesTask(ref, task) {
-  if (typeof ref !== "string" && typeof ref !== "number") return false;
-  const s = String(ref).trim();
-  if (task.id === s) return true;
-  const orderStr = s.startsWith("#") ? s.slice(1) : s;
-  return /^\d+$/.test(orderStr) && task.order === Number(orderStr) || task.title === s;
+function toolHeadline(tool, args, toolLabel) {
+  const name = toolLabel?.trim() || DISPLAY_NAMES[tool] || tool;
+  const parsed = parseArgs(args);
+  return { name, keyArg: parsed ? keyArgOf(tool, parsed) : oneLine(args) };
 }
-function refCollidesWithExisting(name, originalFlatAll) {
-  if (originalFlatAll.some((t) => t.id === name)) return true;
-  const orderStr = name.startsWith("#") ? name.slice(1) : name;
-  if (/^\d+$/.test(orderStr) && originalFlatAll.some((t) => t.order === Number(orderStr))) return true;
-  return originalFlatAll.some((t) => t.title === name);
+function outputLines(output) {
+  const lines = output.replace(/\r\n?/g, "\n").replace(ANSI_OR_CTRL_RE, "").split("\n");
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+  return lines;
 }
-function findInTasks(tasks, id) {
-  return flattenTasks(tasks).find((t) => t.id === id);
+function outputPreview(output, maxLines) {
+  const lines = outputLines(output);
+  const shown = lines.slice(0, Math.max(0, maxLines));
+  return { lines: shown, hiddenLineCount: lines.length - shown.length };
 }
-function findTopLevel(tasks, id) {
-  return tasks.find((t) => t.id === id);
+
+// src/conversation/records.ts
+function settledMessage(id, role, text2, turnId) {
+  return { type: "message", id, role, text: text2, streaming: false, ...turnId ? { turnId } : {} };
 }
-function detectCycle(tasks) {
-  const byId = new Map(tasks.map((t) => [t.id, t]));
-  const visiting = /* @__PURE__ */ new Set();
-  const done = /* @__PURE__ */ new Set();
-  const visit = (id) => {
-    if (done.has(id)) return null;
-    if (visiting.has(id)) return id;
-    visiting.add(id);
-    for (const dep of byId.get(id)?.dependencies ?? []) {
-      const hit = visit(dep);
-      if (hit) return hit;
-    }
-    visiting.delete(id);
-    done.add(id);
-    return null;
+function subagentBlock(id, { toolCallId, model, usage, turnId, ...fields }) {
+  return {
+    type: "subagent",
+    id,
+    ...fields,
+    ...toolCallId ? { toolCallId } : {},
+    ...model ? { model } : {},
+    ...usage ? { usage } : {},
+    ...turnId ? { turnId } : {}
   };
-  for (const t of tasks) {
-    const hit = visit(t.id);
-    if (hit) return byId.get(hit)?.title ?? hit;
-  }
-  return null;
 }
-function isPinned(t) {
-  return t.status === "in_progress" || t.status === "completed";
+function usageBlock(id, { totals, bySubagent, contextFill }) {
+  return { type: "usage", id, totals, ...bySubagent ? { bySubagent } : {}, ...contextFill ? { contextFill } : {} };
 }
-function repairOrder(tasks) {
-  const byId = new Map(tasks.map((t) => [t.id, t]));
-  const placed = /* @__PURE__ */ new Set();
-  const movable = tasks.filter((t) => !isPinned(t));
-  const result = [];
-  const blockerOf = (t) => {
-    const id = t.dependencies.find((d) => byId.has(d) && !placed.has(d));
-    return id ? byId.get(id) : void 0;
-  };
-  const place = (t) => {
-    result.push(t);
-    placed.add(t.id);
+var STATUS_OF_OUTCOME = {
+  success: "ok",
+  failure: "error",
+  refused: "denied",
+  denied: "denied",
+  not_executed: "interrupted"
+};
+function finishedTool(call, output, outcome) {
+  return { ...call, status: STATUS_OF_OUTCOME[outcome], outcome, output, outputLineCount: outputLines(output).length };
+}
+function settledTool(call, step) {
+  return finishedTool(call, step.result, step.outcome);
+}
+function pendingTool(id, { tool, toolLabel, args, toolCallId, turnId }) {
+  return {
+    type: "tool",
+    id,
+    tool,
+    headline: toolHeadline(tool, args, toolLabel),
+    args,
+    status: "pending",
+    output: "",
+    outputLineCount: 0,
+    ...toolCallId ? { toolCallId } : {},
+    ...toolLabel ? { toolLabel } : {},
+    ...turnId ? { turnId } : {}
   };
-  for (const occupant of tasks) {
-    if (isPinned(occupant)) {
-      const blocker = blockerOf(occupant);
-      if (blocker) return { error: pinnedRefusal(blocker, occupant, "before") };
-      place(occupant);
-      continue;
-    }
-    const next = movable.findIndex((t) => !blockerOf(t));
-    if (next < 0) {
-      const [stuck, pin] = trailToPin(movable[0], blockerOf);
-      return { error: pinnedRefusal(stuck, pin, "after") };
-    }
-    place(movable.splice(next, 1)[0]);
+}
+function toolFromStep(id, step, turnId) {
+  return settledTool(pendingTool(id, { ...step, turnId }), step);
+}
+function planMarker(content) {
+  const count = /(\d+) tasks?\b/.exec(content);
+  return { status: content.startsWith("Plan updated") ? "updated" : "generated", ...count ? { taskCount: Number(count[1]) } : {} };
+}
+
+// src/conversation/lanes.ts
+function findLastIndex(items, match) {
+  for (let i = items.length - 1; i >= 0; i--) if (match(items[i])) return i;
+  return -1;
+}
+function replaceAt(items, index, item) {
+  const next = items.slice();
+  next[index] = item;
+  return next;
+}
+function insertTop(blocks, block) {
+  const last = blocks[blocks.length - 1];
+  return last?.type === "usage" ? [...blocks.slice(0, -1), block, last] : [...blocks, block];
+}
+function append(view, make) {
+  return { ...view, blocks: insertTop(view.blocks, make(`b${view.nextId}`)), nextId: view.nextId + 1 };
+}
+function subagentAt(view, lane) {
+  const block = view.blocks[lane];
+  if (block.type !== "subagent") throw new Error(`block ${lane} is not a subagent`);
+  return block;
+}
+function laneBlocks(view, lane) {
+  return lane === null ? view.blocks : subagentAt(view, lane).children;
+}
+function setChildren(view, lane, children) {
+  return { ...view, blocks: replaceAt(view.blocks, lane, { ...subagentAt(view, lane), children }) };
+}
+function laneReplace(view, lane, index, block) {
+  if (lane === null) return { ...view, blocks: replaceAt(view.blocks, index, block) };
+  return setChildren(view, lane, replaceAt(subagentAt(view, lane).children, index, block));
+}
+function laneAppend(view, lane, make) {
+  if (lane === null) return append(view, make);
+  const children = [...subagentAt(view, lane).children, make(`b${view.nextId}`)];
+  return { ...setChildren(view, lane, children), nextId: view.nextId + 1 };
+}
+function isStreaming(block) {
+  return (block.type === "message" || block.type === "thinking") && block.streaming;
+}
+function sealed(block) {
+  return isStreaming(block) ? { ...block, streaming: false } : block;
+}
+function sealLane(view, lane, keep) {
+  const blocks = laneBlocks(view, lane);
+  if (!blocks.some((b, i) => i !== keep && isStreaming(b))) return view;
+  if (lane === null) return { ...view, blocks: view.blocks.map((b, i) => i === keep ? b : sealed(b)) };
+  return setChildren(view, lane, subagentAt(view, lane).children.map((b, i) => i === keep ? b : sealed(b)));
+}
+function appendOutput(view, lane, make) {
+  const next = laneAppend(view, lane, make);
+  return sealLane(next, lane, findLastIndex(laneBlocks(next, lane), (b) => b.type !== "usage"));
+}
+function subagentLane(view, subagentId, turnId) {
+  const existing = findLastIndex(view.blocks, (b) => b.type === "subagent" && b.subagentId === subagentId);
+  if (existing >= 0) return [view, existing];
+  const spawn = findLastIndex(view.blocks, (b) => b.type === "tool" && (b.spawns === subagentId || b.toolCallId === subagentId));
+  const call = view.blocks[spawn];
+  if (call?.type === "tool") {
+    const block = subagentBlock(call.id, {
+      subagentId,
+      brief: call.headline.keyArg,
+      status: "running",
+      children: [],
+      digest: "",
+      toolCallId: call.toolCallId,
+      turnId: call.turnId
+    });
+    return [{ ...view, blocks: replaceAt(view.blocks, spawn, block) }, spawn];
   }
-  return { tasks: result };
+  const next = append(view, (id) => subagentBlock(id, { subagentId, brief: "", status: "running", children: [], digest: "", turnId }));
+  return [next, findLastIndex(next.blocks, (b) => b.type === "subagent" && b.subagentId === subagentId)];
 }
-function trailToPin(task, blockerOf) {
-  let at = task;
-  for (; ; ) {
-    const blocker = blockerOf(at);
-    if (!blocker || isPinned(blocker)) return [at, blocker ?? at];
-    at = blocker;
+function updateSubagent(view, subagentId, turnId, update) {
+  const [next, lane] = subagentLane(view, subagentId, turnId);
+  return { ...next, blocks: replaceAt(next.blocks, lane, update(subagentAt(next, lane))) };
+}
+function laneOf(view, subagentId, turnId) {
+  return subagentId ? subagentLane(view, subagentId, turnId) : [view, null];
+}
+function think(view, text2, turnId, segmentId, subagentId) {
+  const [placed, lane] = laneOf(view, subagentId, turnId);
+  const blocks = laneBlocks(placed, lane);
+  const lastIndex = findLastIndex(blocks, (b) => b.type !== "usage");
+  const last = blocks[lastIndex];
+  if (last?.type === "thinking" && last.streaming && last.segmentId === segmentId) {
+    return laneReplace(placed, lane, lastIndex, { ...last, text: last.text + text2 });
   }
+  return appendOutput(placed, lane, (id) => ({
+    type: "thinking",
+    id,
+    text: text2,
+    streaming: true,
+    ...turnId ? { turnId } : {},
+    ...segmentId ? { segmentId } : {},
+    ...subagentId ? { subagentId } : {}
+  }));
 }
-function describeMoves(before, after) {
-  const wasAt = new Map(before.map((t, i) => [t.id, i + 1]));
-  const moved = after.map((t, i) => ({ t, from: wasAt.get(t.id), to: i + 1 })).filter((m) => m.from !== m.to);
-  return moved.length ? moved.map((m) => `"${m.t.title}" #${m.from}\u2192#${m.to}`).join(", ") : null;
+function setUsageLine(view, line) {
+  const last = view.blocks[view.blocks.length - 1];
+  const block = usageBlock(last?.type === "usage" ? last.id : `b${view.nextId}`, line);
+  if (last?.type === "usage") return { ...view, blocks: replaceAt(view.blocks, view.blocks.length - 1, block) };
+  return { ...view, blocks: [...view.blocks, block], nextId: view.nextId + 1 };
 }
-function pinnedRefusal(other, pin, side) {
-  const word = pin.status === "in_progress" ? "running" : "completed";
-  return `"${other.title}" would have to run ${side} "${pin.title}", which is ${word} and cannot be moved`;
+function closeBlock(block, interrupted) {
+  return interrupted && block.type === "tool" && block.status === "pending" ? { ...block, status: "interrupted" } : sealed(block);
 }
-function canMergeTasks(tasks, selectedIds) {
-  if (selectedIds.length < 2) return { ok: false, error: "Select at least two tasks to merge" };
-  const idSet = new Set(selectedIds);
-  const toMerge = tasks.filter((t) => idSet.has(t.id));
-  if (toMerge.length < 2) return { ok: false, error: "At least two valid tasks are required to merge" };
-  for (const t of toMerge) {
-    if (t.status === "in_progress") return { ok: false, error: `"${t.title}" is running and cannot be merged` };
-    if (t.status === "completed") return { ok: false, error: `"${t.title}" is completed and cannot be merged` };
+function closeSubagent(block, cut) {
+  const children = block.children.map((c) => closeBlock(c, cut !== null));
+  const status = cut && block.status === "running" ? cut : block.status;
+  return status === block.status && children.every((c, i) => c === block.children[i]) ? block : { ...block, status, children };
+}
+function closeOpenBlocks(view, cut) {
+  const blocks = view.blocks.map((b) => b.type === "subagent" ? closeSubagent(b, cut) : closeBlock(b, cut !== null));
+  return blocks.every((b, i) => b === view.blocks[i]) ? view : { ...view, blocks };
+}
+
+// src/conversation/taskLog.ts
+var EMPTY_TASK_LOG = { blocks: [], nextId: 1, queued: [], working: false, streams: {} };
+var TEXT_STREAM = "text";
+var thinkingStream = (subagentId) => `thinking:${subagentId ?? ""}`;
+function withoutStream(view, key) {
+  if (!(key in view.streams)) return view;
+  return { ...view, streams: Object.fromEntries(Object.entries(view.streams).filter(([k]) => k !== key)) };
+}
+function blockText(text2) {
+  return text2.replace(/^\n+/, "");
+}
+function openStream(view, lane, key) {
+  const id = view.streams[key];
+  if (id === void 0) return -1;
+  const blocks = laneBlocks(view, lane);
+  const i = findLastIndex(blocks, (b) => b.type !== "usage");
+  const block = blocks[i];
+  return block?.id === id && (block.type === "message" || block.type === "thinking") && block.streaming ? i : -1;
+}
+function streamDelta(view, lane, key, text2, make) {
+  const i = openStream(view, lane, key);
+  const open = laneBlocks(view, lane)[i];
+  if (open?.type === "message" || open?.type === "thinking") return laneReplace(view, lane, i, { ...open, text: open.text + text2 });
+  const next = appendOutput(view, lane, (id) => make(id, blockText(text2)));
+  return { ...next, streams: { ...next.streams, [key]: `b${view.nextId}` } };
+}
+function streamWhole(view, lane, key, text2, make) {
+  const id = view.streams[key];
+  const blocks = laneBlocks(view, lane);
+  const i = id === void 0 ? -1 : findLastIndex(blocks, (b) => b.id === id);
+  const streamed = blocks[i];
+  const next = withoutStream(view, key);
+  if (streamed?.type === "message" || streamed?.type === "thinking") {
+    return laneReplace(next, lane, i, { ...streamed, text: blockText(text2), streaming: false });
   }
-  const ordered = [...toMerge].sort((a, b) => a.order - b.order);
-  const survivorId = "__merge_sim__";
-  const sim = tasks.filter((t) => !idSet.has(t.id)).map((t) => ({ ...t, dependencies: t.dependencies.map((d) => idSet.has(d) ? survivorId : d).filter((d) => d !== t.id) }));
-  const unionDeps = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
-  sim.push({ ...ordered[0], id: survivorId, title: "__merge_sim__", order: ordered[0].order, dependencies: unionDeps });
-  const cycle = detectCycle(sim);
-  if (cycle) return { ok: false, error: `Merging would create a dependency cycle involving "${cycle}"` };
-  return { ok: true };
+  return appendOutput(next, lane, make);
 }
-function dependentsOf(tasks, taskId) {
-  return tasks.filter((t) => t.id !== taskId && t.dependencies.includes(taskId));
+function agentText(view, text2) {
+  return streamWhole(view, null, TEXT_STREAM, text2, (id) => settledMessage(id, "agent", blockText(text2)));
 }
-function dependencyCandidates(tasks, taskId) {
-  if (!taskId) return [...tasks];
-  const target = tasks.find((t) => t.id === taskId);
-  return target ? tasks.filter((t) => t.order < target.order) : [];
+function agentTextDelta(view, text2) {
+  return streamDelta(view, null, TEXT_STREAM, text2, (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true }));
 }
-function canSetDependencies(tasks, taskId, dependencies) {
-  const target = tasks.find((t) => t.id === taskId);
-  if (!target) return { ok: false, error: "Task not found" };
-  const allowed = new Set(dependencyCandidates(tasks, taskId).map((t) => t.id));
-  for (const dep of dependencies) {
-    if (dep === taskId) return { ok: false, error: `"${target.title}" cannot depend on itself` };
-    const found = tasks.find((t) => t.id === dep);
-    if (!found) return { ok: false, error: `Unknown dependency "${dep}"` };
-    if (!allowed.has(dep)) {
-      return { ok: false, error: `"${target.title}" cannot depend on "${found.title}", which comes after it in the plan` };
-    }
+function thinkingBlock(id, text2, streaming, subagentId) {
+  return { type: "thinking", id, text: text2, streaming, ...subagentId ? { subagentId } : {} };
+}
+function thinkingDelta(view, { text: text2, subagentId }) {
+  const [placed, lane] = laneOf(view, subagentId);
+  return streamDelta(placed, lane, thinkingStream(subagentId), text2, (id, t) => thinkingBlock(id, t, true, subagentId));
+}
+function thinkingWhole(view, { text: text2, subagentId }) {
+  const [placed, lane] = laneOf(view, subagentId);
+  return streamWhole(placed, lane, thinkingStream(subagentId), text2, (id) => thinkingBlock(id, blockText(text2), false, subagentId));
+}
+function announceTool(view, { id: toolCallId, name, args, subagentId }) {
+  const { tool, toolLabel } = mapAgentTool(name);
+  const [placed, lane] = laneOf(view, subagentId);
+  return appendOutput(placed, lane, (id) => {
+    const call = pendingTool(id, { tool, toolLabel, args, toolCallId });
+    const parsed = parseArgs2(args);
+    return parsed ? { ...call, headline: toolHeadline(tool, JSON.stringify(normalizeAgentArgs(tool, parsed)), toolLabel) } : call;
+  });
+}
+function parseArgs2(args) {
+  try {
+    const parsed = JSON.parse(args);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
   }
-  return { ok: true };
 }
-function canSplitTask(tasks, taskId) {
-  const target = tasks.find((t) => t.id === taskId);
-  if (!target) return { ok: false, error: "Task not found" };
-  if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be split` };
-  if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be split` };
-  return { ok: true };
+function settleTool(view, { id: toolCallId, output, success, subagentId }) {
+  const [placed, lane] = laneOf(view, subagentId);
+  const blocks = laneBlocks(placed, lane);
+  const i = findLastIndex(blocks, (b) => b.type === "tool" && b.status === "pending" && b.toolCallId === toolCallId);
+  const pending = blocks[i];
+  const outcome = success ? "success" : "failure";
+  if (pending?.type === "tool") return laneReplace(placed, lane, i, finishedTool(pending, output, outcome));
+  if (lane === null && blocks.some((b) => b.type === "subagent" && b.toolCallId === toolCallId)) return view;
+  return laneAppend(placed, lane, (id) => finishedTool(pendingTool(id, { tool: "agent_tool", toolLabel: "Tool", args: "", toolCallId }), output, outcome));
 }
-function applyTaskOps(currentTasks, ops, runners, catalog) {
-  let tasks = JSON.parse(JSON.stringify(currentTasks));
-  const errors = [];
-  const summary = [];
-  const originalFlatAll = flattenTasks(currentTasks);
-  const handleOwner = /* @__PURE__ */ new Map();
-  const handleId = /* @__PURE__ */ new Map();
-  for (const [i, op] of ops.entries()) {
-    const handle = op.handle;
-    if (handle === void 0) continue;
-    if (typeof handle !== "string" || !handle.trim()) {
-      errors.push(`op ${i + 1} (${op.op}): handle must be a non-empty string`);
-      continue;
-    }
-    if (handleOwner.has(handle)) {
-      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" is already used earlier in this batch`);
-      continue;
-    }
-    if (refCollidesWithExisting(handle, originalFlatAll)) {
-      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" collides with an existing task reference`);
+function startSubagent(view, { subagentId, brief, model }) {
+  return updateSubagent(view, subagentId, void 0, (block) => ({ ...block, ...brief ? { brief } : {}, ...model ? { model } : {} }));
+}
+function finishSubagent(view, { subagentId, outcome, digest }) {
+  const usage = view.usage?.bySubagent?.[subagentId];
+  const next = updateSubagent(view, subagentId, void 0, (block) => ({
+    ...block,
+    status: outcome,
+    digest,
+    children: block.children.map(sealed),
+    ...usage ? { usage } : {}
+  }));
+  return withoutStream(next, thinkingStream(subagentId));
+}
+function reportUsage(view, { record }) {
+  const usage = addPlannerUsage(view.usage ?? { totals: {} }, record);
+  const next = { ...view, usage };
+  return isMeasured(usage.totals) ? setUsageLine(next, usageLine(usage)) : next;
+}
+function runnerToolSubject(tool, args) {
+  const { tool: mapped, toolLabel } = mapAgentTool(tool);
+  const parsed = parseArgs2(args);
+  const headline = toolHeadline(mapped, parsed ? JSON.stringify(normalizeAgentArgs(mapped, parsed)) : args, toolLabel);
+  return headline.keyArg ? `${headline.name}(${headline.keyArg})` : headline.name;
+}
+function requestApproval(view, { approvalId, tool, args, allowForTask, toolCallId }) {
+  if (view.blocks.some((b) => b.type === "approval" && b.approvalId === approvalId)) return view;
+  return append(view, (id) => ({
+    type: "approval",
+    id,
+    approvalId,
+    kind: "runner_tool",
+    subject: runnerToolSubject(tool, args),
+    scope: tool,
+    status: "pending",
+    ...allowForTask ? { allowForTask } : {},
+    ...toolCallId ? { toolCallId } : {}
+  }));
+}
+function settleApproval(view, approvalId, settle) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "approval" && b.approvalId === approvalId);
+  const block = view.blocks[i];
+  if (block?.type !== "approval" || block.status !== "pending") return view;
+  return { ...view, blocks: replaceAt(view.blocks, i, settle(block)) };
+}
+function decideApproval(view, { approvalId, decision, note }) {
+  return settleApproval(view, approvalId, (block) => ({
+    ...block,
+    status: decision === "deny" ? "denied" : "granted",
+    decidedBy: "asked",
+    ...decision === "allowForTask" ? { forTask: true } : {},
+    ...note ? { note } : {}
+  }));
+}
+function startTurn(view, { message, messageId }) {
+  const queued = messageId ? view.queued.filter((m) => m.id !== messageId) : view.queued;
+  return append({ ...view, queued, working: true }, (id) => settledMessage(id, "user", message));
+}
+var CUT = { completed: null, interrupted: "stopped", failed: "failed" };
+function endTurn(view, { reason }) {
+  const closed = closeOpenBlocks({ ...view, working: false, lastTurnEnd: reason, streams: {} }, CUT[reason]);
+  return reason === "interrupted" ? append(closed, (id) => settledMessage(id, "system", "Interrupted.")) : closed;
+}
+function queueMessage(view, { messageId, text: text2 }) {
+  if (view.queued.some((m) => m.id === messageId)) return view;
+  return { ...view, queued: [...view.queued, { id: messageId, text: text2 }] };
+}
+function unqueueMessage(view, { messageId }) {
+  const queued = view.queued.filter((m) => m.id !== messageId);
+  return queued.length === view.queued.length ? view : { ...view, queued };
+}
+function reduceTaskLog(view, event) {
+  switch (event.type) {
+    case "turn_start":
+      return startTurn(view, event);
+    case "turn_end":
+      return endTurn(view, event);
+    case "text_delta":
+      return agentTextDelta(view, event.text);
+    case "text":
+      return agentText(view, event.text);
+    case "thinking_delta":
+      return thinkingDelta(view, event);
+    case "thinking":
+      return thinkingWhole(view, event);
+    case "tool_call":
+      return announceTool(view, event);
+    case "tool_result":
+      return settleTool(view, event);
+    case "subagent_started":
+      return startSubagent(view, event);
+    case "subagent_finished":
+      return finishSubagent(view, event);
+    case "usage":
+      return reportUsage(view, event);
+    case "message_queued":
+      return queueMessage(view, event);
+    case "message_removed":
+      return unqueueMessage(view, event);
+    case "error":
+      return appendOutput(view, null, (id) => settledMessage(id, "error", event.message));
+    case "approval_requested":
+      return requestApproval(view, event);
+    case "approval_decided":
+      return decideApproval(view, event);
+    case "approval_withdrawn":
+      return settleApproval(view, event.approvalId, (block) => ({ ...block, status: "withdrawn" }));
+    default:
+      return view;
+  }
+}
+function replayTaskLog(events, from = EMPTY_TASK_LOG) {
+  return events.reduce(reduceTaskLog, from);
+}
+
+// src/services/conflictFiles.ts
+function capConflictFiles(files, max = 5) {
+  return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
+}
+
+// src/services/ModelAllowlistResolver.ts
+function effectiveAllowlist(allowlist, runner, modelsByRunner) {
+  if (!allowlist || allowlist.length === 0) return void 0;
+  if (!modelsByRunner) return allowlist;
+  const own = new Set((modelsByRunner[runner] ?? []).map((m) => m.modelId));
+  const elsewhere = /* @__PURE__ */ new Set();
+  for (const [other, models] of Object.entries(modelsByRunner)) {
+    if (other === runner) continue;
+    for (const m of models ?? []) elsewhere.add(m.modelId);
+  }
+  const kept = allowlist.filter((id) => own.has(id) || !elsewhere.has(id));
+  return kept.length > 0 ? kept : void 0;
+}
+function filterModelsForPrompt(modelsByRunner, perRunnerAllowlist) {
+  const result = {};
+  for (const [runner, models] of Object.entries(modelsByRunner)) {
+    if (!models) continue;
+    const allowed = effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
+    if (!allowed) {
+      result[runner] = models;
       continue;
     }
-    handleOwner.set(handle, i);
+    const allowedSet = new Set(allowed);
+    const intersection = models.filter((m) => allowedSet.has(m.modelId));
+    const covered = new Set(intersection.map((m) => m.modelId));
+    const missing = allowed.filter((id) => !covered.has(id)).map((id) => ({ modelId: id, modelLabel: id.split("/").pop() || id, variants: [] }));
+    result[runner] = [...intersection, ...missing];
   }
-  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
-  const resolveDeps = (deps, opIndex) => {
-    const ids = [];
-    const bad = [];
-    const liveFlat = flattenTasks(tasks);
-    for (const d of Array.isArray(deps) ? deps : []) {
-      const r = resolveRef(d, originalFlatAll, liveFlat, handleOwner, handleId, opIndex);
-      if ("error" in r) {
-        bad.push(`${String(d)} (${r.error})`);
-        continue;
+  return result;
+}
+var EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+var EFFORT_ALIASES = { disabled: "none", adaptive: "medium" };
+function clampThinkingEffort(effort, variants) {
+  if (!effort) return void 0;
+  if (variants.length === 0) return void 0;
+  const ids = new Set(variants.map((v) => v.id));
+  if (ids.has(effort)) return effort;
+  const canon = EFFORT_ALIASES[effort] ?? effort;
+  if (ids.has(canon)) return canon;
+  const idx = EFFORT_LADDER.indexOf(canon);
+  if (idx < 0) return void 0;
+  for (let d = 1; d < EFFORT_LADDER.length; d++) {
+    const lower = EFFORT_LADDER[idx - d];
+    if (lower && ids.has(lower)) return lower;
+    const higher = EFFORT_LADDER[idx + d];
+    if (higher && ids.has(higher)) return higher;
+  }
+  return void 0;
+}
+function coerceAssignments(tasks, perRunnerAllowlist, allowedRunners, modelsByRunner) {
+  const clampVariant = (task) => {
+    if (!task.assignedModel || !modelsByRunner) return task;
+    const model = modelsByRunner[task.assignedRunner]?.find(
+      (m) => m.modelId === task.assignedModel.modelId
+    );
+    if (!model) return task;
+    const clamped = clampThinkingEffort(task.assignedModel.thinkingEffort, model.variants);
+    return {
+      ...task,
+      assignedModel: {
+        ...task.assignedModel,
+        thinkingEffort: clamped,
+        availableVariants: model.variants.map((v) => v.id)
       }
-      if (!liveFlat.some((t) => t.id === r.id)) {
-        bad.push(`${String(d)} (no longer exists in this batch)`);
-        continue;
+    };
+  };
+  const allowedFor = (runner) => effectiveAllowlist(perRunnerAllowlist[runner], runner, modelsByRunner);
+  const assignmentFor = (runner, modelId) => {
+    const known = modelsByRunner?.[runner]?.find((m) => m.modelId === modelId);
+    return {
+      modelId,
+      modelLabel: known?.modelLabel ?? modelId,
+      thinkingEffort: void 0,
+      ...known ? { availableVariants: known.variants.map((v) => v.id) } : {}
+    };
+  };
+  return tasks.map((task) => {
+    if (task.type === "user") return task;
+    if (allowedRunners && !allowedRunners.includes(task.assignedRunner)) {
+      const fallbackRunner = allowedRunners[0];
+      const fallbackModels = allowedFor(fallbackRunner);
+      const fallbackModel = fallbackModels?.length ? assignmentFor(fallbackRunner, fallbackModels[0]) : modelsByRunner?.[fallbackRunner]?.[0] ? assignmentFor(fallbackRunner, modelsByRunner[fallbackRunner][0].modelId) : task.assignedModel;
+      return clampVariant({
+        ...task,
+        assignedRunner: fallbackRunner,
+        assignedModel: fallbackModel
+      });
+    }
+    const allowlist = allowedFor(task.assignedRunner);
+    if (!task.assignedModel) {
+      if (allowlist && allowlist.length > 0) {
+        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) });
       }
-      ids.push(r.id);
+      const discovered = modelsByRunner?.[task.assignedRunner]?.[0];
+      if (discovered) {
+        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, discovered.modelId) });
+      }
+      return task;
     }
-    return { ids, bad };
-  };
-  for (const [i, op] of ops.entries()) {
-    const label = `op ${i + 1} (${op.op})`;
-    switch (op.op) {
-      case "update": {
-        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
-        if ("error" in ref) {
-          errors.push(`${label}: ${ref.error}`);
-          break;
-        }
-        const target = findInTasks(tasks, ref.id);
-        if (!target) {
-          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
-          break;
-        }
-        const changes = {};
-        for (const key of UPDATABLE_FIELDS) {
-          if (op.changes && key in op.changes) changes[key] = op.changes[key];
-        }
-        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
-          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
-          break;
-        }
-        const changesForCheck = { ...changes };
-        delete changesForCheck.dependencies;
-        const check = validateTaskEdit("planner", flattenTasks(tasks), target.id, changesForCheck, catalog);
-        if (!check.ok) {
-          errors.push(`${label}: ${check.error}`);
-          break;
-        }
-        for (const field of check.clear ?? []) changes[field] = void 0;
-        if ("dependencies" in changes) {
-          const { ids, bad } = resolveDeps(changes.dependencies, i);
-          if (bad.length) {
-            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
-            break;
-          }
-          changes.dependencies = ids.filter((id) => id !== target.id);
-        }
-        if (Object.keys(changes).length === 0) {
-          errors.push(`${label}: no valid changes provided`);
-          break;
-        }
-        tasks = updateTaskInPlan(tasks, target.id, changes);
-        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
-        summary.push(`Updated "${target.title}" (${Object.keys(changes).join(", ")})${clearedNote}`);
-        break;
+    if (!allowlist || allowlist.length === 0) return clampVariant(task);
+    if (allowlist.includes(task.assignedModel.modelId)) return clampVariant(task);
+    return { ...task, assignedModel: assignmentFor(task.assignedRunner, allowlist[0]) };
+  });
+}
+
+// src/services/TaskOps.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/services/TaskEditValidator.ts
+var AI_ONLY_FIELDS = ["assignedModel", "thinkingEffort", "taskMode", "autonomy"];
+function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
+  if (!catalog) return { ok: true };
+  if (assignedModel) {
+    const models = catalog.modelsByRunner[runner];
+    if (models) {
+      const modelId = assignedModel.modelId;
+      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
+      if (!models.some((m) => m.modelId === modelId) && !allowed?.includes(modelId)) {
+        return { ok: false, error: `Runner "${runner}" does not offer model "${modelId}"` };
       }
-      case "add": {
-        const spec = op.task ?? {};
-        if (!spec.title) {
-          errors.push(`${label}: new task needs a title`);
-          break;
-        }
-        const { ids, bad } = resolveDeps(spec.dependencies, i);
-        if (bad.length) {
-          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
-          break;
-        }
-        const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : runners[0];
-        const validity = checkModelAndModeValidity(runner, spec.assignedModel, spec.taskMode, catalog);
-        if (!validity.ok) {
-          errors.push(`${label}: ${validity.error}`);
-          break;
-        }
-        const newId = uuidv4();
-        tasks = addTaskToPlan(tasks, {
-          ...spec,
-          id: newId,
-          dependencies: ids,
-          assignedRunner: runner,
-          description: spec.description ?? spec.title,
-          prompt: spec.prompt ?? spec.description ?? spec.title
-        });
-        if (op.handle) handleId.set(op.handle, newId);
-        summary.push(`Added "${spec.title}"`);
-        break;
+      if (allowed && !allowed.includes(modelId)) {
+        return { ok: false, error: `Model "${modelId}" is excluded by the allowlist for runner "${runner}"` };
       }
-      case "remove": {
-        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
-        if ("error" in ref) {
-          errors.push(`${label}: ${ref.error}`);
-          break;
-        }
-        const target = findInTasks(tasks, ref.id);
-        if (!target) {
-          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
-          break;
-        }
-        if (target.status === "in_progress") {
-          errors.push(`${label}: "${target.title}" is running and cannot be removed`);
-          break;
-        }
-        if (target.status === "completed") {
-          errors.push(`${label}: "${target.title}" is completed and cannot be removed`);
-          break;
-        }
-        tasks = removeTaskFromPlan(tasks, target.id);
-        summary.push(`Removed "${target.title}"`);
-        break;
-      }
-      case "reorder": {
-        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
-        const badRef = refs.find((r) => "error" in r);
-        if (badRef) {
-          errors.push(`${label}: ${badRef.error}`);
-          break;
-        }
-        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
-        if (resolved.some((t) => !t)) {
-          errors.push(`${label}: unknown task in reorder list`);
-          break;
-        }
-        const orderIds = resolved.map((t) => t.id);
-        if (new Set(orderIds).size !== tasks.length) {
-          errors.push(`${label}: reorder must list every top-level task exactly once (${tasks.length} tasks)`);
-          break;
-        }
-        const byId = new Map(tasks.map((t) => [t.id, t]));
-        tasks = renumberTasks(orderIds.map((id) => byId.get(id)));
-        summary.push("Reordered tasks");
-        break;
-      }
-      case "merge": {
-        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
-        const badRef = refs.find((r) => "error" in r);
-        if (badRef) {
-          errors.push(`${label}: ${badRef.error}`);
-          break;
-        }
-        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
-        if (resolved.some((t) => !t)) {
-          errors.push(`${label}: unknown task in merge list (already removed, merged, or split by an earlier op)`);
-          break;
-        }
-        const toMerge = resolved.map((t) => t).sort((a, b) => a.order - b.order);
-        if (toMerge.length < 2) {
-          errors.push(`${label}: merge needs at least two tasks`);
-          break;
-        }
-        const locked = toMerge.find((t) => t.status === "in_progress" || t.status === "completed");
-        if (locked) {
-          errors.push(`${label}: "${locked.title}" is ${locked.status === "in_progress" ? "running" : "completed"} and cannot be merged`);
-          break;
-        }
-        const idSet = new Set(toMerge.map((t) => t.id));
-        const unionDepsRaw = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
-        const { ids, bad } = resolveDeps(unionDepsRaw, i);
-        if (bad.length) {
-          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
-          break;
-        }
-        const spec = op.merged ?? {};
-        if (!spec.title) {
-          errors.push(`${label}: merged task needs a title`);
-          break;
-        }
-        const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : toMerge[0].assignedRunner;
-        const mergedTask = createTask({
-          title: spec.title,
-          description: spec.description ?? toMerge.map((t) => t.description).filter(Boolean).join("\n\n"),
-          prompt: spec.prompt ?? (toMerge.map((t) => t.prompt).filter(Boolean).join("\n\n---\n\n") || void 0),
-          type: spec.type ?? (toMerge.some((t) => t.type === "user") ? "user" : "ai"),
-          dependencies: ids,
-          assignedRunner: runner,
-          assignedModel: spec.assignedModel ?? toMerge.find((t) => t.assignedModel)?.assignedModel,
-          thinkingEffort: spec.thinkingEffort ?? toMerge.find((t) => t.thinkingEffort)?.thinkingEffort,
-          taskMode: spec.taskMode ?? toMerge[0].taskMode,
-          autonomy: spec.autonomy ?? toMerge.find((t) => t.autonomy)?.autonomy,
-          sliceType: spec.sliceType ?? toMerge.find((t) => t.sliceType)?.sliceType,
-          userStoriesCovered: spec.userStoriesCovered ?? (toMerge.flatMap((t) => t.userStoriesCovered ?? []).length ? [...new Set(toMerge.flatMap((t) => t.userStoriesCovered ?? []))] : void 0)
-        });
-        const mergedId = mergedTask.id;
-        const firstId = toMerge[0].id;
-        const result = [];
-        let inserted = false;
-        for (const t of tasks) {
-          if (idSet.has(t.id)) {
-            if (!inserted && t.id === firstId) {
-              result.push(mergedTask);
-              inserted = true;
-            }
-            continue;
-          }
-          result.push({ ...t, dependencies: t.dependencies.map((d) => idSet.has(d) ? mergedId : d) });
-        }
-        if (!inserted) result.push(mergedTask);
-        tasks = renumberTasks(result);
-        if (op.handle) handleId.set(op.handle, mergedId);
-        summary.push(`Merged ${toMerge.length} tasks into "${spec.title}"`);
-        break;
-      }
-      case "split": {
-        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i);
-        if ("error" in ref) {
-          errors.push(`${label}: ${ref.error}`);
-          break;
-        }
-        const target = findTopLevel(tasks, ref.id);
-        if (!target) {
-          errors.push(`${label}: task "${op.taskId}" not found`);
-          break;
-        }
-        if (target.status === "in_progress") {
-          errors.push(`${label}: "${target.title}" is running and cannot be split`);
-          break;
-        }
-        if (target.status === "completed") {
-          errors.push(`${label}: "${target.title}" is completed and cannot be split`);
-          break;
-        }
-        const parts = op.parts ?? [];
-        if (parts.length < 2) {
-          errors.push(`${label}: split needs at least two parts`);
-          break;
-        }
-        const newTasks = [];
-        let prevId;
-        let buildError = false;
-        for (let p = 0; p < parts.length; p++) {
-          const spec = parts[p];
-          if (!spec || !spec.title) {
-            errors.push(`${label}: split part ${p + 1} needs a title`);
-            buildError = true;
-            break;
-          }
-          let deps;
-          if (p === 0) {
-            const { ids, bad } = resolveDeps(target.dependencies, i);
-            if (bad.length) {
-              errors.push(`${label}: split part 1 unknown dependencies: ${bad.join(", ")}`);
-              buildError = true;
-              break;
-            }
-            deps = ids;
-          } else {
-            deps = prevId ? [prevId] : [];
-          }
-          const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : target.assignedRunner;
-          const nt = createTask({
-            title: spec.title,
-            description: spec.description ?? spec.title,
-            prompt: spec.prompt ?? spec.description ?? spec.title,
-            type: spec.type ?? target.type,
-            dependencies: deps,
-            assignedRunner: runner,
-            assignedModel: spec.assignedModel ?? target.assignedModel,
-            taskMode: spec.taskMode ?? target.taskMode,
-            autonomy: spec.autonomy ?? target.autonomy,
-            sliceType: spec.sliceType ?? target.sliceType,
-            userStoriesCovered: spec.userStoriesCovered ?? target.userStoriesCovered
-          });
-          newTasks.push(nt);
-          prevId = nt.id;
-        }
-        if (buildError) break;
-        const tailId = newTasks[newTasks.length - 1].id;
-        const result = [];
-        for (const t of tasks) {
-          if (t.id === target.id) {
-            result.push(...newTasks);
-            continue;
-          }
-          result.push({ ...t, dependencies: t.dependencies.map((d) => d === target.id ? tailId : d) });
-        }
-        tasks = renumberTasks(result);
-        if (op.handle) handleId.set(op.handle, tailId);
-        summary.push(`Split "${target.title}" into ${newTasks.length} tasks`);
-        break;
+    }
+  }
+  if (taskMode !== void 0) {
+    const modes = catalog.runnerModes[runner];
+    if (modes && modes.length > 0 && !modes.some((m) => m.id === taskMode)) {
+      return { ok: false, error: `Runner "${runner}" has no task mode "${taskMode}" \u2014 valid modes: ${modes.map((m) => m.id).join(", ")}` };
+    }
+  }
+  return { ok: true };
+}
+function typeCoherenceCheck(target, changes) {
+  if (!changes.type || changes.type === target.type) return null;
+  if (changes.type === "user") {
+    if (!Array.isArray(changes.userSteps) || changes.userSteps.length === 0) {
+      return { ok: false, error: `"${target.title}" cannot become a manual task without user steps \u2014 include "userSteps" in this edit` };
+    }
+    return { ok: true, clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0) };
+  }
+  if (!changes.prompt || !changes.prompt.trim()) {
+    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt \u2014 include "prompt" in this edit` };
+  }
+  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
+}
+function validateTaskEdit(actor, tasks, taskId, changes, catalog) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  if (actor === "planner") {
+    if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be modified` };
+    if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be modified` };
+  }
+  if (changes.dependencies) {
+    const depCheck = canSetDependencies(tasks, taskId, changes.dependencies);
+    if (!depCheck.ok) return depCheck;
+  }
+  const coherence = typeCoherenceCheck(target, changes);
+  if (coherence && !coherence.ok) return coherence;
+  const runner = changes.assignedRunner ?? target.assignedRunner;
+  const validity = checkModelAndModeValidity(runner, changes.assignedModel, changes.taskMode, catalog);
+  if (!validity.ok) return validity;
+  return coherence ?? { ok: true };
+}
+
+// src/services/TaskOps.ts
+var UPDATABLE_FIELDS = [
+  "title",
+  "description",
+  "prompt",
+  "dependencies",
+  "assignedRunner",
+  "assignedModel",
+  "taskMode",
+  "thinkingEffort",
+  "type",
+  "userSteps",
+  "autonomy",
+  "sliceType"
+];
+function taskOpsProtocol(executionNote = "") {
+  const updateChanges = UPDATABLE_FIELDS.map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
+  return [
+    "- To modify specific tasks, reply with ONLY this JSON object:",
+    '  {"taskOps": [',
+    `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
+    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?},"handle"?:"<name>"},',
+    '    {"op":"remove","taskId":"<id or #order>"},',
+    '    {"op":"reorder","taskIds":["<id or #order>", "... every task exactly once"]},   // only to re-prioritise INDEPENDENT tasks',
+    '    {"op":"merge","taskIds":["<id or #order>", "..."],"merged":{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...},"handle"?:"<name>"},',
+    '    {"op":"split","taskId":"<id or #order>","parts":[{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...}, ...],"handle"?:"<name>"},',
+    `    {"op":"rearm","taskId":"<id or #order>","changes"?:{${updateChanges}}}`,
+    "  ]}",
+    '- For sweeping changes, you may instead emit a full {"tasks":[...]} plan JSON.',
+    'Every "<id or #order>" ref in a batch resolves against the plan shown above, before any op in the batch runs \u2014 an earlier remove/merge/split never shifts what a later "#N" means.',
+    'Give "add", "merge", or "split" a "handle" (any name you choose, unused elsewhere in this batch) to let a LATER op in the same batch reference the task it produces \u2014 for "split", the handle names its last part. A handle used before its defining op is rejected.',
+    'When creating or changing tasks, set "assignedRunner" and "assignedModel" ({"modelId","modelLabel","thinkingEffort"?}) using only the runners and models listed in <available_models>.',
+    'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
+    'Just declare the dependencies you want \u2014 display order is repaired for you afterwards, so a rewire or a newly added prerequisite never needs a "reorder" op. Only a task that is running or completed cannot be shifted, so an edit that would need one to move is rejected.' + executionNote,
+    'Flipping "type" between "ai" and "user" is a content change, not just a label: an update to "user" needs "userSteps" in the SAME op, and an update to "ai" needs "prompt" in the SAME op \u2014 the model/mode/effort/autonomy fields (flipping to "user") or the userSteps (flipping to "ai") are cleared automatically.',
+    '"rearm" puts a failed OR completed task back to pending \u2014 verdict and output summary are cleared, any dependents it had blocked are released, and it may carry field changes (e.g. a corrected "prompt") applied in the same op. A running task cannot be re-armed. Never rearm a task just to relabel it \u2014 only when it should actually run again.'
+  ];
+}
+function textHasTaskOps(text2) {
+  return text2.includes(`"${TASK_OPS_ENVELOPE_KEY}"`);
+}
+function parseTaskOpsJson(text2) {
+  const { matches, fallback } = extractObjectsWithKey(text2, TASK_OPS_ENVELOPE_KEY);
+  const candidates = matches.length > 0 ? [...matches].reverse() : [fallback.json];
+  let lastError = null;
+  for (const json of candidates) {
+    try {
+      return parseTaskOpsObject(json, text2);
+    } catch (err) {
+      if (!(err instanceof PlanParseError)) throw err;
+      if (!lastError) lastError = err;
+    }
+  }
+  throw lastError ?? new PlanParseError("No JSON object found in task-ops reply", text2);
+}
+function parseTaskOpsObject(json, text2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(escapeControlCharsInStrings(stripTrailingCommas(json)));
+  } catch (err) {
+    throw new PlanParseError(`Task-ops JSON is invalid: ${err instanceof Error ? err.message : String(err)}`, text2);
+  }
+  const ops = parsed.taskOps;
+  if (!Array.isArray(ops) || ops.length === 0) {
+    throw new PlanParseError('"taskOps" must be a non-empty array', text2);
+  }
+  for (const op of ops) {
+    if (typeof op !== "object" || op === null || typeof op.op !== "string") {
+      throw new PlanParseError('Every task op needs an "op" field (update | add | remove | reorder | merge | split)', text2);
+    }
+  }
+  return ops;
+}
+function resolveRef(ref, originalScope, liveScope, handleOwner, handleId, opIndex) {
+  if (typeof ref !== "string" && typeof ref !== "number") return { error: `invalid reference "${String(ref)}"` };
+  const s = String(ref).trim();
+  const ownerIdx = handleOwner.get(s);
+  if (ownerIdx !== void 0) {
+    if (ownerIdx >= opIndex) {
+      return { error: `handle "${s}" is defined later in this batch (op ${ownerIdx + 1}) and cannot be referenced yet` };
+    }
+    const id = handleId.get(s);
+    if (!id) return { error: `handle "${s}" was never resolved` };
+    return { id };
+  }
+  const byLiveId = liveScope.find((t) => t.id === s);
+  if (byLiveId) return { id: byLiveId.id };
+  const orderStr = s.startsWith("#") ? s.slice(1) : s;
+  if (/^\d+$/.test(orderStr)) {
+    const order = Number(orderStr);
+    const byOrder = originalScope.filter((t) => t.order === order);
+    if (byOrder.length === 1) return { id: byOrder[0].id };
+  }
+  const byTitle = originalScope.find((t) => t.title === s);
+  if (byTitle) return { id: byTitle.id };
+  return { error: `task "${s}" not found` };
+}
+function taskOpRefs(op) {
+  switch (op.op) {
+    case "update":
+    case "remove":
+    case "split":
+    case "rearm":
+      return [op.taskId];
+    case "merge":
+    case "reorder":
+      return op.taskIds;
+    case "add":
+      return [];
+  }
+}
+function refMatchesTask(ref, task) {
+  if (typeof ref !== "string" && typeof ref !== "number") return false;
+  const s = String(ref).trim();
+  if (task.id === s) return true;
+  const orderStr = s.startsWith("#") ? s.slice(1) : s;
+  return /^\d+$/.test(orderStr) && task.order === Number(orderStr) || task.title === s;
+}
+function refCollidesWithExisting(name, originalFlatAll) {
+  if (originalFlatAll.some((t) => t.id === name)) return true;
+  const orderStr = name.startsWith("#") ? name.slice(1) : name;
+  if (/^\d+$/.test(orderStr) && originalFlatAll.some((t) => t.order === Number(orderStr))) return true;
+  return originalFlatAll.some((t) => t.title === name);
+}
+function findInTasks(tasks, id) {
+  return flattenTasks(tasks).find((t) => t.id === id);
+}
+function findTopLevel(tasks, id) {
+  return tasks.find((t) => t.id === id);
+}
+function detectCycle(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const visiting = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (done.has(id)) return null;
+    if (visiting.has(id)) return id;
+    visiting.add(id);
+    for (const dep of byId.get(id)?.dependencies ?? []) {
+      const hit = visit(dep);
+      if (hit) return hit;
+    }
+    visiting.delete(id);
+    done.add(id);
+    return null;
+  };
+  for (const t of tasks) {
+    const hit = visit(t.id);
+    if (hit) return byId.get(hit)?.title ?? hit;
+  }
+  return null;
+}
+function isPinned(t) {
+  return t.status === "in_progress" || t.status === "completed";
+}
+function repairOrder(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const placed = /* @__PURE__ */ new Set();
+  const movable = tasks.filter((t) => !isPinned(t));
+  const result = [];
+  const blockerOf = (t) => {
+    const id = t.dependencies.find((d) => byId.has(d) && !placed.has(d));
+    return id ? byId.get(id) : void 0;
+  };
+  const place = (t) => {
+    result.push(t);
+    placed.add(t.id);
+  };
+  for (const occupant of tasks) {
+    if (isPinned(occupant)) {
+      const blocker = blockerOf(occupant);
+      if (blocker) return { error: pinnedRefusal(blocker, occupant, "before") };
+      place(occupant);
+      continue;
+    }
+    const next = movable.findIndex((t) => !blockerOf(t));
+    if (next < 0) {
+      const [stuck, pin] = trailToPin(movable[0], blockerOf);
+      return { error: pinnedRefusal(stuck, pin, "after") };
+    }
+    place(movable.splice(next, 1)[0]);
+  }
+  return { tasks: result };
+}
+function trailToPin(task, blockerOf) {
+  let at = task;
+  for (; ; ) {
+    const blocker = blockerOf(at);
+    if (!blocker || isPinned(blocker)) return [at, blocker ?? at];
+    at = blocker;
+  }
+}
+function describeMoves(before, after) {
+  const wasAt = new Map(before.map((t, i) => [t.id, i + 1]));
+  const moved = after.map((t, i) => ({ t, from: wasAt.get(t.id), to: i + 1 })).filter((m) => m.from !== m.to);
+  return moved.length ? moved.map((m) => `"${m.t.title}" #${m.from}\u2192#${m.to}`).join(", ") : null;
+}
+function pinnedRefusal(other, pin, side) {
+  const word = pin.status === "in_progress" ? "running" : "completed";
+  return `"${other.title}" would have to run ${side} "${pin.title}", which is ${word} and cannot be moved`;
+}
+function canMergeTasks(tasks, selectedIds) {
+  if (selectedIds.length < 2) return { ok: false, error: "Select at least two tasks to merge" };
+  const idSet = new Set(selectedIds);
+  const toMerge = tasks.filter((t) => idSet.has(t.id));
+  if (toMerge.length < 2) return { ok: false, error: "At least two valid tasks are required to merge" };
+  for (const t of toMerge) {
+    if (t.status === "in_progress") return { ok: false, error: `"${t.title}" is running and cannot be merged` };
+    if (t.status === "completed") return { ok: false, error: `"${t.title}" is completed and cannot be merged` };
+  }
+  const ordered = [...toMerge].sort((a, b) => a.order - b.order);
+  const survivorId = "__merge_sim__";
+  const sim = tasks.filter((t) => !idSet.has(t.id)).map((t) => ({ ...t, dependencies: t.dependencies.map((d) => idSet.has(d) ? survivorId : d).filter((d) => d !== t.id) }));
+  const unionDeps = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
+  sim.push({ ...ordered[0], id: survivorId, title: "__merge_sim__", order: ordered[0].order, dependencies: unionDeps });
+  const cycle = detectCycle(sim);
+  if (cycle) return { ok: false, error: `Merging would create a dependency cycle involving "${cycle}"` };
+  return { ok: true };
+}
+function dependentsOf(tasks, taskId) {
+  return tasks.filter((t) => t.id !== taskId && t.dependencies.includes(taskId));
+}
+function dependencyCandidates(tasks, taskId) {
+  if (!taskId) return [...tasks];
+  const target = tasks.find((t) => t.id === taskId);
+  return target ? tasks.filter((t) => t.order < target.order) : [];
+}
+function canSetDependencies(tasks, taskId, dependencies) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  const allowed = new Set(dependencyCandidates(tasks, taskId).map((t) => t.id));
+  for (const dep of dependencies) {
+    if (dep === taskId) return { ok: false, error: `"${target.title}" cannot depend on itself` };
+    const found = tasks.find((t) => t.id === dep);
+    if (!found) return { ok: false, error: `Unknown dependency "${dep}"` };
+    if (!allowed.has(dep)) {
+      return { ok: false, error: `"${target.title}" cannot depend on "${found.title}", which comes after it in the plan` };
+    }
+  }
+  return { ok: true };
+}
+function canSplitTask(tasks, taskId) {
+  const target = tasks.find((t) => t.id === taskId);
+  if (!target) return { ok: false, error: "Task not found" };
+  if (target.status === "in_progress") return { ok: false, error: `"${target.title}" is running and cannot be split` };
+  if (target.status === "completed") return { ok: false, error: `"${target.title}" is completed and cannot be split` };
+  return { ok: true };
+}
+function applyTaskOps(currentTasks, ops, runners, catalog) {
+  let tasks = JSON.parse(JSON.stringify(currentTasks));
+  const errors = [];
+  const summary = [];
+  const originalFlatAll = flattenTasks(currentTasks);
+  const handleOwner = /* @__PURE__ */ new Map();
+  const handleId = /* @__PURE__ */ new Map();
+  for (const [i, op] of ops.entries()) {
+    const handle = op.handle;
+    if (handle === void 0) continue;
+    if (typeof handle !== "string" || !handle.trim()) {
+      errors.push(`op ${i + 1} (${op.op}): handle must be a non-empty string`);
+      continue;
+    }
+    if (handleOwner.has(handle)) {
+      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" is already used earlier in this batch`);
+      continue;
+    }
+    if (refCollidesWithExisting(handle, originalFlatAll)) {
+      errors.push(`op ${i + 1} (${op.op}): handle "${handle}" collides with an existing task reference`);
+      continue;
+    }
+    handleOwner.set(handle, i);
+  }
+  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
+  const resolveDeps = (deps, opIndex) => {
+    const ids = [];
+    const bad = [];
+    const liveFlat = flattenTasks(tasks);
+    for (const d of Array.isArray(deps) ? deps : []) {
+      const r = resolveRef(d, originalFlatAll, liveFlat, handleOwner, handleId, opIndex);
+      if ("error" in r) {
+        bad.push(`${String(d)} (${r.error})`);
+        continue;
       }
-      case "rearm": {
+      if (!liveFlat.some((t) => t.id === r.id)) {
+        bad.push(`${String(d)} (no longer exists in this batch)`);
+        continue;
+      }
+      ids.push(r.id);
+    }
+    return { ids, bad };
+  };
+  for (const [i, op] of ops.entries()) {
+    const label = `op ${i + 1} (${op.op})`;
+    switch (op.op) {
+      case "update": {
         const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
         if ("error" in ref) {
           errors.push(`${label}: ${ref.error}`);
@@ -795,10 +1210,6 @@ function applyTaskOps(currentTasks, ops, runners, catalog) {
           errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
           break;
         }
-        if (target.status === "in_progress") {
-          errors.push(`${label}: "${target.title}" is running and cannot be re-armed`);
-          break;
-        }
         const changes = {};
         for (const key of UPDATABLE_FIELDS) {
           if (op.changes && key in op.changes) changes[key] = op.changes[key];
@@ -807,551 +1218,478 @@ function applyTaskOps(currentTasks, ops, runners, catalog) {
           errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
           break;
         }
-        const changesForCheck = { ...changes };
-        delete changesForCheck.dependencies;
-        const check = validateTaskEdit("direct", flattenTasks(tasks), target.id, changesForCheck, catalog);
-        if (!check.ok) {
-          errors.push(`${label}: ${check.error}`);
-          break;
-        }
-        for (const field of check.clear ?? []) changes[field] = void 0;
-        if ("dependencies" in changes) {
-          const { ids, bad } = resolveDeps(changes.dependencies, i);
-          if (bad.length) {
-            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
-            break;
-          }
-          changes.dependencies = ids.filter((id) => id !== target.id);
-        }
-        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0 });
-        for (const dep of flattenTasks(tasks)) {
-          if (dep.status === "blocked" && dep.dependencies.includes(target.id)) {
-            tasks = updateTaskInPlan(tasks, dep.id, { status: "pending" });
-          }
-        }
-        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
-        const changedNote = Object.keys(changes).length ? ` (${Object.keys(changes).join(", ")})` : "";
-        summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
-        break;
-      }
-      default:
-        errors.push(`${label}: unknown op "${op.op}"`);
-    }
-    if (errors.length) break;
-  }
-  if (!errors.length) {
-    const flat = flattenTasks(tasks);
-    const idSet = new Set(flat.map((t) => t.id));
-    for (const t of flat) {
-      for (const dep of t.dependencies) {
-        if (!idSet.has(dep)) errors.push(`"${t.title}" depends on a task that no longer exists (${dep})`);
-      }
-    }
-    const cycleAt = detectCycle(flat);
-    if (cycleAt) errors.push(`Dependency cycle detected involving "${cycleAt}"`);
-    if (!errors.length) {
-      const repaired = repairOrder(tasks);
-      if ("error" in repaired) {
-        errors.push(repaired.error);
-      } else {
-        const moves = describeMoves(tasks, repaired.tasks);
-        if (moves) summary.push(`Reordered to keep dependencies first: ${moves}`);
-        tasks = renumberTasks(repaired.tasks);
-      }
-    }
-  }
-  return errors.length ? { ok: false, tasks: currentTasks, errors, summary: [] } : { ok: true, tasks, errors: [], summary };
-}
-
-// src/services/researchStepSummary.ts
-function ellipsize(text2, max) {
-  const oneLine2 = text2.replace(/\s+/g, " ").trim();
-  return oneLine2.length > max ? `${oneLine2.slice(0, max)}\u2026` : oneLine2;
-}
-function summarizeToolCall(tool, argsJson, toolLabel) {
-  const display = toolLabel?.trim() || tool;
-  if (tool === "agent_tool") {
-    try {
-      const args = JSON.parse(argsJson);
-      const hint = args.path ?? args.file_path ?? args.filePath ?? args.pattern ?? args.query ?? args.url ?? args.command;
-      if (hint) return `${display} ${ellipsize(String(hint), 50)}`;
-    } catch {
-    }
-    return display;
-  }
-  if (tool === "spawn_research_agent") {
-    try {
-      const args = JSON.parse(argsJson);
-      const prompt = typeof args.prompt === "string" ? args.prompt : "";
-      const oneLine2 = prompt.replace(/\s+/g, " ").trim();
-      return `spawn: "${oneLine2.slice(0, 60)}${oneLine2.length > 60 ? "\u2026" : ""}"`;
-    } catch {
-      return "spawn_research_agent";
-    }
-  }
-  try {
-    const args = JSON.parse(argsJson);
-    if (tool === "find_symbol" && args.symbol) {
-      return `find_symbol ${args.symbol}${args.language ? ` [${args.language}]` : ""}`;
-    }
-    if (tool === "web_search" && args.query) {
-      return `web_search "${ellipsize(String(args.query), 50)}"`;
-    }
-    if (tool === "fetch" && args.url) {
-      return `fetch ${ellipsize(String(args.url), 60)}`;
-    }
-    if (tool === "glob" && args.pattern) {
-      return `glob ${ellipsize(String(args.pattern), 50)}`;
-    }
-    if (tool === "grep" && args.pattern) {
-      const mode = args.output_mode && args.output_mode !== "content" ? ` (${args.output_mode})` : "";
-      const scope = args.include ? ` in ${args.include}` : "";
-      return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
-    }
-    const path = args.filePath || args.file_path || args.path;
-    if (path) {
-      const basename = String(path).split("/").pop() || String(path);
-      return `${display} ${basename}`;
-    }
-    if (args.pattern) {
-      return `${display} ${args.pattern}`;
-    }
-    if (args.command) {
-      return `bash: ${String(args.command).slice(0, 40)}`;
-    }
-  } catch {
-  }
-  return display;
-}
-function classifyOutcome(success, output) {
-  if (!success) {
-    if (/^Command refused:/.test(output) || /is not available\. You are a read-only research subagent/.test(output)) return "refused";
-    if (/not approved/i.test(output) || /^Access denied:/.test(output) || /needs user approval/i.test(output)) return "denied";
-    return "failure";
-  }
-  return "success";
-}
-
-// src/services/SessionMessage.ts
-function serializeTask(t) {
-  return {
-    id: t.id,
-    order: t.order,
-    title: t.title,
-    type: t.type,
-    description: t.description,
-    dependencies: t.dependencies || [],
-    assignedRunner: t.assignedRunner,
-    assignedModel: t.assignedModel || null,
-    taskMode: t.taskMode || "build",
-    prompt: t.prompt || null,
-    subtasks: (t.subtasks || []).map(serializeTask),
-    userSteps: t.userSteps || void 0,
-    thinkingEffort: t.thinkingEffort || void 0,
-    autonomy: t.autonomy || void 0,
-    sliceType: t.sliceType || void 0,
-    userStoriesCovered: t.userStoriesCovered || void 0
-  };
-}
-function serializeTaskStatus(t, idleSince = null, isolation = null) {
-  return {
-    id: t.id,
-    status: t.status,
-    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null,
-    idleSince,
-    ...isolation ? { isolation } : {}
-  };
-}
-function serializePlan(plan) {
-  return {
-    tasks: plan.tasks.map(serializeTask),
-    runners: plan.runners,
-    generatedAt: plan.generatedAt,
-    conversationHistory: plan.conversationHistory,
-    prdMarkdown: plan.prdMarkdown,
-    queuedMessages: plan.queuedMessages
-  };
-}
-function executionSummary(tasks) {
-  return {
-    total: tasks.length,
-    completed: tasks.filter((t) => t.status === "completed").length,
-    failed: tasks.filter((t) => t.status === "failed").length
-  };
-}
-var CHECKPOINT_TRUNCATE_LENGTH = 120;
-function truncateCheckpointSummary(summary) {
-  const firstLine = summary.split("\n")[0].trim();
-  if (firstLine.length <= CHECKPOINT_TRUNCATE_LENGTH) return firstLine;
-  return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
-}
-
-// src/services/terminalRender.ts
-var ANSI_OR_CTRL_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[()][AB012]|\x1b[=>]|[\x00-\x08\x0b-\x1f\x7f]/g;
-function flattenTerminalOutput(raw) {
-  return raw.replace(ANSI_OR_CTRL_RE, "").replace(/[─-▟]/g, "").replace(/\s+/g, "");
-}
-function renderTerminalOutput(raw) {
-  const rows = /* @__PURE__ */ new Map();
-  let row = 1;
-  let col = 1;
-  let savedRow = 1;
-  let savedCol = 1;
-  const cells = (r) => {
-    let line = rows.get(r);
-    if (!line) {
-      line = [];
-      rows.set(r, line);
-    }
-    return line;
-  };
-  const firstParam = (params, fallback = 1) => params[0] || fallback;
-  const eraseLine = (mode) => {
-    const line = cells(row);
-    if (mode === 2) {
-      rows.set(row, []);
-    } else if (mode === 1) {
-      for (let c = 0; c < col; c++) line[c] = " ";
-    } else {
-      line.length = Math.max(0, col - 1);
-    }
-  };
-  for (let i = 0; i < raw.length; ) {
-    const ch = raw[i];
-    if (ch === "\x1B") {
-      const kind = raw[i + 1];
-      if (kind === "[") {
-        let end = i + 2;
-        while (end < raw.length) {
-          const code = raw.charCodeAt(end);
-          if (code >= 64 && code <= 126) break;
-          end++;
-        }
-        if (end >= raw.length) break;
-        const final = raw[end];
-        const body = raw.slice(i + 2, end).replace(/^[?<>=!]+/, "");
-        const params = body.split(";").map((p) => Number.parseInt(p, 10) || 0);
-        switch (final) {
-          case "H":
-          case "f":
-            row = params[0] || 1;
-            col = params[1] || 1;
-            break;
-          case "G":
-            col = firstParam(params);
-            break;
-          case "d":
-            row = firstParam(params);
-            break;
-          case "A":
-            row = Math.max(1, row - firstParam(params));
-            break;
-          case "B":
-            row += firstParam(params);
-            break;
-          case "C":
-            col += firstParam(params);
-            break;
-          case "D":
-            col = Math.max(1, col - firstParam(params));
-            break;
-          case "E":
-            row += firstParam(params);
-            col = 1;
-            break;
-          case "F":
-            row = Math.max(1, row - firstParam(params));
-            col = 1;
-            break;
-          case "s":
-            savedRow = row;
-            savedCol = col;
-            break;
-          case "u":
-            row = savedRow;
-            col = savedCol;
-            break;
-          case "K":
-            eraseLine(params[0] || 0);
-            break;
-          case "J":
-            if ((params[0] || 0) === 2 || (params[0] || 0) === 3) rows.clear();
+        const changesForCheck = { ...changes };
+        delete changesForCheck.dependencies;
+        const check = validateTaskEdit("planner", flattenTasks(tasks), target.id, changesForCheck, catalog);
+        if (!check.ok) {
+          errors.push(`${label}: ${check.error}`);
+          break;
+        }
+        for (const field of check.clear ?? []) changes[field] = void 0;
+        if ("dependencies" in changes) {
+          const { ids, bad } = resolveDeps(changes.dependencies, i);
+          if (bad.length) {
+            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
             break;
-          case "X": {
-            const line = cells(row);
-            for (let c = 0; c < firstParam(params); c++) line[col - 1 + c] = " ";
+          }
+          changes.dependencies = ids.filter((id) => id !== target.id);
+        }
+        if (Object.keys(changes).length === 0) {
+          errors.push(`${label}: no valid changes provided`);
+          break;
+        }
+        tasks = updateTaskInPlan(tasks, target.id, changes);
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        summary.push(`Updated "${target.title}" (${Object.keys(changes).join(", ")})${clearedNote}`);
+        break;
+      }
+      case "add": {
+        const spec = op.task ?? {};
+        if (!spec.title) {
+          errors.push(`${label}: new task needs a title`);
+          break;
+        }
+        const { ids, bad } = resolveDeps(spec.dependencies, i);
+        if (bad.length) {
+          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+          break;
+        }
+        const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : runners[0];
+        const validity = checkModelAndModeValidity(runner, spec.assignedModel, spec.taskMode, catalog);
+        if (!validity.ok) {
+          errors.push(`${label}: ${validity.error}`);
+          break;
+        }
+        const newId = uuidv4();
+        tasks = addTaskToPlan(tasks, {
+          ...spec,
+          id: newId,
+          dependencies: ids,
+          assignedRunner: runner,
+          description: spec.description ?? spec.title,
+          prompt: spec.prompt ?? spec.description ?? spec.title
+        });
+        if (op.handle) handleId.set(op.handle, newId);
+        summary.push(`Added "${spec.title}"`);
+        break;
+      }
+      case "remove": {
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be removed`);
+          break;
+        }
+        if (target.status === "completed") {
+          errors.push(`${label}: "${target.title}" is completed and cannot be removed`);
+          break;
+        }
+        tasks = removeTaskFromPlan(tasks, target.id);
+        summary.push(`Removed "${target.title}"`);
+        break;
+      }
+      case "reorder": {
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const badRef = refs.find((r) => "error" in r);
+        if (badRef) {
+          errors.push(`${label}: ${badRef.error}`);
+          break;
+        }
+        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
+        if (resolved.some((t) => !t)) {
+          errors.push(`${label}: unknown task in reorder list`);
+          break;
+        }
+        const orderIds = resolved.map((t) => t.id);
+        if (new Set(orderIds).size !== tasks.length) {
+          errors.push(`${label}: reorder must list every top-level task exactly once (${tasks.length} tasks)`);
+          break;
+        }
+        const byId = new Map(tasks.map((t) => [t.id, t]));
+        tasks = renumberTasks(orderIds.map((id) => byId.get(id)));
+        summary.push("Reordered tasks");
+        break;
+      }
+      case "merge": {
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const badRef = refs.find((r) => "error" in r);
+        if (badRef) {
+          errors.push(`${label}: ${badRef.error}`);
+          break;
+        }
+        const resolved = refs.map((r) => findTopLevel(tasks, r.id));
+        if (resolved.some((t) => !t)) {
+          errors.push(`${label}: unknown task in merge list (already removed, merged, or split by an earlier op)`);
+          break;
+        }
+        const toMerge = resolved.map((t) => t).sort((a, b) => a.order - b.order);
+        if (toMerge.length < 2) {
+          errors.push(`${label}: merge needs at least two tasks`);
+          break;
+        }
+        const locked = toMerge.find((t) => t.status === "in_progress" || t.status === "completed");
+        if (locked) {
+          errors.push(`${label}: "${locked.title}" is ${locked.status === "in_progress" ? "running" : "completed"} and cannot be merged`);
+          break;
+        }
+        const idSet = new Set(toMerge.map((t) => t.id));
+        const unionDepsRaw = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
+        const { ids, bad } = resolveDeps(unionDepsRaw, i);
+        if (bad.length) {
+          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+          break;
+        }
+        const spec = op.merged ?? {};
+        if (!spec.title) {
+          errors.push(`${label}: merged task needs a title`);
+          break;
+        }
+        const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : toMerge[0].assignedRunner;
+        const mergedTask = createTask({
+          title: spec.title,
+          description: spec.description ?? toMerge.map((t) => t.description).filter(Boolean).join("\n\n"),
+          prompt: spec.prompt ?? (toMerge.map((t) => t.prompt).filter(Boolean).join("\n\n---\n\n") || void 0),
+          type: spec.type ?? (toMerge.some((t) => t.type === "user") ? "user" : "ai"),
+          dependencies: ids,
+          assignedRunner: runner,
+          assignedModel: spec.assignedModel ?? toMerge.find((t) => t.assignedModel)?.assignedModel,
+          thinkingEffort: spec.thinkingEffort ?? toMerge.find((t) => t.thinkingEffort)?.thinkingEffort,
+          taskMode: spec.taskMode ?? toMerge[0].taskMode,
+          autonomy: spec.autonomy ?? toMerge.find((t) => t.autonomy)?.autonomy,
+          sliceType: spec.sliceType ?? toMerge.find((t) => t.sliceType)?.sliceType,
+          userStoriesCovered: spec.userStoriesCovered ?? (toMerge.flatMap((t) => t.userStoriesCovered ?? []).length ? [...new Set(toMerge.flatMap((t) => t.userStoriesCovered ?? []))] : void 0)
+        });
+        const mergedId = mergedTask.id;
+        const firstId = toMerge[0].id;
+        const result = [];
+        let inserted = false;
+        for (const t of tasks) {
+          if (idSet.has(t.id)) {
+            if (!inserted && t.id === firstId) {
+              result.push(mergedTask);
+              inserted = true;
+            }
+            continue;
+          }
+          result.push({ ...t, dependencies: t.dependencies.map((d) => idSet.has(d) ? mergedId : d) });
+        }
+        if (!inserted) result.push(mergedTask);
+        tasks = renumberTasks(result);
+        if (op.handle) handleId.set(op.handle, mergedId);
+        summary.push(`Merged ${toMerge.length} tasks into "${spec.title}"`);
+        break;
+      }
+      case "split": {
+        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findTopLevel(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" not found`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be split`);
+          break;
+        }
+        if (target.status === "completed") {
+          errors.push(`${label}: "${target.title}" is completed and cannot be split`);
+          break;
+        }
+        const parts = op.parts ?? [];
+        if (parts.length < 2) {
+          errors.push(`${label}: split needs at least two parts`);
+          break;
+        }
+        const newTasks = [];
+        let prevId;
+        let buildError = false;
+        for (let p = 0; p < parts.length; p++) {
+          const spec = parts[p];
+          if (!spec || !spec.title) {
+            errors.push(`${label}: split part ${p + 1} needs a title`);
+            buildError = true;
             break;
           }
-          case "P": {
-            cells(row).splice(col - 1, firstParam(params));
-            break;
+          let deps;
+          if (p === 0) {
+            const { ids, bad } = resolveDeps(target.dependencies, i);
+            if (bad.length) {
+              errors.push(`${label}: split part 1 unknown dependencies: ${bad.join(", ")}`);
+              buildError = true;
+              break;
+            }
+            deps = ids;
+          } else {
+            deps = prevId ? [prevId] : [];
+          }
+          const runner = spec.assignedRunner && runners.includes(spec.assignedRunner) ? spec.assignedRunner : target.assignedRunner;
+          const nt = createTask({
+            title: spec.title,
+            description: spec.description ?? spec.title,
+            prompt: spec.prompt ?? spec.description ?? spec.title,
+            type: spec.type ?? target.type,
+            dependencies: deps,
+            assignedRunner: runner,
+            assignedModel: spec.assignedModel ?? target.assignedModel,
+            taskMode: spec.taskMode ?? target.taskMode,
+            autonomy: spec.autonomy ?? target.autonomy,
+            sliceType: spec.sliceType ?? target.sliceType,
+            userStoriesCovered: spec.userStoriesCovered ?? target.userStoriesCovered
+          });
+          newTasks.push(nt);
+          prevId = nt.id;
+        }
+        if (buildError) break;
+        const tailId = newTasks[newTasks.length - 1].id;
+        const result = [];
+        for (const t of tasks) {
+          if (t.id === target.id) {
+            result.push(...newTasks);
+            continue;
           }
-          case "@": {
-            cells(row).splice(col - 1, 0, ...Array(firstParam(params)).fill(" "));
+          result.push({ ...t, dependencies: t.dependencies.map((d) => d === target.id ? tailId : d) });
+        }
+        tasks = renumberTasks(result);
+        if (op.handle) handleId.set(op.handle, tailId);
+        summary.push(`Split "${target.title}" into ${newTasks.length} tasks`);
+        break;
+      }
+      case "rearm": {
+        const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(tasks), handleOwner, handleId, i);
+        if ("error" in ref) {
+          errors.push(`${label}: ${ref.error}`);
+          break;
+        }
+        const target = findInTasks(tasks, ref.id);
+        if (!target) {
+          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          break;
+        }
+        if (target.status === "in_progress") {
+          errors.push(`${label}: "${target.title}" is running and cannot be re-armed`);
+          break;
+        }
+        const changes = {};
+        for (const key of UPDATABLE_FIELDS) {
+          if (op.changes && key in op.changes) changes[key] = op.changes[key];
+        }
+        if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
+          errors.push(`${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]`);
+          break;
+        }
+        const changesForCheck = { ...changes };
+        delete changesForCheck.dependencies;
+        const check = validateTaskEdit("direct", flattenTasks(tasks), target.id, changesForCheck, catalog);
+        if (!check.ok) {
+          errors.push(`${label}: ${check.error}`);
+          break;
+        }
+        for (const field of check.clear ?? []) changes[field] = void 0;
+        if ("dependencies" in changes) {
+          const { ids, bad } = resolveDeps(changes.dependencies, i);
+          if (bad.length) {
+            errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
             break;
           }
-          default:
-            break;
+          changes.dependencies = ids.filter((id) => id !== target.id);
         }
-        i = end + 1;
-        continue;
+        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0, awaitingReason: void 0 });
+        for (const dep of flattenTasks(tasks)) {
+          if (dep.status === "blocked" && dep.dependencies.includes(target.id)) {
+            tasks = updateTaskInPlan(tasks, dep.id, { status: "pending" });
+          }
+        }
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        const changedNote = Object.keys(changes).length ? ` (${Object.keys(changes).join(", ")})` : "";
+        summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
+        break;
       }
-      if (kind === "]" || kind === "P" || kind === "^" || kind === "_") {
-        let end = i + 2;
-        while (end < raw.length && raw[end] !== "\x07" && !(raw[end] === "\x1B" && raw[end + 1] === "\\")) end++;
-        if (end >= raw.length) break;
-        i = raw[end] === "\x07" ? end + 1 : end + 2;
-        continue;
+      default:
+        errors.push(`${label}: unknown op "${op.op}"`);
+    }
+    if (errors.length) break;
+  }
+  if (!errors.length) {
+    const flat = flattenTasks(tasks);
+    const idSet = new Set(flat.map((t) => t.id));
+    for (const t of flat) {
+      for (const dep of t.dependencies) {
+        if (!idSet.has(dep)) errors.push(`"${t.title}" depends on a task that no longer exists (${dep})`);
       }
-      if (kind === "7") {
-        savedRow = row;
-        savedCol = col;
-      } else if (kind === "8") {
-        row = savedRow;
-        col = savedCol;
-      } else if (kind === "c") {
-        rows.clear();
-        row = 1;
-        col = 1;
+    }
+    const cycleAt = detectCycle(flat);
+    if (cycleAt) errors.push(`Dependency cycle detected involving "${cycleAt}"`);
+    if (!errors.length) {
+      const repaired = repairOrder(tasks);
+      if ("error" in repaired) {
+        errors.push(repaired.error);
+      } else {
+        const moves = describeMoves(tasks, repaired.tasks);
+        if (moves) summary.push(`Reordered to keep dependencies first: ${moves}`);
+        tasks = renumberTasks(repaired.tasks);
       }
-      i += kind === "(" || kind === ")" ? 3 : 2;
-      continue;
     }
-    if (ch === "\r") {
-      col = 1;
-      i++;
-      continue;
+  }
+  return errors.length ? { ok: false, tasks: currentTasks, errors, summary: [] } : { ok: true, tasks, errors: [], summary };
+}
+
+// src/services/researchStepSummary.ts
+function ellipsize(text2, max) {
+  const oneLine2 = text2.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max)}\u2026` : oneLine2;
+}
+function summarizeToolCall(tool, argsJson, toolLabel) {
+  const display = toolLabel?.trim() || tool;
+  if (tool === "agent_tool") {
+    try {
+      const args = JSON.parse(argsJson);
+      const hint = args.path ?? args.file_path ?? args.filePath ?? args.pattern ?? args.query ?? args.url ?? args.command;
+      if (hint) return `${display} ${ellipsize(String(hint), 50)}`;
+    } catch {
     }
-    if (ch === "\n") {
-      row++;
-      i++;
-      continue;
+    return display;
+  }
+  if (tool === "spawn_research_agent") {
+    try {
+      const args = JSON.parse(argsJson);
+      const prompt = typeof args.prompt === "string" ? args.prompt : "";
+      const oneLine2 = prompt.replace(/\s+/g, " ").trim();
+      return `spawn: "${oneLine2.slice(0, 60)}${oneLine2.length > 60 ? "\u2026" : ""}"`;
+    } catch {
+      return "spawn_research_agent";
     }
-    if (ch === "\b") {
-      col = Math.max(1, col - 1);
-      i++;
-      continue;
+  }
+  try {
+    const args = JSON.parse(argsJson);
+    if (tool === "find_symbol" && args.symbol) {
+      return `find_symbol ${args.symbol}${args.language ? ` [${args.language}]` : ""}`;
     }
-    if (ch === "	") {
-      col += 8 - (col - 1) % 8;
-      i++;
-      continue;
+    if (tool === "web_search" && args.query) {
+      return `web_search "${ellipsize(String(args.query), 50)}"`;
     }
-    if (ch < " " || ch === "\x7F") {
-      i++;
-      continue;
+    if (tool === "fetch" && args.url) {
+      return `fetch ${ellipsize(String(args.url), 60)}`;
     }
-    cells(row)[col - 1] = ch;
-    col++;
-    i++;
-  }
-  const populated = [...rows.keys()].sort((a, b) => a - b);
-  return populated.map((r) => cells(r).join("")).join("\n");
-}
-function renderCleanCapture(raw, doneToken) {
-  const rendered = renderTerminalOutput(raw).replace(/[\s─-▟]+$/gm, "");
-  if (!doneToken) return rendered.trim();
-  const lines = rendered.split("\n");
-  const flat = (s) => flattenTerminalOutput(s);
-  for (let i = 0; i < lines.length; i++) {
-    const own = flat(lines[i]).includes(doneToken);
-    if (own) return lines.slice(0, i).join("\n").trim();
-    const window = flat(lines[i]) + (i + 1 < lines.length ? flat(lines[i + 1]) : "");
-    if (window.includes(doneToken)) return lines.slice(0, i + 1).join("\n").trim();
-  }
-  return rendered.trim();
-}
-
-// src/conversation/format.ts
-var DISPLAY_NAMES = {
-  read_file: "Read",
-  read_files: "Read",
-  list_dir: "List",
-  glob: "Glob",
-  grep: "Grep",
-  find_symbol: "Symbol",
-  bash: "Bash",
-  fetch: "Fetch",
-  web_search: "WebSearch",
-  spawn_research_agent: "Agent"
-};
-var HINT_FIELDS = ["file_path", "filePath", "path", "url", "pattern", "query", "command", "description", "prompt"];
-function parseArgs(args) {
-  try {
-    const parsed = JSON.parse(args);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function oneLine(text2) {
-  return text2.replace(/\s+/g, " ").trim();
-}
-function firstLineOf(command) {
-  const lines = command.trim().split(/\r?\n/);
-  const more = lines.length - 1;
-  return more > 0 ? `${lines[0]} \u2026 +${more} line${more === 1 ? "" : "s"}` : lines[0];
-}
-function text(value) {
-  return typeof value === "string" ? value : "";
-}
-function searchArg(pattern, path, include = "") {
-  return `${pattern}${path ? ` in ${path}` : ""}${include ? ` (${include})` : ""}`;
-}
-function hintArg(args) {
-  for (const field of HINT_FIELDS) {
-    const value = text(args[field]);
-    if (value) return field === "command" ? firstLineOf(value) : oneLine(value);
+    if (tool === "glob" && args.pattern) {
+      return `glob ${ellipsize(String(args.pattern), 50)}`;
+    }
+    if (tool === "grep" && args.pattern) {
+      const mode = args.output_mode && args.output_mode !== "content" ? ` (${args.output_mode})` : "";
+      const scope = args.include ? ` in ${args.include}` : "";
+      return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
+    }
+    const path = args.filePath || args.file_path || args.path;
+    if (path) {
+      const basename = String(path).split("/").pop() || String(path);
+      return `${display} ${basename}`;
+    }
+    if (args.pattern) {
+      return `${display} ${args.pattern}`;
+    }
+    if (args.command) {
+      return `bash: ${String(args.command).slice(0, 40)}`;
+    }
+  } catch {
   }
-  const firstText = Object.values(args).find((v) => typeof v === "string" && v.trim() !== "");
-  return firstText ? oneLine(firstText) : "";
+  return display;
 }
-function keyArgOf(tool, args) {
-  switch (tool) {
-    case "bash":
-      return firstLineOf(text(args.command));
-    case "read_file":
-    case "list_dir":
-      return text(args.path);
-    case "read_files":
-      return Array.isArray(args.paths) ? args.paths.map(String).join(", ") : "";
-    case "glob":
-      return searchArg(text(args.pattern), text(args.path));
-    case "grep":
-      return searchArg(text(args.pattern), text(args.path), text(args.include));
-    case "find_symbol":
-      return `${text(args.symbol)}${text(args.language) ? ` [${text(args.language)}]` : ""}`;
-    case "fetch":
-      return text(args.url);
-    case "web_search":
-      return oneLine(text(args.query));
-    case "spawn_research_agent":
-      return oneLine(text(args.prompt));
-    default:
-      return hintArg(args);
+function classifyOutcome(success, output) {
+  if (!success) {
+    if (/^Command refused:/.test(output) || /is not available\. You are a read-only research subagent/.test(output)) return "refused";
+    if (/not approved/i.test(output) || /^Access denied:/.test(output) || /needs user approval/i.test(output)) return "denied";
+    return "failure";
   }
+  return "success";
 }
-function toolHeadline(tool, args, toolLabel) {
-  const name = toolLabel?.trim() || DISPLAY_NAMES[tool] || tool;
-  const parsed = parseArgs(args);
-  return { name, keyArg: parsed ? keyArgOf(tool, parsed) : oneLine(args) };
-}
-function outputLines(output) {
-  const lines = output.replace(/\r\n?/g, "\n").replace(ANSI_OR_CTRL_RE, "").split("\n");
-  while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
-  return lines;
+
+// src/services/continuation.ts
+function continuability(task) {
+  const refuse = (reason) => ({ ok: false, reason: `Task "${task.title}" cannot be continued: ${reason}` });
+  if (task.type !== "ai") return refuse("it is not run by an agent.");
+  if (task.status === "awaiting_user" && task.awaitingReason === "conflict") {
+    return refuse("its work is waiting on a merge conflict. Resolve or repair the conflict instead.");
+  }
+  if (task.status !== "completed" && task.status !== "failed") return refuse("only a completed or failed task can be.");
+  if (task.transport?.kind !== "structured") return refuse("it ran in a terminal, so there is no saved session to resume. Use Retry instead.");
+  if (!task.transport.nativeSessionId) return refuse("its runner left no saved session to resume. Use Retry instead.");
+  return { ok: true, sessionId: task.transport.nativeSessionId };
 }
-function outputPreview(output, maxLines) {
-  const lines = outputLines(output);
-  const shown = lines.slice(0, Math.max(0, maxLines));
-  return { lines: shown, hiddenLineCount: lines.length - shown.length };
+function canContinue(task) {
+  return continuability(task).ok;
 }
 
-// src/conversation/records.ts
-function settledMessage(id, role, text2, turnId) {
-  return { type: "message", id, role, text: text2, streaming: false, ...turnId ? { turnId } : {} };
-}
-function subagentBlock(id, { toolCallId, model, usage, turnId, ...fields }) {
+// src/services/SessionMessage.ts
+function serializeTask(t) {
   return {
-    type: "subagent",
-    id,
-    ...fields,
-    ...toolCallId ? { toolCallId } : {},
-    ...model ? { model } : {},
-    ...usage ? { usage } : {},
-    ...turnId ? { turnId } : {}
+    id: t.id,
+    order: t.order,
+    title: t.title,
+    type: t.type,
+    description: t.description,
+    dependencies: t.dependencies || [],
+    assignedRunner: t.assignedRunner,
+    assignedModel: t.assignedModel || null,
+    taskMode: t.taskMode || "build",
+    prompt: t.prompt || null,
+    subtasks: (t.subtasks || []).map(serializeTask),
+    userSteps: t.userSteps || void 0,
+    thinkingEffort: t.thinkingEffort || void 0,
+    autonomy: t.autonomy || void 0,
+    sliceType: t.sliceType || void 0,
+    userStoriesCovered: t.userStoriesCovered || void 0
   };
 }
-function usageBlock(id, { totals, bySubagent, contextFill }) {
-  return { type: "usage", id, totals, ...bySubagent ? { bySubagent } : {}, ...contextFill ? { contextFill } : {} };
-}
-var STATUS_OF_OUTCOME = {
-  success: "ok",
-  failure: "error",
-  refused: "denied",
-  denied: "denied",
-  not_executed: "interrupted"
-};
-function settledTool(call, step) {
-  return { ...call, status: STATUS_OF_OUTCOME[step.outcome], outcome: step.outcome, output: step.result, outputLineCount: outputLines(step.result).length };
+function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [], awaitingApproval = 0) {
+  return {
+    id: t.id,
+    status: t.status,
+    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null,
+    idleSince,
+    ...isolation ? { isolation } : {},
+    ...t.transport ? { transport: t.transport.fallback ? { kind: t.transport.kind, fallback: t.transport.fallback } : { kind: t.transport.kind } } : {},
+    ...t.status === "awaiting_user" && t.awaitingReason ? { awaitingReason: t.awaitingReason } : {},
+    ...queued.length > 0 ? { queued: queued.map((m) => ({ ...m })) } : {},
+    ...canContinue(t) ? { continuable: true } : {},
+    ...awaitingApproval > 0 ? { awaitingApproval } : {}
+  };
 }
-function pendingTool(id, { tool, toolLabel, args, toolCallId, turnId }) {
+function serializePlan(plan) {
   return {
-    type: "tool",
-    id,
-    tool,
-    headline: toolHeadline(tool, args, toolLabel),
-    args,
-    status: "pending",
-    output: "",
-    outputLineCount: 0,
-    ...toolCallId ? { toolCallId } : {},
-    ...toolLabel ? { toolLabel } : {},
-    ...turnId ? { turnId } : {}
+    tasks: plan.tasks.map(serializeTask),
+    runners: plan.runners,
+    generatedAt: plan.generatedAt,
+    conversationHistory: plan.conversationHistory,
+    prdMarkdown: plan.prdMarkdown,
+    queuedMessages: plan.queuedMessages
   };
 }
-function toolFromStep(id, step, turnId) {
-  return settledTool(pendingTool(id, { ...step, turnId }), step);
+function executionSummary(tasks) {
+  return {
+    total: tasks.length,
+    completed: tasks.filter((t) => t.status === "completed").length,
+    failed: tasks.filter((t) => t.status === "failed").length
+  };
 }
-function planMarker(content) {
-  const count = /(\d+) tasks?\b/.exec(content);
-  return { status: content.startsWith("Plan updated") ? "updated" : "generated", ...count ? { taskCount: Number(count[1]) } : {} };
+var CHECKPOINT_TRUNCATE_LENGTH = 120;
+function truncateCheckpointSummary(summary) {
+  const firstLine = summary.split("\n")[0].trim();
+  if (firstLine.length <= CHECKPOINT_TRUNCATE_LENGTH) return firstLine;
+  return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
 }
 
 // src/conversation/reduce.ts
 var EMPTY_CONVERSATION = { blocks: [], nextId: 1 };
-function findLastIndex(items, match) {
-  for (let i = items.length - 1; i >= 0; i--) if (match(items[i])) return i;
-  return -1;
-}
-function replaceAt(items, index, item) {
-  const next = items.slice();
-  next[index] = item;
-  return next;
-}
-function insertTop(blocks, block) {
-  const last = blocks[blocks.length - 1];
-  return last?.type === "usage" ? [...blocks.slice(0, -1), block, last] : [...blocks, block];
-}
-function append(view, make) {
-  return { ...view, blocks: insertTop(view.blocks, make(`b${view.nextId}`)), nextId: view.nextId + 1 };
-}
-function subagentAt(view, lane) {
-  const block = view.blocks[lane];
-  if (block.type !== "subagent") throw new Error(`block ${lane} is not a subagent`);
-  return block;
-}
-function laneBlocks(view, lane) {
-  return lane === null ? view.blocks : subagentAt(view, lane).children;
-}
-function setChildren(view, lane, children) {
-  return { ...view, blocks: replaceAt(view.blocks, lane, { ...subagentAt(view, lane), children }) };
-}
-function laneReplace(view, lane, index, block) {
-  if (lane === null) return { ...view, blocks: replaceAt(view.blocks, index, block) };
-  return setChildren(view, lane, replaceAt(subagentAt(view, lane).children, index, block));
-}
-function laneAppend(view, lane, make) {
-  if (lane === null) return append(view, make);
-  const children = [...subagentAt(view, lane).children, make(`b${view.nextId}`)];
-  return { ...setChildren(view, lane, children), nextId: view.nextId + 1 };
-}
-function isStreaming(block) {
-  return (block.type === "message" || block.type === "thinking") && block.streaming;
-}
-function sealed(block) {
-  return isStreaming(block) ? { ...block, streaming: false } : block;
-}
-function sealLane(view, lane, keep) {
-  const blocks = laneBlocks(view, lane);
-  if (!blocks.some((b, i) => i !== keep && isStreaming(b))) return view;
-  if (lane === null) return { ...view, blocks: view.blocks.map((b, i) => i === keep ? b : sealed(b)) };
-  return setChildren(view, lane, subagentAt(view, lane).children.map((b, i) => i === keep ? b : sealed(b)));
-}
-function appendOutput(view, lane, make) {
-  const next = laneAppend(view, lane, make);
-  return sealLane(next, lane, findLastIndex(laneBlocks(next, lane), (b) => b.type !== "usage"));
-}
 function isUnsettledSegment(block, turnId) {
   return block.type === "message" && block.turnId === turnId && block.segmentId !== void 0;
 }
@@ -1400,34 +1738,10 @@ function retractText(view, { turnId, segmentId }) {
   const blocks = view.blocks.filter((b) => !(isUnsettledSegment(b, turnId) && (segmentId === void 0 || b.segmentId === segmentId)));
   return dropBuildingPlan(blocks.length === view.blocks.length ? view : { ...view, blocks }, turnId, segmentId);
 }
-function subagentLane(view, subagentId, turnId) {
-  const existing = findLastIndex(view.blocks, (b) => b.type === "subagent" && b.subagentId === subagentId);
-  if (existing >= 0) return [view, existing];
-  const spawn = findLastIndex(view.blocks, (b) => b.type === "tool" && (b.spawns === subagentId || b.toolCallId === subagentId));
-  const call = view.blocks[spawn];
-  if (call?.type === "tool") {
-    const block = subagentBlock(call.id, {
-      subagentId,
-      brief: call.headline.keyArg,
-      status: "running",
-      children: [],
-      digest: "",
-      toolCallId: call.toolCallId,
-      turnId: call.turnId
-    });
-    return [{ ...view, blocks: replaceAt(view.blocks, spawn, block) }, spawn];
-  }
-  const next = append(view, (id) => subagentBlock(id, { subagentId, brief: "", status: "running", children: [], digest: "", turnId }));
-  return [next, findLastIndex(next.blocks, (b) => b.type === "subagent" && b.subagentId === subagentId)];
-}
-function updateSubagent(view, subagentId, turnId, update) {
-  const [next, lane] = subagentLane(view, subagentId, turnId);
-  return { ...next, blocks: replaceAt(next.blocks, lane, update(subagentAt(next, lane))) };
-}
-function startSubagent(view, { subagentId, brief, model, turnId }) {
+function startSubagent2(view, { subagentId, brief, model, turnId }) {
   return updateSubagent(view, subagentId, turnId, (block) => ({ ...block, ...brief ? { brief } : {}, ...model ? { model } : {} }));
 }
-function finishSubagent(view, { subagentId, outcome, digest, usage, turnId }) {
+function finishSubagent2(view, { subagentId, outcome, digest, usage, turnId }) {
   return updateSubagent(view, subagentId, turnId, (block) => ({
     ...block,
     status: outcome,
@@ -1436,35 +1750,17 @@ function finishSubagent(view, { subagentId, outcome, digest, usage, turnId }) {
     ...usage ? { usage } : {}
   }));
 }
-function think(view, text2, turnId, segmentId, subagentId) {
-  const [placed, lane] = subagentId ? subagentLane(view, subagentId, turnId) : [view, null];
-  const blocks = laneBlocks(placed, lane);
-  const lastIndex = findLastIndex(blocks, (b) => b.type !== "usage");
-  const last = blocks[lastIndex];
-  if (last?.type === "thinking" && last.streaming && last.segmentId === segmentId) {
-    return laneReplace(placed, lane, lastIndex, { ...last, text: last.text + text2 });
-  }
-  return appendOutput(placed, lane, (id) => ({
-    type: "thinking",
-    id,
-    text: text2,
-    streaming: true,
-    ...turnId ? { turnId } : {},
-    ...segmentId ? { segmentId } : {},
-    ...subagentId ? { subagentId } : {}
-  }));
-}
-function announceTool(view, call) {
+function announceTool2(view, call) {
   const spawns = call.tool === "spawn_research_agent" ? call.subagentId : void 0;
-  const [placed, lane] = call.subagentId && !spawns ? subagentLane(view, call.subagentId, call.turnId) : [view, null];
+  const [placed, lane] = laneOf(view, spawns ? void 0 : call.subagentId, call.turnId);
   return appendOutput(placed, lane, (id) => ({ ...pendingTool(id, call), ...spawns ? { spawns } : {} }));
 }
 function isPendingCallOf(block, step) {
   if (block.type !== "tool" || block.status !== "pending") return false;
   return step.toolCallId ? block.toolCallId === step.toolCallId : block.toolCallId === void 0 && block.tool === step.tool;
 }
-function settleTool(view, { step, turnId }) {
-  const [placed, lane] = step.subagentId ? subagentLane(view, step.subagentId, turnId) : [view, null];
+function settleTool2(view, { step, turnId }) {
+  const [placed, lane] = laneOf(view, step.subagentId, turnId);
   const blocks = laneBlocks(placed, lane);
   const i = findLastIndex(blocks, (b) => isPendingCallOf(b, step));
   const pending = blocks[i];
@@ -1497,7 +1793,7 @@ function markPlan(view, content, turnId) {
   }
   return append(view, (id) => ({ type: "plan", id, text: "", ...marker }));
 }
-function requestApproval(view, { id: approvalId, kind, subject, scope, detail, turnId }) {
+function requestApproval2(view, { id: approvalId, kind, subject, scope, detail, turnId }) {
   return append(view, (id) => ({
     type: "approval",
     id,
@@ -1510,13 +1806,13 @@ function requestApproval(view, { id: approvalId, kind, subject, scope, detail, t
     ...turnId ? { turnId } : {}
   }));
 }
-function settleApproval(view, { id, granted }) {
+function settleApproval2(view, { id, granted }) {
   const i = findLastIndex(view.blocks, (b) => b.type === "approval" && b.approvalId === id);
   const request = view.blocks[i];
   if (request?.type !== "approval") return view;
   return { ...view, blocks: replaceAt(view.blocks, i, { ...request, status: granted ? "granted" : "denied", decidedBy: "asked" }) };
 }
-function decideApproval(view, { kind, subject, scope, detail, granted, source }) {
+function decideApproval2(view, { kind, subject, scope, detail, granted, source }) {
   return append(view, (id) => ({
     type: "approval",
     id,
@@ -1528,28 +1824,14 @@ function decideApproval(view, { kind, subject, scope, detail, granted, source })
     ...detail ? { detail } : {}
   }));
 }
-function reportUsage(view, message) {
-  if (!isMeasured(message.totals)) return view;
-  const last = view.blocks[view.blocks.length - 1];
-  const line = usageBlock(last?.type === "usage" ? last.id : `b${view.nextId}`, message);
-  if (last?.type === "usage") return { ...view, blocks: replaceAt(view.blocks, view.blocks.length - 1, line) };
-  return { ...view, blocks: [...view.blocks, line], nextId: view.nextId + 1 };
-}
-function closeBlock(block, interrupted) {
-  return interrupted && block.type === "tool" && block.status === "pending" ? { ...block, status: "interrupted" } : sealed(block);
-}
-function closeSubagent(block, cut) {
-  const children = block.children.map((c) => closeBlock(c, cut !== null));
-  const status = cut && block.status === "running" ? cut : block.status;
-  return status === block.status && children.every((c, i) => c === block.children[i]) ? block : { ...block, status, children };
+function reportUsage2(view, message) {
+  return isMeasured(message.totals) ? setUsageLine(view, message) : view;
 }
-function endTurn(view, { turnId, outcome }) {
+function endTurn2(view, { turnId, outcome }) {
   let next = dropBuildingPlan(view, turnId);
   const planText = outcome === "plan" ? finalSegmentIndex(next.blocks, turnId, true) : -1;
   if (planText >= 0) next = { ...next, blocks: next.blocks.filter((_, i) => i !== planText) };
-  const cut = outcome === "stopped" ? "stopped" : outcome === "error" ? "failed" : null;
-  const blocks = next.blocks.map((b) => b.type === "subagent" ? closeSubagent(b, cut) : closeBlock(b, cut !== null));
-  return blocks.every((b, i) => b === next.blocks[i]) ? next : { ...next, blocks };
+  return closeOpenBlocks(next, outcome === "stopped" ? "stopped" : outcome === "error" ? "failed" : null);
 }
 function markCompaction(view, summary) {
   const i = findLastIndex(view.blocks, (b) => b.type === "message" && b.role === "planner" && b.turnId === void 0 && b.text === summary);
@@ -1586,27 +1868,27 @@ function reduceConversation(view, input) {
     case "planner_thinking_delta":
       return think(view, input.text, input.turnId, input.segmentId, input.subagentId);
     case "research_step":
-      return announceTool(view, input);
+      return announceTool2(view, input);
     case "research_step_done":
-      return settleTool(view, input);
+      return settleTool2(view, input);
     case "subagent_started":
-      return startSubagent(view, input);
+      return startSubagent2(view, input);
     case "subagent_finished":
-      return finishSubagent(view, input);
+      return finishSubagent2(view, input);
     case "plan_token":
       return streamPlan(view, input);
     case "plan_generated":
       return syncTranscript(view, input);
     case "planner_turn_ended":
-      return endTurn(view, input);
+      return endTurn2(view, input);
     case "approval_request":
-      return requestApproval(view, input);
+      return requestApproval2(view, input);
     case "approval_settled":
-      return settleApproval(view, input);
+      return settleApproval2(view, input);
     case "approval_decided":
-      return decideApproval(view, input);
+      return decideApproval2(view, input);
     case "planner_usage":
-      return reportUsage(view, input);
+      return reportUsage2(view, input);
     default:
       return view;
   }
@@ -1776,6 +2058,19 @@ export {
   isMeasured,
   usageLine,
   plannerContextFill,
+  mapAgentTool,
+  normalizeAgentArgs,
+  flattenTerminalOutput,
+  renderTerminalOutput,
+  renderCleanCapture,
+  toolHeadline,
+  outputLines,
+  outputPreview,
+  EMPTY_TASK_LOG,
+  runnerToolSubject,
+  reduceTaskLog,
+  replayTaskLog,
+  capConflictFiles,
   effectiveAllowlist,
   filterModelsForPrompt,
   clampThinkingEffort,
@@ -1794,18 +2089,14 @@ export {
   applyTaskOps,
   summarizeToolCall,
   classifyOutcome,
-  flattenTerminalOutput,
-  renderTerminalOutput,
-  renderCleanCapture,
+  continuability,
+  canContinue,
   serializeTask,
   serializeTaskStatus,
   serializePlan,
   executionSummary,
   CHECKPOINT_TRUNCATE_LENGTH,
   truncateCheckpointSummary,
-  toolHeadline,
-  outputLines,
-  outputPreview,
   EMPTY_CONVERSATION,
   reduceConversation,
   fromTranscript,
@@ -1821,4 +2112,4 @@ export {
   hasHiddenDetail,
   taskStartedNotice
 };
-//# sourceMappingURL=chunk-KLN7ELXO.mjs.map
+//# sourceMappingURL=chunk-ROVYWEBI.mjs.map