@ordewell/core 0.9.1 → 0.10.0

package/dist/plan-utils.js

@@ -24,12 +24,21 @@ __export(plan_utils_exports, {
   DEFAULT_RUNNERS: () => DEFAULT_RUNNERS,
   EMPTY_CONVERSATION: () => EMPTY_CONVERSATION,
   EMPTY_HOLD: () => EMPTY_HOLD,
+  EMPTY_RUN: () => EMPTY_RUN,
   EMPTY_TASK_LOG: () => EMPTY_TASK_LOG,
   NOT_STARTED: () => NOT_STARTED,
   NO_TURN: () => NO_TURN,
+  SUPERVISOR_LEVEL_LABEL: () => SUPERVISOR_LEVEL_LABEL,
+  addAttemptUsage: () => addAttemptUsage,
+  addModelUsage: () => addModelUsage,
+  addPlannerUsage: () => addPlannerUsage,
+  addUsage: () => addUsage,
+  addUsageTotals: () => addUsageTotals,
   aheadOfDraft: () => aheadOfDraft,
   approvalLabel: () => approvalLabel,
   awaitingLabel: () => awaitingLabel,
+  blockedByLabel: () => blockedByLabel,
+  blockingFailures: () => blockingFailures,
   canMergeTasks: () => canMergeTasks,
   canSetDependencies: () => canSetDependencies,
   canSplitTask: () => canSplitTask,
@@ -41,10 +50,12 @@ __export(plan_utils_exports, {
   diffStat: () => diffStat,
   diffSummary: () => diffSummary,
   drainNext: () => drainNext,
+  endAttemptUsage: () => endAttemptUsage,
   followTurn: () => followTurn,
   fromTranscript: () => fromTranscript,
   hasHiddenDetail: () => hasHiddenDetail,
   holdPrompt: () => holdPrompt,
+  isMeasured: () => isMeasured,
   isTaskRunning: () => isTaskRunning,
   loadedSkillTokens: () => loadedSkillTokens,
   markAction: () => markAction,
@@ -54,32 +65,43 @@ __export(plan_utils_exports, {
   opsEditable: () => opsEditable,
   outputLines: () => outputLines,
   outputPreview: () => outputPreview,
+  parseCount: () => parseCount,
+  partedPromptUsage: () => partedPromptUsage,
   pastGateConfirmation: () => pastGateConfirmation,
+  pausedOnLimit: () => pausedOnLimit,
+  planUsage: () => planUsage,
+  plannerContextFill: () => plannerContextFill,
   reduceConversation: () => reduceConversation,
   reduceTaskLog: () => reduceTaskLog,
   replayTaskLog: () => replayTaskLog,
+  resolveTaskRef: () => resolveTaskRef,
+  resumeLabel: () => resumeLabel,
+  resumeTime: () => resumeTime,
   runnerToolSubject: () => runnerToolSubject,
   skillTokens: () => skillTokens,
+  skippedLabel: () => skippedLabel,
+  startAttemptUsage: () => startAttemptUsage,
   stopTurn: () => stopTurn,
   summarizeToolCall: () => summarizeToolCall,
+  takeAt: () => takeAt,
   taskOrderLabel: () => taskOrderLabel,
   taskRef: () => taskRef,
+  taskRefOf: () => taskRefOf,
   taskRowActions: () => taskRowActions,
   taskRowView: () => taskRowView,
   taskStartedNotice: () => taskStartedNotice,
   taskStatusKind: () => taskStatusKind,
   titledRefs: () => titledRefs,
   titledTaskRef: () => titledTaskRef,
+  titledTaskRefOf: () => titledTaskRefOf,
   toolHeadline: () => toolHeadline,
   truncateCheckpointSummary: () => truncateCheckpointSummary,
   unsendAll: () => unsendAll,
-  unsendLatest: () => unsendLatest
+  unsendLatest: () => unsendLatest,
+  usageLine: () => usageLine
 });
 module.exports = __toCommonJS(plan_utils_exports);
 
-// src/services/TaskOps.ts
-var import_uuid2 = require("uuid");
-
 // src/models/Task.ts
 var import_uuid = require("uuid");
 
@@ -102,9 +124,9 @@ function loadedSkillTokens(text2, loaded) {
   return skillTokens(text2).filter((t) => loaded.includes(t.name));
 }
 
-// src/order-labels.ts
+// src/services/TaskRefs.ts
 function taskOrderLabel(task, parent) {
-  return parent ? `${parent.order}.${task.order}` : String(task.order);
+  return parent ? `${parent.label ?? parent.order}.${task.order}` : String(task.order);
 }
 function taskRef(task, parent) {
   return `#${taskOrderLabel(task, parent)}`;
@@ -112,10 +134,49 @@ function taskRef(task, parent) {
 function titledTaskRef(task, parent) {
   return `${taskRef(task, parent)} ${task.title}`;
 }
+function* depthFirst(tasks, parent, parentLabel) {
+  for (const task of tasks) {
+    const label = taskOrderLabel(task, parent ? { order: parent.order, label: parentLabel } : void 0);
+    yield { task, parent, label };
+    yield* depthFirst(task.subtasks ?? [], task, label);
+  }
+}
+function findTaskRef(tasks, id) {
+  for (const match of depthFirst(tasks)) if (match.task.id === id) return match;
+  return void 0;
+}
+function taskRefOf(tasks, id) {
+  const found = findTaskRef(tasks, id);
+  return found && `#${found.label}`;
+}
+function titledTaskRefOf(tasks, id) {
+  const found = findTaskRef(tasks, id);
+  return found && `#${found.label} ${found.task.title}`;
+}
+function resolveTaskRef(tasks, ref) {
+  const s = String(ref).trim();
+  if (!s) return void 0;
+  for (const { task } of depthFirst(tasks)) if (task.id === s) return task;
+  const label = s.startsWith("#") ? s.slice(1) : s;
+  if (/^\d+(\.\d+)*$/.test(label)) {
+    let level = tasks;
+    let found;
+    for (const order of label.split(".").map(Number)) {
+      found = level?.find((t) => t.order === order);
+      level = found?.subtasks;
+    }
+    return found;
+  }
+  for (const { task } of depthFirst(tasks)) if (task.title === s) return task;
+  return void 0;
+}
 
 // src/models/Task.ts
 var SKILL_NAME = new RegExp(`^${SKILL_NAME_PATTERN}$`);
 var DEFAULT_RUNNERS = ["claude-code"];
+function pausedOnLimit(task) {
+  return task.status === "awaiting_user" && task.awaitingReason === "usage-limit";
+}
 
 // src/taskRow/status.ts
 var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
@@ -126,6 +187,8 @@ function taskStatusKind(task) {
       return "done";
     case "failed":
       return "failed";
+    case "skipped":
+      return "skipped";
     case "blocked":
       return "blocked";
     case "awaiting_user":
@@ -138,39 +201,63 @@ var AWAITING_LABELS = {
   input: "Waiting for your input",
   checkpoint: "Checkpoint",
   conflict: "Merge conflict",
-  "files-changed": "Changed tracked files"
+  "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";
+}
 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
-function detectCycle(tasks) {
+// src/services/PlannedTask.ts
+var import_uuid2 = require("uuid");
+function findCycle(tasks) {
   const byId = new Map(tasks.map((t) => [t.id, t]));
-  const visiting = /* @__PURE__ */ new Set();
+  const path = [];
   const done = /* @__PURE__ */ new Set();
   const visit = (id) => {
     if (done.has(id)) return null;
-    if (visiting.has(id)) return id;
-    visiting.add(id);
+    const at = path.indexOf(id);
+    if (at >= 0) return path.slice(at);
+    path.push(id);
     for (const dep of byId.get(id)?.dependencies ?? []) {
       const hit = visit(dep);
       if (hit) return hit;
     }
-    visiting.delete(id);
+    path.pop();
     done.add(id);
     return null;
   };
   for (const t of tasks) {
     const hit = visit(t.id);
-    if (hit) return byId.get(hit)?.title ?? hit;
+    if (hit) return hit.map((id) => byId.get(id));
   }
   return null;
 }
+function detectCycle(tasks) {
+  return findCycle(tasks)?.[0].title ?? null;
+}
+
+// src/services/TaskOps.ts
 function canMergeTasks(tasks, selectedIds) {
   if (selectedIds.length < 2) return { ok: false, error: "Select at least two tasks to merge" };
   const idSet = new Set(selectedIds);
@@ -467,9 +554,13 @@ function normalizeAgentArgs(tool, args) {
 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 } : {} };
@@ -488,8 +579,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",
@@ -528,6 +619,44 @@ function planMarker(content) {
   return { status: content.startsWith("Plan updated") ? "updated" : "generated", ...count ? { taskCount: Number(count[1]) } : {} };
 }
 
+// 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/SessionMessage.ts
 var CHECKPOINT_TRUNCATE_LENGTH = 120;
 function truncateCheckpointSummary(summary) {
@@ -541,7 +670,22 @@ function capConflictFiles(files, max = 5) {
   return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
 }
 
+// src/services/runSettingsText.ts
+var SUPERVISOR_LEVEL_LABEL = { off: "Off", watch: "Watch", act: "Act" };
+function parseCount(arg, min) {
+  if (arg === void 0 || !/^\d+$/.test(arg)) return null;
+  const n = Number(arg);
+  return n >= min ? n : null;
+}
+
 // src/models/Usage.ts
+function partedPromptUsage(parts) {
+  const reported = [parts.uncached, parts.cacheRead, parts.cacheWrite].filter((n) => n !== void 0);
+  return {
+    ...reported.length > 0 ? { inputTokens: reported.reduce((a, b) => a + b, 0) } : {},
+    ...parts.cacheRead !== void 0 ? { cachedInputTokens: parts.cacheRead } : {}
+  };
+}
 var TOKEN_FIELDS = ["inputTokens", "outputTokens", "cachedInputTokens"];
 function addUsage(totals, record) {
   const next = { ...totals };
@@ -556,13 +700,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) {
@@ -572,6 +724,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 } : {}
   };
@@ -580,6 +734,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/conversation/lanes.ts
 function findLastIndex(items, match) {
@@ -710,16 +906,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));
@@ -737,14 +972,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)));
@@ -858,6 +1094,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);
@@ -901,6 +1139,8 @@ function reduceConversation(view, input) {
       return settleApproval(view, input);
     case "approval_decided":
       return decideApproval(view, input);
+    case "execution_action":
+      return append(view, (id) => settledMessage(id, "system", input.text));
     case "planner_usage":
       return reportUsage(view, input);
     default:
@@ -918,9 +1158,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 = [];
@@ -931,7 +1184,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 {
@@ -989,7 +1242,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;
@@ -1003,9 +1256,27 @@ 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/utils/sameMessage.ts
+function sameMessage(a, b) {
+  const bare = (value) => value.trim().replace(/\.+$/, "").trimEnd();
+  return bare(a) !== "" && bare(a) === bare(b);
 }
 
 // src/conversation/taskLog.ts
@@ -1046,10 +1317,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 } : {} };
@@ -1114,19 +1392,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 requestApproval2(view, { approvalId, tool, args, allowForTask, toolCallId }) {
+function requestApproval2(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 settleApproval2(view, approvalId, settle) {
   const i = findLastIndex(view.blocks, (b) => b.type === "approval" && b.approvalId === approvalId);
@@ -1134,36 +1415,73 @@ function settleApproval2(view, approvalId, settle) {
   if (block?.type !== "approval" || block.status !== "pending") return view;
   return { ...view, blocks: replaceAt(view.blocks, i, settle(block)) };
 }
-function decideApproval2(view, { approvalId, decision, note }) {
-  return settleApproval2(view, approvalId, (block) => ({
+function answered(block, decision, note) {
+  return {
     ...block,
     status: decision === "deny" ? "denied" : "granted",
     decidedBy: "asked",
     ...decision === "allowForTask" ? { forTask: true } : {},
     ...note ? { note } : {}
-  }));
+  };
+}
+function decideApproval2(view, { approvalId, decision, note }) {
+  return settleApproval2(view, approvalId, (block) => answered(block, decision, note));
+}
+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, 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 startTurn(view, { message, messageId }) {
+function startCommand(view, { name, args, messageId }) {
   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;
+  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 endTurn2(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);
@@ -1171,18 +1489,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 endTurn2(view, event);
     case "text_delta":
@@ -1214,13 +1558,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 requestApproval2(view, event);
     case "approval_decided":
       return decideApproval2(view, event);
     case "approval_withdrawn":
       return settleApproval2(view, event.approvalId, (block) => ({ ...block, status: "withdrawn" }));
+    case "runner_ended":
+      return endOpenCalls(view);
     default:
       return view;
   }
@@ -1242,6 +1588,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 };
@@ -1295,7 +1645,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
@@ -1306,20 +1656,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") {
@@ -1330,7 +1689,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;
 }
@@ -1339,52 +1698,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;
@@ -1399,18 +1756,30 @@ function newTaskFields(title, prompt) {
   if (!name) return null;
   return { title: name, description: name, prompt: prompt?.trim() ? prompt : name, type: "ai" };
 }
+
+// src/services/runView.ts
+var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHECKPOINT_TRUNCATE_LENGTH,
   DEFAULT_RUNNERS,
   EMPTY_CONVERSATION,
   EMPTY_HOLD,
+  EMPTY_RUN,
   EMPTY_TASK_LOG,
   NOT_STARTED,
   NO_TURN,
+  SUPERVISOR_LEVEL_LABEL,
+  addAttemptUsage,
+  addModelUsage,
+  addPlannerUsage,
+  addUsage,
+  addUsageTotals,
   aheadOfDraft,
   approvalLabel,
   awaitingLabel,
+  blockedByLabel,
+  blockingFailures,
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
@@ -1422,10 +1791,12 @@ function newTaskFields(title, prompt) {
   diffStat,
   diffSummary,
   drainNext,
+  endAttemptUsage,
   followTurn,
   fromTranscript,
   hasHiddenDetail,
   holdPrompt,
+  isMeasured,
   isTaskRunning,
   loadedSkillTokens,
   markAction,
@@ -1435,25 +1806,39 @@ function newTaskFields(title, prompt) {
   opsEditable,
   outputLines,
   outputPreview,
+  parseCount,
+  partedPromptUsage,
   pastGateConfirmation,
+  pausedOnLimit,
+  planUsage,
+  plannerContextFill,
   reduceConversation,
   reduceTaskLog,
   replayTaskLog,
+  resolveTaskRef,
+  resumeLabel,
+  resumeTime,
   runnerToolSubject,
   skillTokens,
+  skippedLabel,
+  startAttemptUsage,
   stopTurn,
   summarizeToolCall,
+  takeAt,
   taskOrderLabel,
   taskRef,
+  taskRefOf,
   taskRowActions,
   taskRowView,
   taskStartedNotice,
   taskStatusKind,
   titledRefs,
   titledTaskRef,
+  titledTaskRefOf,
   toolHeadline,
   truncateCheckpointSummary,
   unsendAll,
-  unsendLatest
+  unsendLatest,
+  usageLine
 });
 //# sourceMappingURL=plan-utils.js.map