@ordewell/core 0.10.4 → 0.10.6

package/dist/{chunk-FH6M5QZG.mjs → chunk-DMG4ISUG.mjs}

@@ -1,20 +1,42 @@
 import {
-  NOT_STARTED,
-  WAITS_FOR_APPROVAL_LABEL,
-  approvalLabel,
-  awaitingLabel,
-  isTaskRunning,
-  resumeLabel,
-  taskStatusKind
-} from "./chunk-A57ITQE7.mjs";
+  MANUAL_NOT_READ_ONLY,
+  MODE_NOT_THE_PLANNERS,
+  OPS_NOT_READ_ONLY,
+  PlanParseError,
+  TASK_OPS_ENVELOPE_KEY,
+  checkPlanInvariants,
+  detectCycle,
+  effectiveAllowlist,
+  escapeControlCharsInStrings,
+  extractObjectsWithKey,
+  opsPlacementRefusal,
+  plannedTask,
+  resolveAssignment,
+  stripTrailingCommas,
+  taggedReadOnlyMode,
+  taskWhere
+} from "./chunk-H7QX32BH.mjs";
 import {
+  addTaskToPlan,
+  canSetDependencies,
+  flattenTasks,
+  flattenTasksWithParents,
+  inheritedOps,
+  opsFlag,
   pausedOnLimit,
   rejoinPlanTree,
+  removeTaskFromPlan,
+  renumberTasks,
+  resolveTaskRef,
+  skillNames,
   taskOrderLabel,
+  taskPlacement,
   taskRefOf,
   titledTaskRef,
-  titledTaskRefOf
-} from "./chunk-SM6BV6XS.mjs";
+  titledTaskRefOf,
+  updateTaskInPlan,
+  walkPlan
+} from "./chunk-EEE2GBLG.mjs";
 
 // src/models/Usage.ts
 function partedPromptUsage(parts) {
@@ -84,8 +106,21 @@ function addAttemptUsage(usage, record, now) {
   const folded = addPlannerUsage(usage, record);
   return { ...usage, ...folded, lastPromptTokens: folded.lastPromptTokens, contextWindow: folded.contextWindow, wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)) };
 }
-function endAttemptUsage(usage, now) {
-  return { ...usage, endedAt: now, wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)) };
+function endAttemptUsage(usage, now, runnerSessionCost, sessionId) {
+  return {
+    ...usage,
+    endedAt: now,
+    wallTimeMs: Math.max(0, Date.parse(now) - Date.parse(usage.startedAt)),
+    ...sessionId ? { sessionId } : {},
+    ...runnerSessionCost ? { runnerSessionCost } : {}
+  };
+}
+function countedSessionCost(attempts, sessionId) {
+  return [...attempts ?? []].reverse().find((usage) => usage.runnerSessionCost?.sessionId === sessionId)?.runnerSessionCost;
+}
+function resumedSessionWindow(attempts, runner, attempt, sessionId) {
+  const last = [...attempts ?? []].reverse().find((usage) => usage.attempt !== attempt && usage.runner === runner && usage.sessionId === sessionId && usage.contextWindow !== void 0);
+  return last ? { source: last.source, model: last.model, contextWindow: last.contextWindow } : void 0;
 }
 function addUsageTotals(totals, addition) {
   let next = addUsage(totals, { source: "", inputTokens: addition.inputTokens, outputTokens: addition.outputTokens, cachedInputTokens: addition.cachedInputTokens });
@@ -114,6 +149,16 @@ function planUsage(tasks) {
   }
   return result;
 }
