@ordewell/core 0.9.0 → 0.10.0

package/dist/{chunk-QUARDKVT.mjs → chunk-CH5IGWFS.mjs}

@@ -1,27 +1,19 @@
 import {
-  PlanParseError,
-  TASK_OPS_ENVELOPE_KEY,
-  escapeControlCharsInStrings,
-  extractObjectsWithKey,
-  stripTrailingCommas
-} from "./chunk-H5O74L77.mjs";
-import {
-  addTaskToPlan,
-  createTask,
-  flattenTasks,
-  inheritedOps,
-  inheritedSkills,
-  opsFlag,
-  removeTaskFromPlan,
-  renumberTasks,
-  skillNames,
-  updateTaskInPlan
-} from "./chunk-UUU46PVQ.mjs";
+  NOT_STARTED,
+  approvalLabel,
+  awaitingLabel,
+  isTaskRunning,
+  resumeLabel,
+  taskStatusKind
+} from "./chunk-DJAPDO6E.mjs";
 import {
+  pausedOnLimit,
+  rejoinPlanTree,
   taskOrderLabel,
-  taskRef,
-  titledTaskRef
-} from "./chunk-V3JHS7AX.mjs";
+  taskRefOf,
+  titledTaskRef,
+  titledTaskRefOf
+} from "./chunk-2IIRSBEQ.mjs";
 
 // src/models/Usage.ts
 function partedPromptUsage(parts) {
@@ -45,13 +37,21 @@ function addUsage(totals, record) {
   return next;
 }
 function addPlannerUsage(usage, record) {
-  const next = { ...usage, totals: addUsage(usage.totals, record) };
+  const next = { ...usage, totals: addUsage(usage.totals, record), byModel: addModelUsage(usage.byModel ?? [], record) };
   if (record.subagentId) {
     next.bySubagent = { ...usage.bySubagent, [record.subagentId]: addUsage(usage.bySubagent?.[record.subagentId] ?? {}, record) };
     return next;
   }
+  if (!record.aggregate) {
+    if (record.source !== usage.source || record.model !== usage.model) {
+      delete next.lastPromptTokens;
+      delete next.contextWindow;
+    }
+    next.source = record.source;
+    next.model = record.model;
+  }
   if (record.inputTokens !== void 0) next.lastPromptTokens = record.inputTokens;
-  if (record.contextWindow !== void 0 && record.contextWindow > 0) next.contextWindow = record.contextWindow;
+  if (record.contextWindow !== void 0) next.contextWindow = record.contextWindow > 0 ? record.contextWindow : void 0;
   return next;
 }
 function isMeasured(totals) {
@@ -61,6 +61,8 @@ function usageLine(usage) {
   const contextFill = plannerContextFill(usage);
   return {
     totals: usage.totals,
+    ...usage.byModel ? { byModel: usage.byModel } : {},
+    ...usage.model ? { model: usage.model } : {},
     ...usage.bySubagent ? { bySubagent: usage.bySubagent } : {},
     ...contextFill ? { contextFill } : {}
   };
@@ -69,6 +71,48 @@ 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 };
 }
+function addModelUsage(models, record) {
+  const index = models.findIndex((m) => m.source === record.source && m.model === record.model);
+  if (index < 0) return [...models, { source: record.source, ...record.model ? { model: record.model } : {}, totals: addUsage({}, record) }];
+  return models.map((m, i) => i === index ? { ...m, totals: addUsage(m.totals, record) } : m);
+}
+function startAttemptUsage(attempt, runner, startedAt) {
+  return { attempt, runner, startedAt, wallTimeMs: 0, totals: {}, byModel: [] };
+}
+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 addUsageTotals(totals, addition) {
+  let next = addUsage(totals, { source: "", inputTokens: addition.inputTokens, outputTokens: addition.outputTokens, cachedInputTokens: addition.cachedInputTokens });
+  for (const [currency, amount] of Object.entries(addition.reportedCost ?? {})) next = addUsage(next, { source: "", reportedCost: { currency, amount } });
+  return next;
+}
+function planUsage(tasks) {
+  const result = { totals: {}, byModel: [], wallTimeMs: 0, attempts: 0 };
+  for (const task of tasks) {
+    const child = planUsage(task.subtasks ?? []);
+    result.totals = addUsageTotals(result.totals, child.totals);
+    result.wallTimeMs += child.wallTimeMs;
+    result.attempts += child.attempts;
+    const models = [...child.byModel];
+    for (const usage of task.attemptUsage ?? []) {
+      result.totals = addUsageTotals(result.totals, usage.totals);
+      result.wallTimeMs += usage.wallTimeMs;
+      result.attempts++;
+      models.push(...usage.byModel ?? []);
+    }
+    for (const model of models) {
+      const existing = result.byModel.find((m) => m.source === model.source && m.model === model.model);
+      if (existing) existing.totals = addUsageTotals(existing.totals, model.totals);
+      else result.byModel.push({ ...model, totals: addUsageTotals({}, model.totals) });
+    }
+  }
+  return result;
+}
 
 // src/services/harness/agentTools.ts
 var KNOWN_TOOLS = {
@@ -253,13 +297,23 @@ function diffSummary({ added, removed }) {
   return `Added ${lines(added)}, removed ${lines(removed)}`;
 }
 
+// src/utils/sameMessage.ts
+function sameMessage(a, b) {
+  const bare = (value) => value.trim().replace(/\.+$/, "").trimEnd();
+  return bare(a) !== "" && bare(a) === bare(b);
+}
+
 // src/conversation/records.ts
 function settledMessage(id, role, text2, turnId) {
   return { type: "message", id, role, text: text2, streaming: false, ...turnId ? { turnId } : {} };
 }
-function userMessage(id, text2, skills, turnId) {
+function userMessage(id, text2, skills, { turnId, forced } = {}) {
   const block = settledMessage(id, "user", text2, turnId);
-  return skills.length > 0 ? { ...block, skills: skills.map((s) => s.name) } : block;
+  return {
+    ...block,
+    ...skills.length > 0 ? { skills: skills.map((s) => s.name) } : {},
+    ...forced ? { forced: true } : {}
+  };
 }
 function skillLoadNotice({ invokedBy, name, source, path, attaches }) {
   return { invokedBy, name, source, path, ...attaches ? { attaches } : {} };
@@ -293,8 +347,8 @@ function subagentBlock(id, { toolCallId, model, usage, turnId, ...fields }) {
     ...turnId ? { turnId } : {}
   };
 }
-function usageBlock(id, { totals, bySubagent, contextFill }) {
-  return { type: "usage", id, totals, ...bySubagent ? { bySubagent } : {}, ...contextFill ? { contextFill } : {} };
+function usageBlock(id, { totals, bySubagent, byModel, model, contextFill }) {
+  return { type: "usage", id, totals, ...byModel ? { byModel } : {}, ...model ? { model } : {}, ...bySubagent ? { bySubagent } : {}, ...contextFill ? { contextFill } : {} };
 }
 var STATUS_OF_OUTCOME = {
   success: "ok",
@@ -488,10 +542,17 @@ function streamWhole(view, lane, key, text2, make) {
   return appendOutput(next, lane, make);
 }
 function agentText(view, text2) {
-  return streamWhole(view, null, TEXT_STREAM, text2, (id) => settledMessage(id, "agent", blockText(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 agentTextDelta(view, text2) {
-  return streamDelta(view, null, TEXT_STREAM, text2, (id, t) => ({ type: "message", id, role: "agent", text: t, streaming: true }));
+  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 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;
+  return appendOutput({ ...settled, latestText: void 0 }, null, (id) => settledMessage(id, "error", message));
 }
 function thinkingBlock(id, text2, streaming, subagentId) {
   return { type: "thinking", id, text: text2, streaming, ...subagentId ? { subagentId } : {} };
@@ -556,19 +617,22 @@ function runnerToolSubject(tool, 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 }) {
+function requestApproval(view, { approvalId, tool, args, allowForTask, toolCallId, decided }) {
   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 } : {}
-  }));
+  return append(view, (id) => {
+    const block = {
+      type: "approval",
+      id,
+      approvalId,
+      kind: "runner_tool",
+      subject: runnerToolSubject(tool, args),
+      scope: tool,
+      status: "pending",
+      ...allowForTask ? { allowForTask } : {},
+      ...toolCallId ? { toolCallId } : {}
+    };
+    return decided ? answered(block, decided) : block;
+  });
 }
 function settleApproval(view, approvalId, settle) {
   const i = findLastIndex(view.blocks, (b) => b.type === "approval" && b.approvalId === approvalId);
@@ -576,36 +640,73 @@ function settleApproval(view, approvalId, settle) {
   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) => ({
+function answered(block, decision, note) {
+  return {
     ...block,
     status: decision === "deny" ? "denied" : "granted",
     decidedBy: "asked",
     ...decision === "allowForTask" ? { forTask: true } : {},
     ...note ? { note } : {}
-  }));
+  };
+}
+function decideApproval(view, { approvalId, decision, note }) {
+  return settleApproval(view, approvalId, (block) => answered(block, decision, note));
 }
-function startTurn(view, { message, messageId }) {
+function startTurn(view, { message, messageId, from, forced }) {
   const queued = messageId ? view.queued.filter((m) => m.id !== messageId) : view.queued;
-  const working = { ...view, queued, working: true };
-  return message ? append(working, (id) => settledMessage(id, "user", message)) : working;
+  const working = { ...view, queued, working: true, latestText: void 0 };
+  return message ? append(working, (id) => ({ ...sentMessage(id, message, from), ...forced ? { forced: true } : {} })) : working;
+}
+function sentMessage(id, text2, from) {
+  return from === "ordewell" ? settledMessage(id, "system", `Ordewell: ${text2}`) : settledMessage(id, "user", text2);
+}
+function startCommand(view, { name, args, messageId }) {
+  const queued = messageId ? view.queued.filter((m) => m.id !== messageId) : view.queued;
+  return append({ ...view, queued, working: true, latestText: void 0 }, (id) => ({
+    type: "command",
+    id,
+    name,
+    ...args ? { args } : {},
+    status: "running",
+    output: ""
+  }));
+}
+function runningCommand(view) {
+  return findLastIndex(view.blocks, (b) => b.type === "command" && b.status === "running");
+}
+function commandOutput(view, { text: text2 }) {
+  const i = runningCommand(view);
+  const block = view.blocks[i];
+  if (block?.type !== "command") return append(view, (id) => settledMessage(id, "system", text2));
+  return { ...view, blocks: replaceAt(view.blocks, i, { ...block, output: block.output ? `${block.output}
+${text2}` : text2 }) };
+}
+function appendStep(view, make) {
+  const next = append(view, make);
+  return sealLane(next, null, findLastIndex(next.blocks, (b) => b.type !== "usage"));
 }
 var CUT = { completed: null, interrupted: "stopped", failed: "failed" };
+var COMMAND_END = { completed: "done", interrupted: "stopped", failed: "failed" };
 function endTurn(view, { reason }) {
-  const closed = closeOpenBlocks({ ...view, working: false, lastTurnEnd: reason, streams: {} }, CUT[reason]);
+  const i = runningCommand(view);
+  const command = view.blocks[i];
+  const settled = command?.type === "command" ? { ...view, blocks: replaceAt(view.blocks, i, { ...command, status: COMMAND_END[reason] }) } : view;
+  const closed = closeOpenBlocks({ ...settled, working: false, lastTurnEnd: reason, streams: {}, latestText: void 0 }, CUT[reason]);
   return reason === "interrupted" ? append(closed, (id) => settledMessage(id, "system", "Interrupted.")) : closed;
 }
-function queueMessage(view, { messageId, text: text2, forced }) {
+function queueMessage(view, { messageId, text: text2, forced, from }) {
   const listed = view.queued.find((m) => m.id === messageId);
+  const sender = from ? { from } : {};
   if (forced) {
     const rest = view.queued.filter((m) => m !== listed);
     const at = rest.findIndex((m) => !m.forced);
     const placed = at < 0 ? rest.length : at;
-    return { ...view, queued: [...rest.slice(0, placed), { id: messageId, text: text2, forced: true }, ...rest.slice(placed)] };
+    const handedOver = listed?.handedOver ? { handedOver: true } : {};
+    return { ...view, queued: [...rest.slice(0, placed), { id: messageId, text: text2, forced: true, ...handedOver, ...sender }, ...rest.slice(placed)] };
   }
-  if (!listed) return { ...view, queued: [...view.queued, { id: messageId, text: text2 }] };
+  if (!listed) return { ...view, queued: [...view.queued, { id: messageId, text: text2, ...sender }] };
   if (!listed.handedOver) return view;
-  return { ...view, queued: view.queued.map((m) => m === listed ? { id: m.id, text: m.text } : m) };
+  return { ...view, queued: view.queued.map((m) => m === listed ? { id: m.id, text: m.text, ...m.forced ? { forced: true } : {}, ...sender } : m) };
 }
 function handOver(view, { messageId }) {
   const listed = view.queued.find((m) => m.id === messageId);
@@ -613,18 +714,44 @@ function handOver(view, { messageId }) {
   return { ...view, queued: view.queued.map((m) => m === listed ? { ...m, handedOver: true } : m) };
 }
 function deliverMidTurn(view, event) {
-  return appendOutput(unqueueMessage(view, event), null, (id) => settledMessage(id, "user", event.text));
+  return appendOutput(unqueueMessage(view, event), null, (id) => sentMessage(id, event.text, event.from));
 }
 function unqueueMessage(view, { messageId }) {
   const queued = view.queued.filter((m) => m.id !== messageId);
   return queued.length === view.queued.length ? view : { ...view, queued };
 }
+function endCall(block) {
+  return block.type === "tool" && block.status === "pending" ? finishedTool(block, "", "not_executed") : 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;
+    if (ended !== block) changed = true;
+    return ended;
+  });
+  return changed ? { ...view, blocks } : view;
+}
 function reduceTaskLog(view, event) {
   switch (event.type) {
     case "task_skills":
       return append(view, (id) => settledMessage(id, "system", `Skills: ${event.skills.map((s) => `${s.name} (${s.path})`).join(", ")}`));
     case "turn_start":
       return startTurn(view, event);
+    case "command":
+      return startCommand(view, event);
+    case "command_output":
+      return commandOutput(view, event);
+    case "compaction":
+      return appendStep(view, (id) => ({
+        type: "compaction",
+        id,
+        trigger: event.trigger,
+        ...event.preTokens !== void 0 ? { preTokens: event.preTokens } : {},
+        ...event.postTokens !== void 0 ? { postTokens: event.postTokens } : {}
+      }));
+    case "runner_loaded":
+      return append(view, (id) => ({ type: "runner_loaded", id, commands: event.commands, mcpServers: event.mcpServers }));
     case "turn_end":
       return endTurn(view, event);
     case "text_delta":
@@ -656,13 +783,15 @@ function reduceTaskLog(view, event) {
     case "message_undelivered":
       return append(unqueueMessage(view, event), (id) => settledMessage(id, "system", `${event.text} \xB7 not delivered`));
     case "error":
-      return appendOutput(view, null, (id) => settledMessage(id, "error", event.message));
+      return failTurn(view, 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" }));
+    case "runner_ended":
+      return endOpenCalls(view);
     default:
       return view;
   }
@@ -676,848 +805,6 @@ 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/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 "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"
-};
-function awaitingLabel(task) {
-  return task.status === "awaiting_user" && task.awaitingReason ? AWAITING_LABELS[task.awaitingReason] : null;
-}
-function approvalLabel(count) {
-  if (!count) return null;
-  return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
-}
-
-// src/services/TaskOps.ts
-import { v4 as uuidv4 } from "uuid";
-
-// src/services/TaskEditValidator.ts
-var AI_ONLY_FIELDS = ["assignedModel", "thinkingEffort", "taskMode", "autonomy", "ops"];
-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 opsCheck(tasks, target, 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;
-  if ((changes.type ?? target.type) !== "ai") return { ok: false, error: `"${target.title}" is a manual task \u2014 only an AI task can be an ops task` };
-  if (tasks.some((t) => t.subtasks?.some((s) => s.id === target.id))) {
-    return { ok: false, error: `"${target.title}" is a subtask, which runs with its parent \u2014 only a top-level task can be an ops task` };
-  }
-  return null;
-}
-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 ops = opsCheck(tasks, target, changes);
-  if (ops) return ops;
-  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",
-  "ops",
-  "skills"
-];
-function taskOpsProtocol(executionNote = "", tools = false) {
-  const updateChanges = UPDATABLE_FIELDS.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"?,"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.',
-    '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>"}.`,
-    '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") 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, 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 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 withSkillNames(subtasks) {
-  if (!Array.isArray(subtasks)) return subtasks;
-  return subtasks.map((sub) => {
-    if (typeof sub !== "object" || sub === null) return sub;
-    const { skills, ...rest } = sub;
-    const names = skillNames(skills);
-    return {
-      ...rest,
-      ...names ? { skills: names } : {},
-      ..."subtasks" in rest ? { subtasks: withSkillNames(rest.subtasks) } : {}
-    };
-  });
-}
-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 };
-  };
-  const prepareEdit = (op, opIndex, label, audience, refuseRunning = false) => {
-    const ref = resolveRef(op.taskId, originalFlatAll, flattenTasks(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}: "${target.title}" is running and cannot be re-armed` };
-    const changes = updatableChanges(op.changes);
-    if (changes.assignedRunner && !runners.includes(changes.assignedRunner)) {
-      return { error: `${label}: runner "${changes.assignedRunner}" is not in this plan's runner set [${runners.join(", ")}]` };
-    }
-    const changesForCheck = { ...changes };
-    delete changesForCheck.dependencies;
-    const check = validateTaskEdit(audience, flattenTasks(tasks), target.id, changesForCheck, catalog);
-    if (!check.ok) return { error: `${label}: ${check.error}` };
-    for (const field of check.clear ?? []) changes[field] = void 0;
-    if ("dependencies" in changes) {
-      const { ids, bad } = resolveDeps(changes.dependencies, opIndex);
-      if (bad.length) return { error: `${label}: unknown dependencies: ${bad.join(", ")}` };
-      changes.dependencies = ids.filter((id) => id !== target.id);
-    }
-    return { target, changes, check };
-  };
-  for (const [i, op] of ops.entries()) {
-    const label = `op ${i + 1} (${op.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, check } = prep;
-        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,
-          subtasks: withSkillNames(spec.subtasks),
-          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 = [...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.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,
-          ops: inheritedOps(toMerge, spec.ops),
-          skills: inheritedSkills(spec.skills, toMerge.flatMap((t) => t.skills ?? [])),
-          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,
-            ops: inheritedOps([target], spec.ops),
-            skills: inheritedSkills(spec.skills, target.skills),
-            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 prep = prepareEdit(op, i, label, "direct", true);
-        if ("error" in prep) {
-          errors.push(prep.error);
-          break;
-        }
-        const { target, changes, check } = prep;
-        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();
@@ -1580,13 +867,51 @@ function summarizeToolCall(tool, argsJson, toolLabel) {
 }
 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 (/^(Command|Fetch|Web search) 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/blocking.ts
+var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
+function blockingFailures(tasks) {
+  const byId = /* @__PURE__ */ new Map();
+  const index = (list) => {
+    for (const t of list) {
+      byId.set(t.id, t);
+      index(t.subtasks ?? []);
+    }
+  };
+  index(tasks);
+  const memo = /* @__PURE__ */ new Map();
+  const failuresOf = (id, visiting) => {
+    const known = memo.get(id);
+    if (known) return known;
+    const task = byId.get(id);
+    if (!task || !UNSTARTED.has(task.status) || visiting.has(id)) return [];
+    visiting.add(id);
+    const failed = /* @__PURE__ */ new Set();
+    for (const depId of task.dependencies) {
+      const dep = byId.get(depId);
+      if (!dep || dep.status === "completed" || dep.status === "skipped") continue;
+      if (dep.status === "failed") failed.add(depId);
+      else for (const root of failuresOf(depId, visiting)) failed.add(root);
+    }
+    visiting.delete(id);
+    const result = [...failed];
+    memo.set(id, result);
+    return result;
+  };
+  const blocked = /* @__PURE__ */ new Map();
+  for (const id of byId.keys()) {
+    const failures = failuresOf(id, /* @__PURE__ */ new Set());
+    if (failures.length > 0) blocked.set(id, failures);
+  }
+  return blocked;
+}
+
 // src/services/continuation.ts
 function continuability(task) {
   const refuse = (reason) => ({ ok: false, reason: `Task "${task.title}" cannot be continued: ${reason}` });
@@ -1594,7 +919,8 @@ function continuability(task) {
   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.");
+  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.");
   return { ok: true, sessionId: task.runnerSessionId };
 }
@@ -1602,6 +928,24 @@ function canContinue(task) {
   return continuability(task).ok;
 }
 
+// src/services/runSettingsText.ts
+var SUPERVISOR_LEVEL_LABEL = { off: "Off", watch: "Watch", act: "Act" };
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+var onOff = (value) => value ? "on" : "off";
+var supervisorSummary = (run) => `Supervisor: ${SUPERVISOR_LEVEL_LABEL[run.supervisorLevel]}, ${plural(run.supervisorRetryLimit, "retry", "retries")} per task, ${plural(run.wakeUpReadBudget, "read", "reads")} per wake-up`;
+var automergeSummary = (run) => `Merge automatically (gates, end of run): ${onOff(run.mergeAtGatesAutomatically)}`;
+var autorunSummary = (run) => `Autorun: ${onOff(run.autorun)}`;
+var ACT_RISK = "Tasks it adds run too, ops tasks included, which can act on real systems unattended.";
+var AUTORUN_RISK = "Plans start without review, ops tasks included, which can act on real systems unattended. In Full, the planner may also start tasks it adds later.";
+function parseSwitch(arg) {
+  return arg === "on" ? true : arg === "off" ? false : null;
+}
+function parseCount(arg, min) {
+  if (arg === void 0 || !/^\d+$/.test(arg)) return null;
+  const n = Number(arg);
+  return n >= min ? n : null;
+}
+
 // src/services/SessionMessage.ts
 function serializeTask(t) {
   return {
@@ -1609,6 +953,7 @@ function serializeTask(t) {
     order: t.order,
     title: t.title,
     type: t.type,
+    status: t.status,
     description: t.description,
     dependencies: t.dependencies || [],
     assignedRunner: t.assignedRunner,
@@ -1617,12 +962,16 @@ function serializeTask(t) {
     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,
+    ...t.status === "awaiting_user" && t.awaitingReason ? { awaitingReason: t.awaitingReason } : {},
+    ...t.status === "awaiting_user" && t.awaitingReason === "usage-limit" && t.resumeAt ? { resumeAt: t.resumeAt } : {},
+    ...t.status === "skipped" && t.skipReason ? { skipReason: t.skipReason } : {},
     ...t.ops ? { ops: true } : {},
-    ...t.skills?.length ? { skills: [...t.skills] } : {}
+    ...t.attemptUsage ? { attemptUsage: structuredClone(t.attemptUsage) } : {},
+    ...t.skills?.length ? { skills: [...t.skills] } : {},
+    ...t.addedBy ? { addedBy: t.addedBy } : {}
   };
 }
 function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [], awaitingApproval = 0, mergeGate = [], checkpoint = "") {
@@ -1631,9 +980,12 @@ function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [],
     status: t.status,
     verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null,
     idleSince,
+    ...t.attemptUsage ? { attemptUsage: structuredClone(t.attemptUsage) } : {},
     ...isolation ? { isolation } : {},
     ...t.status === "awaiting_user" && t.awaitingReason ? { awaitingReason: t.awaitingReason } : {},
+    ...t.status === "awaiting_user" && t.awaitingReason === "usage-limit" && t.resumeAt ? { resumeAt: t.resumeAt } : {},
     ...t.status === "awaiting_user" && t.awaitingReason === "checkpoint" && checkpoint ? { checkpoint } : {},
+    ...t.status === "skipped" && t.skipReason ? { skipReason: t.skipReason } : {},
     ...queued.length > 0 ? { queued: queued.map((m) => ({ ...m })) } : {},
     ...canContinue(t) ? { continuable: true } : {},
     ...awaitingApproval > 0 ? { awaitingApproval } : {},
@@ -1644,8 +996,8 @@ function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [],
 function surfaceConversation(history) {
   return history?.map(({ skill, ...m }) => skill ? { ...m, skill: skillLoadNotice(skill) } : m);
 }
-function surfaceQueued(queued) {
-  return queued?.map(({ skills, ...m }) => skills ? { ...m, skills: skills.map(skillLoadNotice) } : m);
+function surfacePendingTurns(pending) {
+  return pending?.map(({ skills, ...t }) => skills ? { ...t, skills: skills.map(skillLoadNotice) } : t);
 }
 function surfaceTask({ attemptSkills, subtasks, runnerSessionId: _runnerSessionId, ...task }) {
   return {
@@ -1654,12 +1006,12 @@ function surfaceTask({ attemptSkills, subtasks, runnerSessionId: _runnerSessionI
     subtasks: (subtasks ?? []).map(surfaceTask)
   };
 }
-function surfacePlan(plan) {
+function surfacePlan({ queuedMessages: _carriedOverAtLoad, ...plan }) {
   return {
     ...plan,
     tasks: plan.tasks.map(surfaceTask),
     conversationHistory: surfaceConversation(plan.conversationHistory),
-    queuedMessages: surfaceQueued(plan.queuedMessages),
+    pendingTurns: surfacePendingTurns(plan.pendingTurns),
     researchLog: plan.researchLog?.map((e) => "type" in e ? e : surfaceStep(e))
   };
 }
@@ -1671,16 +1023,19 @@ function serializePlan(plan) {
     tasks: plan.tasks.map(serializeTask),
     runners: plan.runners,
     generatedAt: plan.generatedAt,
+    runSettings: plan.runSettings,
     conversationHistory: surfaceConversation(plan.conversationHistory),
-    prdMarkdown: plan.prdMarkdown,
-    queuedMessages: surfaceQueued(plan.queuedMessages)
+    prdMarkdown: plan.prdMarkdown
   };
 }
 function executionSummary(tasks) {
+  const blocked = blockingFailures(tasks);
   return {
     total: tasks.length,
     completed: tasks.filter((t) => t.status === "completed").length,
-    failed: tasks.filter((t) => t.status === "failed").length
+    failed: tasks.filter((t) => t.status === "failed").length,
+    blocked: tasks.filter((t) => t.status === "blocked" || blocked.has(t.id)).length,
+    skipped: tasks.filter((t) => t.status === "skipped").length
   };
 }
 var CHECKPOINT_TRUNCATE_LENGTH = 120;
@@ -1690,6 +1045,152 @@ function truncateCheckpointSummary(summary) {
   return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
 }
 
+// src/services/runView.ts
+var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
+function split({ verdict, idleSince, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate, ...plan }) {
+  return { plan, status: { verdict, idleSince, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate } };
+}
+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 fold = ({ subtasks, ...task }) => {
+    const was = held.get(task.id);
+    const { checkpoint, ...status } = was ? split(was).status : {};
+    const waits = task.status === "awaiting_user" && task.awaitingReason === "checkpoint";
+    return { ...task, ...status, ...waits && checkpoint ? { checkpoint } : {}, subtasks: subtasks.map(fold) };
+  };
+  return tasks.map(fold);
+}
+function withStatus({ awaitingReason: _reason, resumeAt: _resumeAt, skipReason: _skipped, attemptUsage: _usage, ...plan }, { id: _id, ...status }) {
+  return { ...plan, ...status };
+}
+function applyStatus(tasks, updates) {
+  return tasks.map((task) => {
+    const subtasks = applyStatus(task.subtasks, updates);
+    const update = updates.get(task.id);
+    return update ? { ...withStatus(split(task).plan, update), subtasks } : { ...task, subtasks };
+  });
+}
+function changeTask(tasks, taskId, change) {
+  let changed = false;
+  const next = tasks.map((task) => {
+    const updated = task.id === taskId ? change(task) : task;
+    const subtasks = changeTask(updated.subtasks, taskId, change);
+    if (updated === task && subtasks === task.subtasks) return task;
+    changed = true;
+    return { ...updated, subtasks };
+  });
+  return changed ? next : tasks;
+}
+var PATCHABLE = /* @__PURE__ */ new Set([
+  "order",
+  "title",
+  "type",
+  "status",
+  "description",
+  "dependencies",
+  "assignedRunner",
+  "assignedModel",
+  "taskMode",
+  "prompt",
+  "userSteps",
+  "autonomy",
+  "sliceType",
+  "userStoriesCovered",
+  "awaitingReason",
+  "resumeAt",
+  "skipReason",
+  "ops",
+  "skills",
+  "addedBy",
+  "attemptUsage"
+]);
+function patchTask(task, changes) {
+  const fields = Object.entries(changes).filter(([key]) => PATCHABLE.has(key));
+  if (fields.length === 0) return task;
+  return { ...task, ...Object.fromEntries(fields) };
+}
+function startTask(task) {
+  return task.status === "in_progress" ? task : running(task);
+}
+function running({ awaitingReason: _reason, resumeAt: _resumeAt, skipReason: _skipped, checkpoint: _checkpoint, ...task }) {
+  return { ...task, status: "in_progress" };
+}
+function handoffOf({ type: _type, ...handoff }) {
+  return handoff;
+}
+function planTasks(plan) {
+  if ("tasks" in plan) return plan.tasks;
+  return rejoinPlanTree(plan.pendingTasks, plan.phase === "executing" ? plan.executionLog : []);
+}
+function reduceRun(view, input) {
+  switch (input.type) {
+    case "plan_generated":
+      return { ...view, tasks: refresh(view.tasks, input.plan.tasks), runSettings: input.plan.runSettings };
+    case "plan_snapshot":
+      return {
+        ...view,
+        tasks: refresh(view.tasks, planTasks(input.plan).map(serializeTask)),
+        // A saved plan's phase-tagged form has no run settings to say.
+        runSettings: "tasks" in input.plan ? input.plan.runSettings : view.runSettings
+      };
+    case "status_update":
+      return {
+        ...view,
+        tasks: applyStatus(view.tasks, new Map(input.tasks.map((t) => [t.id, t]))),
+        runMerge: input.runMerge ?? null,
+        usage: input.usage
+      };
+    case "task_started":
+    case "task_updated": {
+      const tasks = changeTask(view.tasks, input.taskId, (task) => input.type === "task_started" ? startTask(task) : patchTask(task, input.changes));
+      return tasks === view.tasks ? view : { ...view, tasks };
+    }
+    case "isolation_handoff":
+      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 };
+    // 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.
+    case "checkpoint":
+    case "review_needed":
+    case "review_approved":
+    case "execution_complete":
+    case "execution_stopped":
+    case "execution_action":
+    case "task_output":
+    case "task_log":
+    case "isolation_blocked":
+    case "planner_message":
+    case "planner_turn_started":
+    case "planner_skill_loaded":
+    case "planner_turn_ended":
+    case "planner_text_delta":
+    case "planner_thinking_delta":
+    case "planner_text_retracted":
+    case "planner_usage":
+    case "planner_liveness":
+    case "subagent_started":
+    case "subagent_finished":
+    case "research_step":
+    case "research_step_done":
+    case "plan_token":
+    case "approval_request":
+    case "approval_settled":
+    case "approval_decided":
+      return view;
+    default: {
+      const unhandled = input;
+      return unhandled;
+    }
+  }
+}
+
 // src/conversation/reduce.ts
 var EMPTY_CONVERSATION = { blocks: [], nextId: 1 };
 function isUnsettledSegment(block, turnId) {
@@ -1702,16 +1203,55 @@ 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.type === "command" || block.type === "compaction" || block.type === "runner_loaded") continue;
     if (block.turnId !== turnId) continue;
     return isUnsettledSegment(block, turnId) ? i : -1;
   }
   return -1;
 }
-function openTurn(view, { turnId, prompt = "", skills = [] }) {
+function openTurn(view, { turnId, prompt = "", skills = [], wakeUps = [], forced }) {
+  const adopted = takePendingInputs(view, prompt, wakeUps, turnId);
+  view = adopted.view;
+  wakeUps = wakeUps.slice(adopted.wakeUps);
+  if (wakeUps.length === 0) return adopted.prompt || prompt === "" && adopted.wakeUps > 0 ? view : promptLine(view, turnId, prompt, skills, forced);
+  const said = prompt === "" || adopted.prompt ? view : promptLine(view, turnId, prompt, skills, forced);
+  const at = prompt === "" ? said.blocks.length : findLastIndex(said.blocks, (b) => b.type === "message" && b.role === "user" && b.turnId === turnId);
+  const updates = wakeUps.map((text2, n) => settledMessage(`b${said.nextId + n}`, "wake_up", text2, turnId));
+  return { ...said, blocks: [...said.blocks.slice(0, at), ...updates, ...said.blocks.slice(at)], nextId: said.nextId + updates.length };
+}
+function takePendingInputs(view, prompt, wakeUps, turnId) {
+  const pending = view.pendingInputs ?? [];
+  const users = pending.filter(({ input }) => input.source === "user");
+  const updates = pending.filter(({ input }) => input.source === "supervisor");
+  const taken = /* @__PURE__ */ new Set();
+  let matchedPrompt = false;
+  for (let n = 1; prompt !== void 0 && n <= users.length; n++) {
+    if (users.slice(0, n).map(({ input }) => input.text).join("\n\n") !== prompt) continue;
+    for (const { input } of users.slice(0, n)) taken.add(input.id);
+    matchedPrompt = true;
+    break;
+  }
+  let matchedUpdates = 0;
+  while (matchedUpdates < wakeUps.length && updates[matchedUpdates]?.input.text === wakeUps[matchedUpdates]) {
+    taken.add(updates[matchedUpdates++].input.id);
+  }
+  if (taken.size === 0) return { view, prompt: false, wakeUps: 0 };
+  const blockIds = new Set(pending.filter(({ input }) => taken.has(input.id)).flatMap(({ blockIds: blockIds2 }) => blockIds2));
+  return {
+    view: {
+      ...view,
+      blocks: turnId === void 0 ? view.blocks : view.blocks.map((block) => blockIds.has(block.id) ? { ...block, turnId } : block),
+      pendingInputs: pending.filter(({ input }) => !taken.has(input.id))
+    },
+    prompt: matchedPrompt,
+    wakeUps: matchedUpdates
+  };
+}
+function promptLine(view, turnId, prompt, skills, forced) {
   const i = findLastIndex(view.blocks, (b) => b.type === "message" && b.role === "user");
   const sent = view.blocks[i];
   const adopted = sent?.type === "message" && sent.turnId === void 0 && sent.text === prompt;
-  const said = adopted ? { ...view, blocks: replaceAt(view.blocks, i, userMessage(sent.id, prompt, skills, turnId)) } : append(view, (id) => userMessage(id, prompt, skills, turnId));
+  const said = adopted ? { ...view, blocks: replaceAt(view.blocks, i, userMessage(sent.id, prompt, skills, { turnId, forced })) } : append(view, (id) => userMessage(id, prompt, skills, { turnId, forced }));
   if (skills.length === 0) return said;
   const at = adopted ? i + 1 : findLastIndex(said.blocks, (b) => b.type === "message" && b.role === "user") + 1;
   const loads = skills.map((skill, n) => skillLoadBlock(`b${said.nextId + n}`, skill, turnId));
@@ -1729,14 +1269,15 @@ 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 }) {
+function settleReply(view, { content, turnId, supervisor }) {
+  const role = supervisor ? "supervisor" : "planner";
   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 dropBuildingPlan({ ...view, blocks: replaceAt(view.blocks, i, settledMessage(view.blocks[i].id, role, content, turnId)) }, turnId);
     }
   }
-  return append(dropBuildingPlan(view, turnId), (id) => settledMessage(id, "planner", content, turnId));
+  return append(dropBuildingPlan(view, turnId), (id) => settledMessage(id, role, content, turnId));
 }
 function retractText(view, { turnId, segmentId }) {
   const blocks = view.blocks.filter((b) => !(isUnsettledSegment(b, turnId) && (segmentId === void 0 || b.segmentId === segmentId)));
@@ -1850,6 +1391,8 @@ function syncTranscript(view, { plan, turnId }) {
   let latest = view.transcriptAt;
   for (const [i, entry] of history.entries()) {
     const isNew = view.transcriptAt === void 0 || entry.timestamp > view.transcriptAt;
+    if (isNew && entry.role === "user" && !entry.kind) next = takePendingInputs(next, entry.content, []).view;
+    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 === "compaction") next = markCompaction(next, entry.content);
@@ -1893,6 +1436,8 @@ function reduceConversation(view, input) {
       return settleApproval2(view, input);
     case "approval_decided":
       return decideApproval2(view, input);
+    case "execution_action":
+      return append(view, (id) => settledMessage(id, "system", input.text));
     case "planner_usage":
       return reportUsage2(view, input);
     default:
@@ -1910,9 +1455,22 @@ function fromEntry(entry, loaded = []) {
     const { skill } = entry;
     return (id) => skillLoadBlock(id(), skillLoadNotice(skill));
   }
-  if (entry.role === "user" && !entry.kind) return (id) => userMessage(id(), entry.content, loaded.map(skillLoadNotice));
-  const role = entry.kind === "system" || entry.kind === "compaction" ? "system" : entry.role === "user" ? "user" : "planner";
-  return (id) => settledMessage(id(), role, entry.content);
+  if (entry.role === "user" && !entry.kind) return (id) => userMessage(id(), entry.content, loaded.map(skillLoadNotice), { forced: entry.forced });
+  return (id) => settledMessage(id(), roleOf(entry), entry.content);
+}
+function roleOf(entry) {
+  switch (entry.kind) {
+    case "system":
+    case "compaction":
+    case "execution":
+      return "system";
+    case "wake_up":
+      return "wake_up";
+    case "supervisor":
+      return "supervisor";
+    default:
+      return entry.role === "user" ? "user" : "planner";
+  }
 }
 function loadsAfter(entries, index) {
   const loads = [];
@@ -1923,7 +1481,7 @@ function loadsAfter(entries, index) {
   return loads;
 }
 function rankOf(entry) {
-  return entry.role === "user" && (!entry.kind || entry.kind === "skill_load") ? USER : SETTLED;
+  return entry.role === "user" && (!entry.kind || entry.kind === "skill_load" || entry.kind === "wake_up") ? USER : SETTLED;
 }
 function spawnBrief(step) {
   try {
@@ -1981,7 +1539,7 @@ function research(log) {
   }
   return placed;
 }
-function fromTranscript(conversationHistory, researchLog, plannerUsage) {
+function fromTranscript(conversationHistory, researchLog, plannerUsage, pendingTurns = []) {
   const history = conversationHistory ?? [];
   const compacted = history[0]?.kind === "compaction" ? history[0] : void 0;
   const kept = compacted ? history.slice(1) : history;
@@ -1995,9 +1553,21 @@ function fromTranscript(conversationHistory, researchLog, plannerUsage) {
   let nextId = 1;
   const id = () => `b${nextId++}`;
   const blocks = placed.map((item) => item.build(id));
+  const pendingInputs = [];
+  for (const input of pendingTurns) {
+    const start = blocks.length;
+    if (input.source === "supervisor") {
+      blocks.push(settledMessage(id(), "wake_up", input.text));
+    } else {
+      const skills = (input.skills ?? []).map(skillLoadNotice);
+      blocks.push(userMessage(id(), input.text, skills, { forced: input.forced }));
+      blocks.push(...skills.map((skill) => skillLoadBlock(id(), skill)));
+    }
+    pendingInputs.push({ input: { ...input, skills: input.skills?.map(skillLoadNotice) }, blockIds: blocks.slice(start).map((block) => block.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 } : {} };
+  return { blocks, nextId, ...transcriptAt ? { transcriptAt } : {}, ...pendingInputs.length > 0 ? { pendingInputs } : {} };
 }
 
 // src/conversation/promptHold.ts
@@ -2013,6 +1583,10 @@ function unsendLatest(hold) {
   if (hold.length === 0) return void 0;
   return { text: hold[hold.length - 1], rest: hold.slice(0, -1) };
 }
+function takeAt(hold, index) {
+  if (index < 0 || index >= hold.length) return void 0;
+  return { text: hold[index], rest: [...hold.slice(0, index), ...hold.slice(index + 1)] };
+}
 function unsendAll(hold) {
   if (hold.length === 0) return void 0;
   return { text: hold.join("\n"), rest: EMPTY_HOLD };
@@ -2066,7 +1640,7 @@ function stopTurn(view, gate) {
 
 // src/conversation/detail.ts
 function hasHiddenDetail(blocks) {
-  return blocks.some((b) => b.type === "thinking" || b.type === "tool" || b.type === "subagent");
+  return blocks.some((b) => b.type === "thinking" || b.type === "tool" || b.type === "subagent" || b.type === "runner_loaded");
 }
 
 // src/conversation/notices.ts
@@ -2077,20 +1651,29 @@ function taskStartedNotice(title, runner) {
 // 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";
+var PAUSED = (t) => t.status === "awaiting_user" && t.awaitingReason === "usage-limit";
+var RESUMES = (t) => PAUSED(t) && !!t.resumeAt;
+var RESUMABLE = (t) => PAUSED(t) && t.continuable === true;
+var HOLDS_UP = (t) => t.status === "failed" || t.status === "blocked" || t.status === "awaiting_user";
 var TASK_RULES = [
   ["cancel", (t) => t.status === "in_progress"],
-  ["skip", (t) => t.status === "blocked"],
+  ["resume-now", RESUMABLE],
+  ["cancel-resume", RESUMES],
+  ["skip", HOLDS_UP],
   ["force-start", UNSTARTED_AI],
-  // A manual task has no runner to report it done, so it can always be marked.
-  ["complete", (t) => t.status === "awaiting_user" || t.type === "user"],
+  // A manual task has no runner to report it done, so it can always be marked;
+  // a skipped one's kept work can still be vouched for.
+  ["complete", (t) => t.status === "awaiting_user" || t.status === "skipped" || t.type === "user"],
   ["uncomplete", (t) => t.status === "completed"]
 ];
 var SUBTASK_RULES = [
   ["cancel", (t) => t.status === "in_progress"],
+  ["resume-now", RESUMABLE],
+  ["cancel-resume", RESUMES],
   ["complete", (t) => t.status === "in_progress" && t.type === "ai"],
   ["force-start", (t) => t.type === "ai" && QUEUED(t)],
-  ["skip", QUEUED],
-  ["complete", (t) => t.status === "awaiting_user"],
+  ["skip", (t) => QUEUED(t) || t.status === "failed"],
+  ["complete", (t) => t.status === "awaiting_user" || t.status === "skipped"],
   ["uncomplete", (t) => t.status === "completed"]
 ];
 function taskRowActions(task, placement = "task") {
@@ -2101,7 +1684,7 @@ function markAction(task) {
   return task.status === "completed" ? "uncomplete" : "complete";
 }
 function markRequestFor(action) {
-  if (action === "complete" || action === "skip") return "complete";
+  if (action === "complete") return "complete";
   if (action === "uncomplete") return "uncomplete";
   return null;
 }
@@ -2110,52 +1693,50 @@ function opsEditable(task) {
 }
 
 // src/taskRow/view.ts
-var refsOf = (ids, orderOf) => ids.map((id) => {
-  const order = orderOf?.get(id);
-  return order === void 0 ? id : taskRef({ order });
-});
+var refsOf = (ids, tasks) => ids.map((id) => tasks?.length ? taskRefOf(tasks, id) ?? id : id);
 var namedRepo = (repo) => repo && repo !== "." ? repo : null;
 var namedRepos = (repos) => (repos ?? []).filter((r) => r !== ".");
 var filesOf = (files) => files?.length ? capConflictFiles(files) : null;
+var asBlocking = (tasks) => tasks.map((t) => ({ id: t.id, status: t.status ?? "", dependencies: t.dependencies ?? [], subtasks: asBlocking(t.subtasks ?? []) }));
+function blockedBy(task, tasks) {
+  if (!tasks?.length || !NOT_STARTED.has(task.status)) return [];
+  return blockingFailures(asBlocking(tasks)).get(task.id) ?? [];
+}
 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 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,
     orderLabel: taskOrderLabel(task, parent),
     kind: task.type === "user" ? "user" : task.ops ? "ops" : "ai",
-    status: taskStatusKind(task),
+    status: blocked.length > 0 ? "blocked" : taskStatusKind(task),
     running: isTaskRunning(task),
     awaiting: awaitingLabel(task),
+    resumes: resumeLabel(task, context.now),
     approvals: approvalLabel(task.awaitingApproval),
     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,
     repairing: isolation?.state === "repairing" ? { files: filesOf(isolation.conflictFiles), attempt: isolation.repair ?? null } : null,
     repaired: isolation?.repairedFiles?.length ? { files: capConflictFiles(isolation.repairedFiles), landed: isolation.state === "integrated" } : null,
-    mergeGate: task.mergeGate?.length ? refsOf(task.mergeGate, context.orderOf) : null,
+    mergeGate: task.mergeGate?.length ? refsOf(task.mergeGate, context.tasks) : null,
+    blockedBy: blocked.length > 0 ? refsOf(blocked, context.tasks) : null,
+    skipReason: task.status === "skipped" ? task.skipReason ?? null : null,
     opsChangedFiles: task.status === "awaiting_user" && task.awaitingReason === "files-changed",
     forcedPastGate: task.forcedPastGate?.length ? task.forcedPastGate : null,
-    dependencies: refsOf(task.dependencies, context.orderOf),
-    actions: taskRowActions(task, context.placement ?? (parent ? "subtask" : "task")),
+    dependencies: refsOf(task.dependencies, context.tasks),
+    // A block read off the plan offers what a stored one does: Skip among them.
+    actions: taskRowActions(blocked.length > 0 ? { ...task, status: "blocked" } : task, context.placement ?? (parent ? "subtask" : "task")),
     mark: markAction(task),
     opsEditable: opsEditable(task)
   };
 }
 
 // src/taskRow/texts.ts
-function findNamed(tasks, id) {
-  for (const task of tasks) {
-    if (task.id === id) return task;
-    const nested = findNamed(task.subtasks ?? [], id);
-    if (nested) return nested;
-  }
-  return void 0;
-}
 function titledRefs(ids, tasks) {
-  return ids.map((id) => {
-    const task = findNamed(tasks, id);
-    return task ? titledTaskRef(task) : id;
-  });
+  return ids.map((id) => titledTaskRefOf(tasks, id) ?? id);
 }
 function dependentsNotice(dependents) {
   if (dependents.length === 0) return null;
@@ -2178,6 +1759,13 @@ export {
   isMeasured,
   usageLine,
   plannerContextFill,
+  addModelUsage,
+  startAttemptUsage,
+  addAttemptUsage,
+  endAttemptUsage,
+  addUsageTotals,
+  planUsage,
+  sameMessage,
   mapAgentTool,
   normalizeAgentArgs,
   toolHeadline,
@@ -2193,31 +1781,19 @@ export {
   reduceTaskLog,
   replayTaskLog,
   capConflictFiles,
-  effectiveAllowlist,
-  filterModelsForPrompt,
-  clampThinkingEffort,
-  coerceAssignments,
-  isTaskRunning,
-  NOT_STARTED,
-  taskStatusKind,
-  awaitingLabel,
-  approvalLabel,
-  validateTaskEdit,
-  taskOpsProtocol,
-  textHasTaskOps,
-  parseTaskOpsJson,
-  taskOpRefs,
-  refMatchesTask,
-  canMergeTasks,
-  dependentsOf,
-  dependencyCandidates,
-  canSetDependencies,
-  canSplitTask,
-  applyTaskOps,
   summarizeToolCall,
   classifyOutcome,
+  blockingFailures,
   continuability,
   canContinue,
+  SUPERVISOR_LEVEL_LABEL,
+  supervisorSummary,
+  automergeSummary,
+  autorunSummary,
+  ACT_RISK,
+  AUTORUN_RISK,
+  parseSwitch,
+  parseCount,
   serializeTask,
   serializeTaskStatus,
   surfacePlan,
@@ -2226,6 +1802,8 @@ export {
   executionSummary,
   CHECKPOINT_TRUNCATE_LENGTH,
   truncateCheckpointSummary,
+  EMPTY_RUN,
+  reduceRun,
   EMPTY_CONVERSATION,
   reduceConversation,
   fromTranscript,
@@ -2233,6 +1811,7 @@ export {
   holdPrompt,
   drainNext,
   unsendLatest,
+  takeAt,
   unsendAll,
   aheadOfDraft,
   NO_TURN,
@@ -2251,4 +1830,4 @@ export {
   pastGateConfirmation,
   newTaskFields
 };
-//# sourceMappingURL=chunk-QUARDKVT.mjs.map
+//# sourceMappingURL=chunk-CH5IGWFS.mjs.map