@ordewell/core 0.5.4 → 0.5.6

package/dist/chunk-ROVYWEBI.mjs

@@ -0,0 +1,2115 @@
+import {
+  PlanParseError,
+  TASK_OPS_ENVELOPE_KEY,
+  addTaskToPlan,
+  createTask,
+  escapeControlCharsInStrings,
+  extractObjectsWithKey,
+  flattenTasks,
+  removeTaskFromPlan,
+  renumberTasks,
+  stripTrailingCommas,
+  updateTaskInPlan
+} from "./chunk-EDGUFCIR.mjs";
+
+// src/models/Usage.ts
+function partedPromptUsage(parts) {
+  const reported = [parts.uncached, parts.cacheRead, parts.cacheWrite].filter((n) => n !== void 0);
+  return {
+    ...reported.length > 0 ? { inputTokens: reported.reduce((a, b) => a + b, 0) } : {},
+    ...parts.cacheRead !== void 0 ? { cachedInputTokens: parts.cacheRead } : {}
+  };
+}
+var TOKEN_FIELDS = ["inputTokens", "outputTokens", "cachedInputTokens"];
+function addUsage(totals, record) {
+  const next = { ...totals };
+  for (const field of TOKEN_FIELDS) {
+    const reported = record[field];
+    if (reported !== void 0) next[field] = (totals[field] ?? 0) + reported;
+  }
+  if (record.reportedCost) {
+    const { amount, currency } = record.reportedCost;
+    next.reportedCost = { ...totals.reportedCost, [currency]: (totals.reportedCost?.[currency] ?? 0) + amount };
+  }
+  return next;
+}
+function addPlannerUsage(usage, record) {
+  const next = { ...usage, totals: addUsage(usage.totals, record) };
+  if (record.subagentId) {
+    next.bySubagent = { ...usage.bySubagent, [record.subagentId]: addUsage(usage.bySubagent?.[record.subagentId] ?? {}, record) };
+    return next;
+  }
+  if (record.inputTokens !== void 0) next.lastPromptTokens = record.inputTokens;
+  if (record.contextWindow !== void 0 && record.contextWindow > 0) next.contextWindow = record.contextWindow;
+  return next;
+}
+function isMeasured(totals) {
+  return totals.inputTokens !== void 0 || totals.outputTokens !== void 0 || totals.cachedInputTokens !== void 0 || Object.keys(totals.reportedCost ?? {}).length > 0;
+}
+function usageLine(usage) {
+  const contextFill = plannerContextFill(usage);
+  return {
+    totals: usage.totals,
+    ...usage.bySubagent ? { bySubagent: usage.bySubagent } : {},
+    ...contextFill ? { contextFill } : {}
+  };
+}
+function plannerContextFill(usage) {
+  if (usage.lastPromptTokens === void 0 || usage.contextWindow === void 0 || usage.contextWindow <= 0) return void 0;
+  return { usedTokens: usage.lastPromptTokens, windowTokens: usage.contextWindow };
+}
+
+// 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 };
+  }
+  return { tool: "agent_tool", toolLabel: name };
+}
+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(" ");
+    }
+  }
+  if (tool === "fetch") alias("uri", "url");
+  if (tool === "web_search") alias("q", "query");
+  return out;
+}
+
+// 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();
+            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;
+      }
+      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 (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 (ch === "\r") {
+      col = 1;
+      i++;
+      continue;
+    }
+    if (ch === "\n") {
+      row++;
+      i++;
+      continue;
+    }
+    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++;
+  }
+  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);
+  }
+  const firstText = Object.values(args).find((v) => typeof v === "string" && v.trim() !== "");
+  return firstText ? oneLine(firstText) : "";
+}
+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 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;
+}
+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 };
+}
+
+// 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 }) {
+  return {
+    type: "subagent",
+    id,
+    ...fields,
+    ...toolCallId ? { toolCallId } : {},
+    ...model ? { model } : {},
+    ...usage ? { usage } : {},
+    ...turnId ? { turnId } : {}
+  };
+}
+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 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 } : {}
+  };
+}
+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];
+  }
+  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 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 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 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 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 });
+  }
+  return appendOutput(next, lane, make);
+}
+function agentText(view, text2) {
+  return streamWhole(view, null, TEXT_STREAM, text2, (id) => settledMessage(id, "agent", blockText(text2)));
+}
+function agentTextDelta(view, text2) {
+  return streamDelta(view, null, TEXT_STREAM, text2, (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true }));
+}
+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;
+  }
+}
+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 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;
+    }
+    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;
+}
+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)
+      }
+    };
+  };
+  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]) });
+      }
+      const discovered = modelsByRunner?.[task.assignedRunner]?.[0];
+      if (discovered) {
+        return clampVariant({ ...task, assignedModel: assignmentFor(task.assignedRunner, discovered.modelId) });
+      }
+      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 (allowed && !allowed.includes(modelId)) {
+        return { ok: false, error: `Model "${modelId}" is excluded by the allowlist for runner "${runner}"` };
+      }
+    }
+  }
+  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;
+      }
+      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}`);
+          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;
+      }
+      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;
+          }
+          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;
+      }
+      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;
+          }
+          changes.dependencies = ids.filter((id) => id !== target.id);
+        }
+        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;
+      }
+      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/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 canContinue(task) {
+  return continuability(task).ok;
+}
+
+// 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, 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 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/conversation/reduce.ts
+var EMPTY_CONVERSATION = { blocks: [], nextId: 1 };
+function isUnsettledSegment(block, turnId) {
+  return block.type === "message" && block.turnId === turnId && block.segmentId !== void 0;
+}
+function isBuildingPlan(block, turnId) {
+  return block.type === "plan" && block.status === "building" && block.turnId === turnId;
+}
+function finalSegmentIndex(blocks, turnId, pastPlan = false) {
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const block = blocks[i];
+    if (block.type === "usage" || block.type === "thinking" || block.type === "approval" || pastPlan && block.type === "plan") continue;
+    if (block.turnId !== turnId) continue;
+    return isUnsettledSegment(block, turnId) ? i : -1;
+  }
+  return -1;
+}
+function openTurn(view, turnId, prompt) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "message" && b.role === "user");
+  const sent = view.blocks[i];
+  if (sent?.type === "message" && sent.turnId === void 0 && sent.text === prompt) {
+    return { ...view, blocks: replaceAt(view.blocks, i, { ...sent, turnId }) };
+  }
+  return append(view, (id) => settledMessage(id, "user", prompt, turnId));
+}
+function streamText(view, { turnId, segmentId, text: text2 }) {
+  const i = findLastIndex(view.blocks, (b) => isUnsettledSegment(b, turnId) && b.segmentId === segmentId);
+  const segment = view.blocks[i];
+  if (segment?.type === "message") {
+    return sealLane(laneReplace(view, null, i, { ...segment, text: segment.text + text2, streaming: true }), null, i);
+  }
+  return appendOutput(view, null, (id) => ({ type: "message", id, role: "planner", text: text2, streaming: true, turnId, segmentId }));
+}
+function dropBuildingPlan(view, turnId, segmentId) {
+  const blocks = view.blocks.filter((b) => !(isBuildingPlan(b, turnId) && (segmentId === void 0 || b.segmentId === segmentId)));
+  return blocks.length === view.blocks.length ? view : { ...view, blocks };
+}
+function settleReply(view, { content, turnId }) {
+  if (turnId !== void 0) {
+    const i = finalSegmentIndex(view.blocks, turnId);
+    if (i >= 0) {
+      return dropBuildingPlan({ ...view, blocks: replaceAt(view.blocks, i, settledMessage(view.blocks[i].id, "planner", content, turnId)) }, turnId);
+    }
+  }
+  return append(dropBuildingPlan(view, turnId), (id) => settledMessage(id, "planner", content, turnId));
+}
+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 startSubagent2(view, { subagentId, brief, model, turnId }) {
+  return updateSubagent(view, subagentId, turnId, (block) => ({ ...block, ...brief ? { brief } : {}, ...model ? { model } : {} }));
+}
+function finishSubagent2(view, { subagentId, outcome, digest, usage, turnId }) {
+  return updateSubagent(view, subagentId, turnId, (block) => ({
+    ...block,
+    status: outcome,
+    digest,
+    children: block.children.map(sealed),
+    ...usage ? { usage } : {}
+  }));
+}
+function announceTool2(view, call) {
+  const spawns = call.tool === "spawn_research_agent" ? call.subagentId : void 0;
+  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 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];
+  if (pending?.type === "tool") return laneReplace(placed, lane, i, settledTool(pending, step));
+  if (lane === null && step.toolCallId && blocks.some((b) => b.type === "subagent" && b.toolCallId === step.toolCallId)) return view;
+  return laneAppend(placed, lane, (id) => toolFromStep(id, step, turnId));
+}
+function streamPlan(view, { token, turnId, segmentId }) {
+  const i = findLastIndex(view.blocks, (b) => isBuildingPlan(b, turnId));
+  const building = view.blocks[i];
+  if (building?.type === "plan" && building.segmentId === segmentId) {
+    return { ...view, blocks: replaceAt(view.blocks, i, { ...building, text: building.text + token }) };
+  }
+  return append(dropBuildingPlan(view, turnId), (id) => ({
+    type: "plan",
+    id,
+    status: "building",
+    text: token,
+    ...turnId ? { turnId } : {},
+    ...segmentId ? { segmentId } : {}
+  }));
+}
+function markPlan(view, content, turnId) {
+  const marker = planMarker(content);
+  const i = findLastIndex(view.blocks, (b) => isBuildingPlan(b, turnId));
+  const building = view.blocks[i];
+  if (building?.type === "plan") {
+    const settled = { type: "plan", id: building.id, ...marker, text: "", ...building.turnId ? { turnId: building.turnId } : {} };
+    return { ...view, blocks: replaceAt(view.blocks, i, settled) };
+  }
+  return append(view, (id) => ({ type: "plan", id, text: "", ...marker }));
+}
+function requestApproval2(view, { id: approvalId, kind, subject, scope, detail, turnId }) {
+  return append(view, (id) => ({
+    type: "approval",
+    id,
+    approvalId,
+    kind,
+    subject,
+    scope,
+    status: "pending",
+    ...detail ? { detail } : {},
+    ...turnId ? { turnId } : {}
+  }));
+}
+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 decideApproval2(view, { kind, subject, scope, detail, granted, source }) {
+  return append(view, (id) => ({
+    type: "approval",
+    id,
+    kind,
+    subject,
+    scope,
+    status: granted ? "granted" : "denied",
+    decidedBy: source,
+    ...detail ? { detail } : {}
+  }));
+}
+function reportUsage2(view, message) {
+  return isMeasured(message.totals) ? setUsageLine(view, message) : view;
+}
+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) };
+  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);
+  const announced = view.blocks[i];
+  if (announced?.type === "message") return { ...view, blocks: replaceAt(view.blocks, i, { ...announced, role: "system" }) };
+  return append(view, (id) => settledMessage(id, "system", summary));
+}
+function syncTranscript(view, { plan, turnId }) {
+  const history = plan.conversationHistory ?? [];
+  const committed = findLastIndex(history, (e) => e.kind === "plan_generated");
+  let next = view;
+  let latest = view.transcriptAt;
+  for (const [i, entry] of history.entries()) {
+    const isNew = view.transcriptAt === void 0 || entry.timestamp > view.transcriptAt;
+    if (isNew && entry.kind === "plan_generated") next = markPlan(next, entry.content, i === committed ? turnId : void 0);
+    if (isNew && entry.kind === "system") next = append(next, (id) => settledMessage(id, "system", entry.content));
+    if (isNew && entry.kind === "compaction") next = markCompaction(next, entry.content);
+    if (latest === void 0 || entry.timestamp > latest) latest = entry.timestamp;
+  }
+  return next === view && latest === view.transcriptAt ? view : { ...next, transcriptAt: latest };
+}
+function reduceConversation(view, input) {
+  switch (input.type) {
+    case "local_entry":
+      return append(view, (id) => settledMessage(id, input.role, input.text));
+    case "planner_turn_started":
+      return input.prompt === void 0 ? view : openTurn(view, input.turnId, input.prompt);
+    case "planner_text_delta":
+      return streamText(view, input);
+    case "planner_message":
+      return settleReply(view, input);
+    case "planner_text_retracted":
+      return retractText(view, input);
+    case "planner_thinking_delta":
+      return think(view, input.text, input.turnId, input.segmentId, input.subagentId);
+    case "research_step":
+      return announceTool2(view, input);
+    case "research_step_done":
+      return settleTool2(view, input);
+    case "subagent_started":
+      return startSubagent2(view, input);
+    case "subagent_finished":
+      return finishSubagent2(view, input);
+    case "plan_token":
+      return streamPlan(view, input);
+    case "plan_generated":
+      return syncTranscript(view, input);
+    case "planner_turn_ended":
+      return endTurn2(view, input);
+    case "approval_request":
+      return requestApproval2(view, input);
+    case "approval_settled":
+      return settleApproval2(view, input);
+    case "approval_decided":
+      return decideApproval2(view, input);
+    case "planner_usage":
+      return reportUsage2(view, input);
+    default:
+      return view;
+  }
+}
+
+// src/conversation/transcript.ts
+var USER = 0;
+var RESEARCH = 1;
+var SETTLED = 2;
+function fromEntry(entry) {
+  if (entry.kind === "plan_generated") return (id) => ({ type: "plan", id: id(), text: "", ...planMarker(entry.content) });
+  const role = entry.kind === "system" || entry.kind === "compaction" ? "system" : entry.role === "user" ? "user" : "planner";
+  return (id) => settledMessage(id(), role, entry.content);
+}
+function spawnBrief(step) {
+  try {
+    const args = JSON.parse(step.args);
+    const prompt = args && typeof args === "object" ? args.prompt : void 0;
+    return typeof prompt === "string" ? prompt.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function spawnedBy(step, unclaimed) {
+  const byId = unclaimed.find((e) => e.subagentId === step.toolCallId);
+  if (byId) return byId;
+  if (step.tool !== "spawn_research_agent") return void 0;
+  const brief = spawnBrief(step);
+  return brief === void 0 ? void 0 : unclaimed.find((e) => e.brief === brief);
+}
+function research(log) {
+  const subagents = log.filter((e) => "type" in e && e.type === "subagent");
+  const ownSubagent = new Set(subagents.map((e) => e.subagentId));
+  const unclaimed = [...subagents];
+  const spawnCall = /* @__PURE__ */ new Map();
+  const placed = [];
+  for (const entry of log) {
+    if ("type" in entry) {
+      if (entry.type === "system") placed.push({ at: entry.timestamp, rank: RESEARCH, build: (id) => settledMessage(id(), "system", entry.content) });
+      continue;
+    }
+    if (entry.subagentId && ownSubagent.has(entry.subagentId)) continue;
+    const spawned = spawnedBy(entry, unclaimed);
+    if (spawned) {
+      unclaimed.splice(unclaimed.indexOf(spawned), 1);
+      spawnCall.set(spawned.subagentId, entry.toolCallId);
+      continue;
+    }
+    placed.push({ at: entry.timestamp, rank: RESEARCH, build: (id) => toolFromStep(id(), entry) });
+  }
+  for (const entry of subagents) {
+    const toolCallId = spawnCall.get(entry.subagentId);
+    const steps = log.filter((e) => !("type" in e) && e.subagentId === entry.subagentId);
+    placed.push({
+      at: entry.timestamp,
+      rank: RESEARCH,
+      build: (id) => subagentBlock(id(), {
+        subagentId: entry.subagentId,
+        brief: entry.brief,
+        status: entry.outcome,
+        digest: entry.digest,
+        children: steps.map((step) => toolFromStep(id(), step)),
+        toolCallId,
+        model: entry.model,
+        usage: entry.usage
+      })
+    });
+  }
+  return placed;
+}
+function fromTranscript(conversationHistory, researchLog, plannerUsage) {
+  const history = conversationHistory ?? [];
+  const compacted = history[0]?.kind === "compaction" ? history[0] : void 0;
+  const kept = compacted ? history.slice(1) : history;
+  const cutoff = compacted ? kept[0]?.timestamp ?? compacted.timestamp : "";
+  const placed = [
+    ...kept.map((entry) => ({ at: entry.timestamp, rank: entry.role === "user" && !entry.kind ? USER : SETTLED, build: fromEntry(entry) })),
+    ...research(researchLog ?? []).filter((item) => item.at >= cutoff)
+  ];
+  placed.sort((a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : a.rank - b.rank);
+  if (compacted) placed.unshift({ at: "", rank: SETTLED, build: fromEntry(compacted) });
+  let nextId = 1;
+  const id = () => `b${nextId++}`;
+  const blocks = placed.map((item) => item.build(id));
+  if (plannerUsage && isMeasured(plannerUsage.totals)) blocks.push(usageBlock(id(), usageLine(plannerUsage)));
+  const transcriptAt = history.reduce((latest, e) => latest === void 0 || e.timestamp > latest ? e.timestamp : latest, void 0);
+  return { blocks, nextId, ...transcriptAt ? { transcriptAt } : {} };
+}
+
+// src/conversation/promptHold.ts
+var EMPTY_HOLD = [];
+function holdPrompt(hold, text2) {
+  return [...hold, text2];
+}
+function drainNext(hold) {
+  const [text2, ...rest] = hold;
+  return text2 === void 0 ? void 0 : { text: text2, rest };
+}
+function unsendLatest(hold) {
+  if (hold.length === 0) return void 0;
+  return { text: hold[hold.length - 1], rest: hold.slice(0, -1) };
+}
+function unsendAll(hold) {
+  if (hold.length === 0) return void 0;
+  return { text: hold.join("\n"), rest: EMPTY_HOLD };
+}
+function aheadOfDraft(text2, draft) {
+  return draft ? `${text2}
+${draft}` : text2;
+}
+
+// src/conversation/turnGate.ts
+var NO_TURN = { open: null, stopped: null };
+var TURN_STREAM = /* @__PURE__ */ new Set([
+  "planner_text_delta",
+  "planner_thinking_delta",
+  "planner_text_retracted",
+  "planner_message",
+  "plan_token",
+  "research_step",
+  "research_step_done",
+  "subagent_started",
+  "subagent_finished",
+  "planner_turn_ended"
+]);
+function cutOff(gate, input) {
+  if (gate.stopped === null || !TURN_STREAM.has(input.type)) return false;
+  const turnId = "turnId" in input ? input.turnId : void 0;
+  return turnId === void 0 || turnId === gate.stopped;
+}
+function withGate(live, gate) {
+  return gate.open === live.gate.open && gate.stopped === live.gate.stopped ? live : { ...live, gate };
+}
+function followTurn(view, gate, input) {
+  const live = { view, gate };
+  if (input.type === "planner_turn_started") {
+    return withGate({ view: reduceConversation(view, input), gate }, { open: input.turnId, stopped: null });
+  }
+  if (cutOff(gate, input)) {
+    return input.type === "planner_turn_ended" ? withGate(live, { ...gate, stopped: null }) : live;
+  }
+  const next = { view: reduceConversation(view, input), gate };
+  return input.type === "planner_turn_ended" && input.turnId === gate.open ? withGate(next, { ...gate, open: null }) : next;
+}
+function stopTurn(view, gate) {
+  if (gate.open === null) return { view, gate };
+  return {
+    view: reduceConversation(view, { type: "planner_turn_ended", turnId: gate.open, outcome: "stopped" }),
+    gate: { open: null, stopped: gate.open }
+  };
+}
+
+// src/conversation/detail.ts
+function hasHiddenDetail(blocks) {
+  return blocks.some((b) => b.type === "thinking" || b.type === "tool" || b.type === "subagent");
+}
+
+// src/conversation/notices.ts
+function taskStartedNotice(title, runner) {
+  return runner ? `Started "${title}" \xB7 ${runner}` : `Started "${title}"`;
+}
+
+export {
+  partedPromptUsage,
+  addUsage,
+  addPlannerUsage,
+  isMeasured,
+  usageLine,
+  plannerContextFill,
+  mapAgentTool,
+  normalizeAgentArgs,
+  flattenTerminalOutput,
+  renderTerminalOutput,
+  renderCleanCapture,
+  toolHeadline,
+  outputLines,
+  outputPreview,
+  EMPTY_TASK_LOG,
+  runnerToolSubject,
+  reduceTaskLog,
+  replayTaskLog,
+  capConflictFiles,
+  effectiveAllowlist,
+  filterModelsForPrompt,
+  clampThinkingEffort,
+  coerceAssignments,
+  validateTaskEdit,
+  taskOpsProtocol,
+  textHasTaskOps,
+  parseTaskOpsJson,
+  taskOpRefs,
+  refMatchesTask,
+  canMergeTasks,
+  dependentsOf,
+  dependencyCandidates,
+  canSetDependencies,
+  canSplitTask,
+  applyTaskOps,
+  summarizeToolCall,
+  classifyOutcome,
+  continuability,
+  canContinue,
+  serializeTask,
+  serializeTaskStatus,
+  serializePlan,
+  executionSummary,
+  CHECKPOINT_TRUNCATE_LENGTH,
+  truncateCheckpointSummary,
+  EMPTY_CONVERSATION,
+  reduceConversation,
+  fromTranscript,
+  EMPTY_HOLD,
+  holdPrompt,
+  drainNext,
+  unsendLatest,
+  unsendAll,
+  aheadOfDraft,
+  NO_TURN,
+  followTurn,
+  stopTurn,
+  hasHiddenDetail,
+  taskStartedNotice
+};
+//# sourceMappingURL=chunk-ROVYWEBI.mjs.map