+function taskUsageSummary(task) {
+  const attempts = task.attemptUsage ?? [];
+  const latest = attempts.at(-1);
+  const contextFill = latest ? plannerContextFill(latest) : void 0;
+  return {
+    totals: attempts.reduce((sum, attempt) => addUsageTotals(sum, attempt.totals), {}),
+    attempts: attempts.length,
+    ...contextFill ? { contextFill } : {}
+  };
+}
 
 // src/services/harness/agentTools.ts
 var KNOWN_TOOLS = {
@@ -507,7 +552,7 @@ function closeOpenBlocks(view, cut) {
 
 // src/conversation/taskLog.ts
 var EMPTY_TASK_LOG = { blocks: [], nextId: 1, queued: [], working: false, streams: {} };
-var TEXT_STREAM = "text";
+var textStream = (runId) => runId === void 0 ? "text" : `text:${runId}`;
 var thinkingStream = (subagentId) => `thinking:${subagentId ?? ""}`;
 function withoutStream(view, key) {
   if (!(key in view.streams)) return view;
@@ -524,35 +569,43 @@ function openStream(view, lane, key) {
   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);
+function streamBlock(view, lane, key) {
+  const id = view.streams[key];
+  return id === void 0 ? -1 : findLastIndex(laneBlocks(view, lane), (b) => b.id === id);
+}
+function streamDelta(view, lane, key, text2, make, anywhere = false) {
+  const i = anywhere ? streamBlock(view, lane, key) : 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 i = streamBlock(view, lane, key);
+  const streamed = laneBlocks(view, lane)[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) {
-  const next = streamWhole(view, null, TEXT_STREAM, text2, (id) => settledMessage(id, "agent", blockText(text2)));
-  return { ...next, latestText: next.nextId > view.nextId ? `b${view.nextId}` : view.streams[TEXT_STREAM] };
+function openedText(view, next) {
+  return next.nextId > view.nextId ? { ...next, latestText: `b${view.nextId}` } : next;
 }
-function agentTextDelta(view, text2) {
-  const next = streamDelta(view, null, TEXT_STREAM, text2, (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true }));
-  return { ...next, latestText: next.streams[TEXT_STREAM] };
+function agentText(view, { runId, text: text2 }) {
+  return openedText(view, streamWhole(view, null, textStream(runId), text2, (id) => settledMessage(id, "agent", blockText(text2))));
+}
+function agentTextDelta(view, { runId, text: text2 }) {
+  const make = (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true });
+  return openedText(view, streamDelta(view, null, textStream(runId), text2, make, runId !== void 0));
 }
 function failTurn(view, message) {
   const repeated = view.blocks.find((b) => b.id === view.latestText);
-  const settled = repeated?.type === "message" && repeated.role === "agent" && sameMessage(repeated.text, message) ? withoutStream({ ...view, blocks: view.blocks.filter((b) => b !== repeated) }, TEXT_STREAM) : view;
+  const settled = repeated?.type === "message" && repeated.role === "agent" && sameMessage(repeated.text, message) ? {
+    ...view,
+    blocks: view.blocks.filter((b) => b !== repeated),
+    streams: Object.fromEntries(Object.entries(view.streams).filter(([, id]) => id !== repeated.id))
+  } : view;
   return appendOutput({ ...settled, latestText: void 0 }, null, (id) => settledMessage(id, "error", message));
 }
 function thinkingBlock(id, text2, streaming, subagentId) {
@@ -682,6 +735,12 @@ function commandOutput(view, { text: text2 }) {
   return { ...view, blocks: replaceAt(view.blocks, i, { ...block, output: block.output ? `${block.output}
 ${text2}` : text2 }) };
 }
+function modelSwitchNotice({ from, to, plan, kept }) {
+  if (!plan) return `Model changed in the runner: ${from.label ?? from.model} \u2192 ${to.label ?? to.model}${kept ? ` (${kept})` : ""}`;
+  const planned = plan.model ? `${plan.model.label ?? plan.model.model}${plan.effort ? `, ${plan.effort}` : ""}` : void 0;
+  if (!kept) return `Model changed in the runner: ${from.label ?? from.model} \u2192 ${to.label ?? to.model}; the plan now says ${planned ?? to.label ?? to.model}`;
+  return `The runner now answers on ${to.label ?? to.model}; ${planned ? `the plan still says ${planned}` : "the plan names no model"} (${kept})`;
+}
 function appendStep(view, make) {
   const next = append(view, make);
   return sealLane(next, null, findLastIndex(next.blocks, (b) => b.type !== "usage"));
@@ -727,7 +786,7 @@ function endCall(block) {
 function endOpenCalls(view) {
   let changed = false;
   const blocks = view.blocks.map((block) => {
-    const ended = block.type === "subagent" ? block.children.some((c) => c.type === "tool" && c.status === "pending") ? { ...block, children: block.children.map(endCall) } : block : block.type === "tool" ? endCall(block) : block;
+    const ended = block.type === "subagent" ? block.children.some((c) => c.type === "tool" && c.status === "pending") ? { ...block, children: block.children.map(endCall) } : block : block.type === "tool" ? endCall(block) : block.type === "command" && block.status === "running" ? { ...block, status: "stopped" } : block;
     if (ended !== block) changed = true;
     return ended;
   });
@@ -743,6 +802,8 @@ function reduceTaskLog(view, event) {
       return startCommand(view, event);
     case "command_output":
       return commandOutput(view, event);
+    case "model_switched":
+      return append(view, (id) => settledMessage(id, "system", modelSwitchNotice(event)));
     case "compaction":
       return appendStep(view, (id) => ({
         type: "compaction",
@@ -756,9 +817,9 @@ function reduceTaskLog(view, event) {
     case "turn_end":
       return endTurn(view, event);
     case "text_delta":
-      return agentTextDelta(view, event.text);
+      return agentTextDelta(view, event);
     case "text":
-      return agentText(view, event.text);
+      return agentText(view, event);
     case "thinking_delta":
       return thinkingDelta(view, event);
     case "thinking":
@@ -792,7 +853,7 @@ function reduceTaskLog(view, event) {
     case "approval_withdrawn":
       return settleApproval(view, event.approvalId, (block) => ({ ...block, status: "withdrawn" }));
     case "runner_ended":
-      return endOpenCalls(view);
+      return closeOpenBlocks({ ...endOpenCalls(view), working: false, streams: {}, latestText: void 0 }, "stopped");
     default:
       return view;
   }
@@ -801,7 +862,765 @@ function replayTaskLog(events, from = EMPTY_TASK_LOG) {
   return events.reduce(reduceTaskLog, from);
 }
 
+// src/taskRow/status.ts
+var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
+var NOT_STARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
+function taskStatusKind(task) {
+  switch (task.status) {
+    case "completed":
+      return "done";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "skipped";
+    case "blocked":
+      return "blocked";
+    case "awaiting_user":
+      return "awaiting";
+  }
+  if (!isTaskRunning(task)) return "todo";
+  return task.status === "in_progress" && task.idleSince ? "quiet" : "running";
+}
+var AWAITING_LABELS = {
+  input: "Waiting for your input",
+  checkpoint: "Checkpoint",
+  conflict: "Merge conflict",
+  "files-changed": "Changed tracked files",
+  "usage-limit": "Paused on a usage limit"
+};
+function awaitingLabel(task) {
+  return task.status === "awaiting_user" && task.awaitingReason ? AWAITING_LABELS[task.awaitingReason] : null;
+}
+function blockedByLabel(refs) {
+  return `Blocked by ${refs.join(", ")}`;
+}
+function skippedLabel(reason) {
+  return reason ? `Skipped: ${reason}` : "Skipped";
+}
+var WAITS_FOR_APPROVAL_LABEL = "Waits for your approval";
+function approvalLabel(count) {
+  if (!count) return null;
+  return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
+}
+function resumeTime(at, now = /* @__PURE__ */ new Date()) {
+  const clock = at.toLocaleTimeString("en-US", { hour: "numeric", minute: at.getMinutes() === 0 ? void 0 : "2-digit", hour12: true }).replace(/[ \u202f]([AP]M)$/i, (_m, meridiem) => meridiem.toLowerCase());
+  if (at.toDateString() === now.toDateString()) return clock;
+  return `${at.toLocaleDateString("en-US", { month: "short", day: "numeric" })}, ${clock}`;
+}
+function resumeLabel(task, now = /* @__PURE__ */ new Date()) {
+  if (task.status !== "awaiting_user" || task.awaitingReason !== "usage-limit" || !task.resumeAt) return null;
+  const at = new Date(task.resumeAt);
+  return Number.isNaN(at.getTime()) ? null : `Resumes at ${resumeTime(at, now)}`;
+}
+
+// src/services/TaskOps.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/services/TaskEditValidator.ts
+function lockedTaskRefusal(task, action = "changed") {
+  if (task.status === "in_progress") return `"${task.title}" is running and cannot be ${action} now: the user can stop it first, or change it after it finishes`;
+  if (task.status === "completed") return `"${task.title}" is completed and cannot be ${action}: rearm it to run it again, or add a new task for further work`;
+  return null;
+}
+var AI_ONLY_FIELDS = ["assignedModel", "taskMode", "autonomy", "ops"];
+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: include "userSteps" in this edit` };
+    }
+    return {
+      ok: true,
+      clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0),
+      // User tasks are held to HITL, so a flip that kept the AI task's slice would be refused by the plan's own rules.
+      ...target.sliceType !== "HITL" ? { set: { sliceType: "HITL" } } : {}
+    };
+  }
+  if (!changes.prompt || !changes.prompt.trim()) {
+    return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt: include "prompt" in this edit` };
+  }
+  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
+}
+function opsCheck(target, isSubtask, changes) {
+  if (!("ops" in changes) || !!changes.ops === !!target.ops) return null;
+  if (!NOT_STARTED.has(target.status)) {
+    return { ok: false, error: `"${target.title}" has started, so whether it is an ops task is fixed` };
+  }
+  if (!changes.ops) return null;
+  const refused = opsPlacementRefusal(changes.type ?? target.type, isSubtask);
+  return refused ? { ok: false, error: `"${target.title}" ${refused}` } : null;
+}
+function validateTaskEdit(actor, tasks, taskId, changes) {
+  const found = flattenTasksWithParents(tasks).find(({ task }) => task.id === taskId);
+  if (!found) return { ok: false, error: "Task not found" };
+  const { task: target, parent } = found;
+  const locked = actor === "planner" ? lockedTaskRefusal(target, "modified") : null;
+  if (locked) return { ok: false, error: locked };
+  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 ops = opsCheck(target, parent !== null, changes);
+  if (ops) return ops;
+  return coherence ?? { ok: true };
+}
+
+// src/services/TaskOps.ts
+var UPDATABLE_FIELDS = [
+  "title",
+  "description",
+  "prompt",
+  "dependencies",
+  "assignedRunner",
+  "assignedModel",
+  "taskMode",
+  "type",
+  "userSteps",
+  "autonomy",
+  "sliceType",
+  "ops",
+  "skills"
+];
+function taskOpsProtocol(executionNote = "", tools = false) {
+  const updateChanges = [...UPDATABLE_FIELDS.filter((f) => f !== "taskMode"), "thinkingEffort", "readOnly"].map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
+  return [
+    tools ? "- To modify specific tasks, call edit_plan, never a JSON reply. Its argument is:" : "- To modify specific tasks, reply with ONLY this JSON object:",
+    tools ? '  {"ops": [' : '  {"taskOps": [',
+    `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
+    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?,"readOnly"?,"ops"?},"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}}}`,
+    "  ]}",
+    tools ? "- For sweeping changes, you may instead call submit_plan with the full plan." : '- 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. "#N" is top-level task N; a subtask is named by its dotted label ("#2.1"), as the plan lists it.',
+    '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 ${tools ? "list_runners and list_models return" : "listed in <available_models>"}.`,
+    'Set "readOnly": true on a task that must not change any file, never on one that must run commands (tests, scripts, builds) or an ops task, and "readOnly": false to lift it; you never set "taskMode". A task you move, split or edit keeps being read-only or not unless you say otherwise, and so do the subtasks of a read-only task you add.',
+    'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
+    ...tools ? ["edit_plan checks the batch when you call it and answers with what it will change, or with the error to fix \u2014 call it again in the same reply. The edit is applied when your reply ends; edits you make in one reply join one batch."] : [],
+    '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", which also makes the task HITL) or the userSteps (flipping to "ai") are cleared automatically.',
+    `"skills" in "changes" REPLACES the task's whole skill list. To add one, send the names the plan block shows in its skills:[...] plus the new one; to drop one, send the rest; [] removes them all.`,
+    '"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, originalTree, liveTree, 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 by a later op in this batch and cannot be referenced yet` };
+    }
+    const id = handleId.get(s);
+    if (!id) return { error: `handle "${s}" was never resolved` };
+    return { id };
+  }
+  if (findInTasks(liveTree, s)) return { id: s };
+  const task = resolveTaskRef(originalTree, s);
+  return task ? { id: task.id } : { error: `task "${s}" not found` };
+}
+function updatableChanges(raw) {
+  const changes = {};
+  for (const key of UPDATABLE_FIELDS) {
+    if (raw && key in raw) changes[key] = raw[key];
+  }
+  if ("ops" in changes) changes.ops = opsFlag(changes.ops);
+  if ("skills" in changes) changes.skills = skillNames(changes.skills);
+  return changes;
+}
+function findInTasks(tasks, id) {
+  return taskPlacement(tasks, id)?.task;
+}
+function findTopLevel(tasks, id) {
+  return tasks.find((t) => t.id === id);
+}
+function isPinned(t) {
+  return t.status === "in_progress" || t.status === "completed";
+}
+function lockedInSubtree(parent) {
+  for (const sub of parent.subtasks ?? []) {
+    const locked = lockedTaskRefusal(sub, "removed") ?? lockedInSubtree(sub);
+    if (locked) return locked;
+  }
+  return null;
+}
+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 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 askedReadOnly(spec) {
+  return typeof spec?.readOnly === "boolean" ? spec.readOnly : void 0;
+}
+function isReadOnly(task, catalog) {
+  return task.taskMode !== void 0 && task.taskMode === taggedReadOnlyMode(catalog?.runnerModes?.[task.assignedRunner]);
+}
+function changedFields(target, written, landed, catalog) {
+  const fields = Object.keys(written).filter((f) => f !== "taskMode");
+  if (isReadOnly({ ...target, ...landed }, catalog) !== isReadOnly(target, catalog)) fields.push("readOnly");
+  return fields;
+}
+var NO_CATALOG = { modelsByRunner: {} };
+var keptIds = /* @__PURE__ */ new WeakMap();
+function idsOf(op) {
+  if (typeof op !== "object" || op === null) return uuidv4;
+  const ids = keptIds.get(op) ?? [];
+  keptIds.set(op, ids);
+  let next = 0;
+  return () => {
+    if (next === ids.length) ids.push(uuidv4());
+    return ids[next++];
+  };
+}
+function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
+  const ops = [...held, ...newOps];
+  const opLabel = (i) => i < held.length ? `earlier op ${i + 1} (${ops[i].op})` : `op ${i - held.length + 1} (${ops[i].op})`;
+  let tasks = JSON.parse(JSON.stringify(currentTasks));
+  const errors = [];
+  const summary = [];
+  const adjustments = [];
+  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(`${opLabel(i)}: handle must be a non-empty string`);
+      continue;
+    }
+    if (handleOwner.has(handle)) {
+      errors.push(`${opLabel(i)}: handle "${handle}" is already used earlier in this batch`);
+      continue;
+    }
+    if (resolveTaskRef(currentTasks, handle)) {
+      errors.push(`${opLabel(i)}: 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, currentTasks, tasks, 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 };
+  };
+  const intake = { runners, runnerModes: catalog?.runnerModes, autonomousDefault: catalog?.autonomousDefault, models: catalog };
+  const resolveTree = (planned, opIndex) => {
+    const walk = (t, parentTitle) => {
+      const ids = [];
+      const bad = [];
+      for (const d of t.dependencies) {
+        const own = planned.renamed.get(d);
+        if (own) {
+          ids.push(own);
+          continue;
+        }
+        const r = resolveDeps([d], opIndex);
+        ids.push(...r.ids);
+        bad.push(...r.bad);
+      }
+      if (bad.length) return `unknown dependencies${parentTitle !== void 0 ? ` of ${taskWhere(t.title, parentTitle)}` : ""}: ${bad.join(", ")}`;
+      const subtasks = [];
+      for (const sub of t.subtasks) {
+        const done2 = walk(sub, t.title);
+        if (typeof done2 === "string") return done2;
+        subtasks.push(done2);
+      }
+      return { ...t, dependencies: ids, subtasks };
+    };
+    const done = walk(planned.task);
+    return typeof done === "string" ? { error: done } : { task: done };
+  };
+  const refusalOf = (planned) => [...planned.ignored, ...planned.errors][0]?.message;
+  const prepareEdit = (op, opIndex, label, audience, refuseRunning = false) => {
+    const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, opIndex);
+    if ("error" in ref) return { error: `${label}: ${ref.error}` };
+    const target = findInTasks(tasks, ref.id);
+    if (!target) return { error: `${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)` };
+    if (refuseRunning && target.status === "in_progress") return { error: `${label}: ${lockedTaskRefusal(target, "re-armed")}` };
+    if (op.changes && "taskMode" in op.changes) return { error: `${label}: ${MODE_NOT_THE_PLANNERS}` };
+    const changes = updatableChanges(op.changes);
+    if (op.changes && "thinkingEffort" in op.changes) {
+      const model = changes.assignedModel ?? target.assignedModel;
+      if (!model) return { error: `${label}: "thinkingEffort" is the assigned model's \u2014 set "assignedModel" with it` };
+      changes.assignedModel = { ...model, thinkingEffort: op.changes.thinkingEffort ?? void 0 };
+    }
+    const changesForCheck = { ...changes };
+    delete changesForCheck.dependencies;
+    const check = validateTaskEdit(audience, tasks, target.id, changesForCheck);
+    if (!check.ok) return { error: `${label}: ${check.error}` };
+    for (const field of check.clear ?? []) changes[field] = void 0;
+    Object.assign(changes, check.set);
+    const readOnly = askedReadOnly(op.changes);
+    if (readOnly === true && (changes.type ?? target.type) === "user") return { error: `${label}: ${MANUAL_NOT_READ_ONLY}` };
+    if ((changes.ops ?? target.ops) && (readOnly ?? isReadOnly(target, catalog))) return { error: `${label}: ${OPS_NOT_READ_ONLY}` };
+    const landed2 = { ...changes };
+    const written = { ...target, ...changes };
+    if (written.type === "user" || runners.includes(written.assignedRunner)) {
+      const resolved = resolveAssignment({ writer: "edit", task: written, before: target, readOnly, catalog: catalog ?? NO_CATALOG });
+      if (!resolved.ok) return { error: `${label}: ${resolved.error}` };
+      if (resolved.task.assignedModel !== written.assignedModel) landed2.assignedModel = resolved.task.assignedModel;
+      if (resolved.task.taskMode !== written.taskMode) landed2.taskMode = resolved.task.taskMode;
+      adjustments.push(...resolved.adjustments);
+    }
+    if ("dependencies" in changes) {
+      const { ids, bad } = resolveDeps(changes.dependencies, opIndex);
+      if (bad.length) return { error: `${label}: unknown dependencies: ${bad.join(", ")}` };
+      landed2.dependencies = ids;
+    }
+    return { target, changes: landed2, fields: changedFields(target, changes, landed2, catalog), check };
+  };
+  const breachKey = (e) => `${e.taskId ?? ""}\0${e.field}`;
+  const standing = new Set(checkPlanInvariants(currentTasks, runners, catalog?.runnerModes).map(breachKey));
+  const brokenBy = /* @__PURE__ */ new Map();
+  let lastLabel = opLabel(0);
+  for (const [i, op] of ops.entries()) {
+    const label = opLabel(i);
+    const newId = idsOf(op);
+    switch (op.op) {
+      case "update": {
+        const prep = prepareEdit(op, i, label, "planner");
+        if ("error" in prep) {
+          errors.push(prep.error);
+          break;
+        }
+        const { target, changes, fields, check } = prep;
+        if (fields.length === 0) {
+          const readOnly = askedReadOnly(op.changes);
+          if (readOnly !== void 0 && isReadOnly(target, catalog) === readOnly) {
+            summary.push(`"${target.title}" is already ${readOnly ? "" : "not "}read-only`);
+            break;
+          }
+          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}"${fields.length ? ` (${fields.join(", ")})` : ""}${clearedNote}`);
+        break;
+      }
+      case "add": {
+        const spec = op.task ?? {};
+        if (!spec.title) {
+          errors.push(`${label}: new task needs a title`);
+          break;
+        }
+        const planned = plannedTask(spec, intake, { freshIds: true, newId });
+        const refused = refusalOf(planned);
+        if (refused) {
+          errors.push(`${label}: ${refused}`);
+          break;
+        }
+        adjustments.push(...planned.adjustments);
+        const resolved = resolveTree(planned, i);
+        if ("error" in resolved) {
+          errors.push(`${label}: ${resolved.error}`);
+          break;
+        }
+        tasks = addTaskToPlan(tasks, resolved.task);
+        if (op.handle) handleId.set(op.handle, resolved.task.id);
+        summary.push(`Added "${spec.title}"`);
+        break;
+      }
+      case "remove": {
+        const ref = resolveRef(op.taskId, currentTasks, 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 locked = lockedTaskRefusal(target, "removed") ?? lockedInSubtree(target);
+        if (locked) {
+          errors.push(`${label}: ${locked}`);
+          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 = [...new Map(resolved.map((t) => [t.id, t])).values()].sort((a, b) => a.order - b.order);
+        if (toMerge.length < 2) {
+          errors.push(`${label}: merge needs at least two tasks`);
+          break;
+        }
+        const locked = toMerge.map((t) => lockedTaskRefusal(t, "merged")).find((refusal) => refusal !== null);
+        if (locked) {
+          errors.push(`${label}: ${locked}`);
+          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 writes = toMerge.find((t) => !isReadOnly(t, catalog));
+        const stories = [...new Set(toMerge.flatMap((t) => t.userStoriesCovered ?? []))];
+        const planned = plannedTask(spec, intake, {
+          freshIds: true,
+          newId,
+          from: {
+            readOnly: !writes,
+            fields: {
+              description: toMerge.map((t) => t.description).filter(Boolean).join("\n\n"),
+              prompt: toMerge.map((t) => t.prompt).filter(Boolean).join("\n\n---\n\n") || void 0,
+              type: toMerge.some((t) => t.type === "user") ? "user" : "ai",
+              assignedRunner: toMerge[0].assignedRunner,
+              assignedModel: toMerge.find((t) => t.assignedModel)?.assignedModel,
+              taskMode: (writes ?? toMerge[0]).taskMode,
+              autonomy: toMerge.find((t) => t.autonomy)?.autonomy,
+              sliceType: toMerge.find((t) => t.sliceType)?.sliceType,
+              ops: inheritedOps(toMerge),
+              skills: toMerge.flatMap((t) => t.skills ?? []),
+              userStoriesCovered: stories.length ? stories : void 0
+            }
+          }
+        });
+        const refused = refusalOf(planned);
+        if (refused) {
+          errors.push(`${label}: ${refused}`);
+          break;
+        }
+        adjustments.push(...planned.adjustments);
+        const built = resolveTree({ ...planned, task: { ...planned.task, dependencies: [] } }, i);
+        if ("error" in built) {
+          errors.push(`${label}: ${built.error}`);
+          break;
+        }
+        const mergedTask = { ...built.task, dependencies: ids };
+        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;
+        }
+        const locked = lockedTaskRefusal(target, "split");
+        if (locked) {
+          errors.push(`${label}: ${locked}`);
+          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 planned = plannedTask(spec, intake, {
+            freshIds: true,
+            newId,
+            from: {
+              readOnly: isReadOnly(target, catalog),
+              fields: {
+                type: target.type,
+                assignedRunner: target.assignedRunner,
+                assignedModel: target.assignedModel,
+                taskMode: target.taskMode,
+                autonomy: target.autonomy,
+                sliceType: target.sliceType,
+                ops: inheritedOps([target]),
+                skills: target.skills,
+                userStoriesCovered: target.userStoriesCovered
+              }
+            }
+          });
+          const refused = refusalOf(planned);
+          if (refused) {
+            errors.push(`${label}: split part ${p + 1}: ${refused}`);
+            buildError = true;
+            break;
+          }
+          adjustments.push(...planned.adjustments);
+          const resolved = resolveTree({ ...planned, task: { ...planned.task, dependencies: [] } }, i);
+          if ("error" in resolved) {
+            errors.push(`${label}: split part ${p + 1}: ${resolved.error}`);
+            buildError = true;
+            break;
+          }
+          const nt = { ...resolved.task, dependencies: deps };
+          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 prep = prepareEdit(op, i, label, "direct", true);
+        if ("error" in prep) {
+          errors.push(prep.error);
+          break;
+        }
+        const { target, changes, fields, check } = prep;
+        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0, awaitingReason: void 0, resumeAt: void 0, skipReason: void 0 });
+        const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
+        const changedNote = fields.length ? ` (${fields.join(", ")})` : "";
+        summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
+        break;
+      }
+      default:
+        errors.push(`${label}: unknown op "${op.op}"`);
+    }
+    if (errors.length) break;
+    lastLabel = label;
+    const now = new Set(checkPlanInvariants(tasks, runners, catalog?.runnerModes).map(breachKey));
+    for (const key of brokenBy.keys()) if (!now.has(key)) brokenBy.delete(key);
+    for (const key of now) if (!standing.has(key) && !brokenBy.has(key)) brokenBy.set(key, label);
+  }
+  if (!errors.length) {
+    for (const e of checkPlanInvariants(tasks, runners, catalog?.runnerModes)) {
+      const key = breachKey(e);
+      if (!standing.has(key)) errors.push(`${brokenBy.get(key) ?? lastLabel}: ${e.message}`);
+    }
+  }
+  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);
+    }
+  }
+  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
+  const landed = new Map(flattenTasks(tasks).map((t) => [t.id, t]));
+  const told = /* @__PURE__ */ new Set();
+  const standingAdjustments = adjustments.filter((a) => {
+    const task = landed.get(a.taskId);
+    const now = a.field === "assignedModel" ? task?.assignedModel?.modelId : task?.assignedModel?.thinkingEffort;
+    const key = `${a.taskId}\0${a.field}`;
+    if (task === void 0 || (now ?? null) !== a.to || told.has(key)) return false;
+    told.add(key);
+    return true;
+  });
+  return { ok: true, tasks, errors: [], summary, handles: handleId, adjustments: standingAdjustments };
+}
+
 // src/services/continuation.ts
+function sessionOwner(task) {
+  return task.runnerSessionOwner ?? task.attemptUsage?.at(-1)?.runner;
+}
 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.");
@@ -811,6 +1630,10 @@ function continuability(task) {
   const finished = task.status === "completed" || task.status === "failed" || task.status === "skipped";
   if (!finished && !pausedOnLimit(task)) return refuse("only a completed, failed or skipped task, or one paused on a usage limit, can be.");
   if (!task.runnerSessionId) return refuse("its runner left no saved session to resume. Use Retry instead.");
+  const owner = sessionOwner(task);
+  if (owner && owner !== task.assignedRunner) {
+    return refuse(`its saved session belongs to ${owner}; Retry starts fresh on ${task.assignedRunner} and carries over its files.`);
+  }
   return { ok: true, sessionId: task.runnerSessionId };
 }
 function canContinue(task) {
@@ -818,7 +1641,7 @@ function canContinue(task) {
 }
 
 // src/services/blocking.ts
-var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
+var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved"]);
 function blockingFailures(tasks) {
   const byId = /* @__PURE__ */ new Map();
   const index = (list) => {
@@ -934,6 +1757,7 @@ function serializePlan(plan) {
     runners: plan.runners,
     generatedAt: plan.generatedAt,
     runSettings: plan.runSettings,
+    ...plan.plannerResend ? { plannerResend: plan.plannerResend } : {},
     conversationHistory: surfaceConversation(plan.conversationHistory),
     prdMarkdown: plan.prdMarkdown
   };
@@ -944,7 +1768,7 @@ function executionSummary(tasks) {
     total: tasks.length,
     completed: tasks.filter((t) => t.status === "completed").length,
     failed: tasks.filter((t) => t.status === "failed").length,
-    blocked: tasks.filter((t) => t.status === "blocked" || blocked.has(t.id)).length,
+    blocked: tasks.filter((t) => blocked.has(t.id)).length,
     skipped: tasks.filter((t) => t.status === "skipped").length
   };
 }
@@ -955,6 +1779,31 @@ function truncateCheckpointSummary(summary) {
   return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
 }
 
+// src/services/AssignmentScope.ts
+var OVER = /* @__PURE__ */ new Set(["completed", "skipped"]);
+function assignmentIssue(task, scope) {
+  if (task.type !== "ai" || OVER.has(task.status)) return null;
+  if (!scope.enabledRunners.includes(task.assignedRunner)) return { kind: "runner-off", runner: task.assignedRunner };
+  const model = task.assignedModel;
+  const allowed = effectiveAllowlist(scope.allowlist[task.assignedRunner], task.assignedRunner, scope.models);
+  if (model && allowed && !allowed.includes(model.modelId)) {
+    return { kind: "model-off-list", runner: task.assignedRunner, modelId: model.modelId, modelLabel: model.modelLabel || model.modelId };
+  }
+  return null;
+}
+function assignmentIssueText(issue) {
+  return issue.kind === "runner-off" ? `${issue.runner} is switched off` : `${issue.modelLabel} is not in the allowlist`;
+}
+function assignmentConsequence({ status, awaitingReason, resumeAt }) {
+  if (status === "failed") return "failed; a retry would run it there unless moved";
+  if (status === "awaiting_user" && awaitingReason === "usage-limit") {
+    return resumeAt ? "paused on a usage limit; resumes there at the reset unless moved" : "paused on a usage limit; a retry would run it there unless moved";
+  }
+  if (status === "awaiting_user" && (awaitingReason === "conflict" || awaitingReason === "files-changed")) return "waiting for the user; what runs next runs there unless moved";
+  if (status === "in_progress" || status === "awaiting_user") return "already running as assigned";
+  return "runs as assigned unless moved";
+}
+
 // src/services/conflictFiles.ts
 function capConflictFiles(files, max = 5) {
   return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
@@ -1053,12 +1902,7 @@ function split({ verdict, idleSince, isolation, checkpoint, queued, continuable,
   return { plan, status: { verdict, idleSince, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate, waitsForApproval } };
 }
 function refresh(previous, tasks) {
-  const held = /* @__PURE__ */ new Map();
-  const index = (list) => list.forEach((t) => {
-    held.set(t.id, t);
-    index(t.subtasks);
-  });
-  index(previous);
+  const held = new Map([...walkPlan(previous)].map(({ task }) => [task.id, task]));
   const fold = ({ subtasks, ...task }) => {
     const was = held.get(task.id);
     const { checkpoint, ...status } = was ? split(was).status : {};
@@ -1122,6 +1966,9 @@ function startTask(task) {
 function running({ awaitingReason: _reason, resumeAt: _resumeAt, skipReason: _skipped, checkpoint: _checkpoint, ...task }) {
   return { ...task, status: "in_progress" };
 }
+function withoutIsolation(tasks) {
+  return tasks.map(({ isolation: _isolation, ...task }) => ({ ...task, subtasks: withoutIsolation(task.subtasks) }));
+}
 function handoffOf({ type: _type, ...handoff }) {
   return handoff;
 }
@@ -1158,6 +2005,8 @@ function reduceRun(view, input) {
       return { ...view, handoff: handoffOf(input) };
     case "isolation_merge":
       return input.result.outcome === "merged" ? { ...view, mergeResult: input.result, handoff: null, runMerge: null } : { ...view, mergeResult: input.result };
+    case "run_closed":
+      return { ...view, tasks: withoutIsolation(view.tasks), handoff: null, runMerge: null, mergeResult: null };
     // A checkpoint's whole question and every status `review_needed` implies
     // arrive in the status update that follows; `review_needed`'s own list is
     // flat, so as a plan it would lift subtasks to the top level.
@@ -1273,8 +2122,9 @@ 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, supervisor }) {
+function settleReply(view, { content, turnId, supervisor, runs }) {
   const role = supervisor ? "supervisor" : "planner";
+  if (runs) return settleRuns(view, runs, role, turnId);
   if (turnId !== void 0) {
     const i = finalSegmentIndex(view.blocks, turnId);
     if (i >= 0) {
@@ -1283,6 +2133,25 @@ function settleReply(view, { content, turnId, supervisor }) {
   }
   return append(dropBuildingPlan(view, turnId), (id) => settledMessage(id, role, content, turnId));
 }
+function settleRuns(view, runs, role, turnId) {
+  const settled = /* @__PURE__ */ new Map();
+  let turn = turnId;
+  for (const run of runs) {
+    const i = view.blocks.findIndex((b) => b.type === "message" && b.segmentId === run.segmentId && b.turnId !== void 0 && (turnId === void 0 || b.turnId === turnId));
+    const segment = view.blocks[i];
+    if (segment?.type !== "message") continue;
+    settled.set(i, run);
+    turn ??= segment.turnId;
+  }
+  const contained = new Set(runs.map((run) => run.segmentId));
+  const blocks = view.blocks.flatMap((block, i) => {
+    const run = settled.get(i);
+    if (run) return [settledMessage(block.id, role, run.text, turn)];
+    return turn !== void 0 && isUnsettledSegment(block, turn) && !contained.has(block.segmentId) ? [] : [block];
+  });
+  const streamed = new Set(settled.values());
+  return runs.filter((run) => !streamed.has(run)).reduce((next, run) => append(next, (id) => settledMessage(id, role, run.text, turn)), dropBuildingPlan({ ...view, blocks }, turn));
+}
 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);
@@ -1399,6 +2268,7 @@ function syncTranscript(view, { plan, turnId }) {
     if (isNew && entry.kind === "wake_up") next = takePendingInputs(next, void 0, [entry.content]).view;
     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 === "error") next = append(next, (id) => settledMessage(id, "error", entry.content));
     if (isNew && entry.kind === "compaction") next = markCompaction(next, entry.content);
     if (latest === void 0 || entry.timestamp > latest) latest = entry.timestamp;
   }
@@ -1479,6 +2349,8 @@ function roleOf(entry) {
       return "wake_up";
     case "supervisor":
       return "supervisor";
+    case "error":
+      return "error";
     default:
       return entry.role === "user" ? "user" : "planner";
   }
@@ -1556,7 +2428,7 @@ function fromTranscript(conversationHistory, researchLog, plannerUsage, pendingT
   const kept = compacted ? history.slice(1) : history;
   const cutoff = compacted ? kept[0]?.timestamp ?? compacted.timestamp : "";
   const placed = [
-    ...kept.map((entry, i) => ({ at: entry.timestamp, rank: rankOf(entry), build: fromEntry(entry, loadsAfter(kept, i)) })),
+    ...kept.flatMap((entry, i) => entry.runs ? entry.runs.map((run) => ({ at: run.startedAt, rank: SETTLED, build: (id2) => settledMessage(id2(), roleOf(entry), run.text) })) : [{ at: entry.timestamp, rank: rankOf(entry), build: fromEntry(entry, loadsAfter(kept, i)) }]),
     ...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);
@@ -1627,16 +2499,16 @@ function cutOff(gate, input) {
   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 withGate(live2, gate) {
+  return gate.open === live2.gate.open && gate.stopped === live2.gate.stopped ? live2 : { ...live2, gate };
 }
 function followTurn(view, gate, input) {
-  const live = { view, gate };
+  const live2 = { 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;
+    return input.type === "planner_turn_ended" ? withGate(live2, { ...gate, stopped: null }) : live2;
   }
   const next = { view: reduceConversation(view, input), gate };
   return input.type === "planner_turn_ended" && input.turnId === gate.open ? withGate(next, { ...gate, open: null }) : next;
@@ -1689,6 +2561,60 @@ function markdownHtml(text2) {
   return md.render(text2);
 }
 
+// src/conversation/taskLogFollow.ts
+var EMPTY_TASK_LOG_FOLLOW = {
+  view: EMPTY_TASK_LOG,
+  attempts: [],
+  attempt: 0,
+  pending: [],
+  loaded: false,
+  followLatest: true
+};
+function covered(position, batch) {
+  return !!position && !!batch.position && position.stream === batch.position.stream && batch.position.seq <= position.seq;
+}
+function live(state, batch) {
+  if (batch.attempt <= 0 || batch.attempt < state.attempt) return state;
+  const attempts = state.attempts.includes(batch.attempt) ? state.attempts : [...state.attempts, batch.attempt].sort((a, b) => a - b);
+  if (batch.attempt > state.attempt) {
+    if (!state.followLatest) return attempts === state.attempts ? state : { ...state, attempts };
+    return { ...state, attempts, attempt: batch.attempt, position: void 0, view: batch.events.reduce(reduceTaskLog, EMPTY_TASK_LOG) };
+  }
+  if (covered(state.position, batch)) return state;
+  return { ...state, attempts, view: batch.events.reduce(reduceTaskLog, state.view) };
+}
+function followTaskLog(state, input) {
+  switch (input.type) {
+    case "opened":
+      return EMPTY_TASK_LOG_FOLLOW;
+    case "picked":
+      return { ...state, loaded: false, loadingAttempt: input.attempt, followLatest: input.attempt === state.attempts.at(-1) };
+    case "live":
+      return state.loaded ? live(state, input) : { ...state, pending: [...state.pending, input] };
+    case "loaded": {
+      if (state.loaded) return state;
+      if (!input.abandoned && state.loadingAttempt !== void 0 && input.attempt !== state.loadingAttempt) return state;
+      const attempts = [.../* @__PURE__ */ new Set([...input.attempts ?? state.attempts, ...state.pending.map((batch) => batch.attempt)])].filter((attempt) => attempt > 0).sort((a, b) => a - b);
+      let next = {
+        ...state,
+        attempts,
+        loaded: true,
+        pending: [],
+        loadingAttempt: void 0,
+        ...input.abandoned ? {} : { attempt: input.attempt, view: replayTaskLog(input.events), position: input.position }
+      };
+      for (const batch of state.pending) {
+        if (!input.abandoned && batch.attempt === input.attempt) {
+          if (covered(input.position, batch)) continue;
+          if (!input.position && !batch.position) continue;
+        }
+        next = live(next, batch);
+      }
+      return next;
+    }
+  }
+}
+
 // src/taskRow/actions.ts
 var UNSTARTED_AI = (t) => t.type === "ai" && NOT_STARTED.has(t.status);
 var QUEUED = (t) => t.status === "pending" || t.status === "approved";
@@ -1743,13 +2669,18 @@ function blockedBy(task, tasks) {
   if (!tasks?.length || !NOT_STARTED.has(task.status)) return [];
   return blockingFailures(asBlocking(tasks)).get(task.id) ?? [];
 }
+function flagOf(task, scope) {
+  const issue = scope && task.assignedRunner !== void 0 ? assignmentIssue({ ...task, assignedRunner: task.assignedRunner }, scope) : null;
+  return issue ? { assignmentFlag: assignmentIssueText(issue), assignmentConsequence: assignmentConsequence(task) } : { assignmentFlag: null, assignmentConsequence: null };
+}
 function taskRowView(task, context = {}) {
   const parent = context.parent ?? void 0;
   const isolation = task.isolation && task.isolation.state !== "none" ? task.isolation : null;
-  const latestUsage = task.attemptUsage?.at(-1);
+  const spend = taskUsageSummary(task);
+  const latestAttempt = task.attemptUsage?.at(-1);
   const blocked = blockedBy(task, context.tasks);
   return {
-    usage: latestUsage ? { ...usageLine(latestUsage), attempt: latestUsage.attempt, wallTimeMs: latestUsage.wallTimeMs, byModel: latestUsage.byModel } : task.type === "ai" && ["completed", "failed", "in_progress", "awaiting_user"].includes(task.status) ? { totals: {}, attempt: 0, byModel: [] } : null,
+    usage: latestAttempt ? { totals: spend.totals, ...spend.contextFill ? { contextFill: spend.contextFill } : {}, attempt: latestAttempt.attempt } : task.type === "ai" && ["completed", "failed", "in_progress", "awaiting_user"].includes(task.status) ? { totals: {}, attempt: 0 } : null,
     orderLabel: taskOrderLabel(task, parent),
     kind: task.type === "user" ? "user" : task.ops ? "ops" : "ai",
     status: blocked.length > 0 ? "blocked" : taskStatusKind(task),
@@ -1758,6 +2689,7 @@ function taskRowView(task, context = {}) {
     resumes: resumeLabel(task, context.now),
     approvals: approvalLabel(task.awaitingApproval),
     waitsForApproval: task.waitsForApproval && NOT_STARTED.has(task.status) ? WAITS_FOR_APPROVAL_LABEL : null,
+    ...flagOf(task, context.runnerScope),
     autonomous: task.type === "ai" && context.modes?.find((m) => m.id === task.taskMode)?.autonomous === true,
     repos: namedRepos(isolation?.repos),
     conflict: isolation?.state === "conflict" ? { repo: namedRepo(isolation.conflictRepo), files: filesOf(isolation.conflictFiles) } : null,
@@ -1780,10 +2712,10 @@ function taskRowView(task, context = {}) {
 function titledRefs(ids, tasks) {
   return ids.map((id) => titledTaskRefOf(tasks, id) ?? id);
 }
-function dependentsNotice(dependents) {
+function dependentsNotice(dependents, tasks = []) {
   if (dependents.length === 0) return null;
   const subject = dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`;
-  return `${subject} on it and will lose that dependency: ${dependents.map((t) => titledTaskRef(t)).join(", ")}.`;
+  return `${subject} on it and will lose that dependency: ${dependents.map((t) => (t.id ? titledTaskRefOf(tasks, t.id) : void 0) ?? titledTaskRef(t)).join(", ")}.`;
 }
 function pastGateConfirmation(unmerged, subject = "This task") {
   return `${subject} waits for Merge all: the work of ${unmerged.join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task.`;
@@ -1805,8 +2737,11 @@ export {
   startAttemptUsage,
   addAttemptUsage,
   endAttemptUsage,
+  countedSessionCost,
+  resumedSessionWindow,
   addUsageTotals,
   planUsage,
+  taskUsageSummary,
   sameMessage,
   mapAgentTool,
   normalizeAgentArgs,
@@ -1822,6 +2757,25 @@ export {
   runnerToolSubject,
   reduceTaskLog,
   replayTaskLog,
+  isTaskRunning,
+  NOT_STARTED,
+  taskStatusKind,
+  awaitingLabel,
+  blockedByLabel,
+  skippedLabel,
+  WAITS_FOR_APPROVAL_LABEL,
+  approvalLabel,
+  resumeTime,
+  resumeLabel,
+  validateTaskEdit,
+  UPDATABLE_FIELDS,
+  taskOpsProtocol,
+  textHasTaskOps,
+  parseTaskOpsJson,
+  canMergeTasks,
+  canSplitTask,
+  applyTaskOps,
+  sessionOwner,
   continuability,
   canContinue,
   blockingFailures,
@@ -1834,6 +2788,9 @@ export {
   executionSummary,
   CHECKPOINT_TRUNCATE_LENGTH,
   truncateCheckpointSummary,
+  assignmentIssue,
+  assignmentIssueText,
+  assignmentConsequence,
   capConflictFiles,
   summarizeToolCall,
   classifyOutcome,
@@ -1865,6 +2822,8 @@ export {
   taskStartedNotice,
   markdownTokens,
   markdownHtml,
+  EMPTY_TASK_LOG_FOLLOW,
+  followTaskLog,
   taskRowActions,
   markAction,
   markRequestFor,
@@ -1876,4 +2835,4 @@ export {
   pastGateConfirmation,
   newTaskFields
 };
-//# sourceMappingURL=chunk-FH6M5QZG.mjs.map
+//# sourceMappingURL=chunk-DMG4ISUG.mjs.map