@ordewell/core 0.10.12 → 0.11.1

package/dist/plan-utils.js

@@ -37,27 +37,47 @@ __export(plan_utils_exports, {
   EMPTY_RUN: () => EMPTY_RUN,
   EMPTY_TASK_LOG: () => EMPTY_TASK_LOG,
   EMPTY_TASK_LOG_FOLLOW: () => EMPTY_TASK_LOG_FOLLOW,
+  IDLE_ACTIVITY: () => IDLE_ACTIVITY,
   NOT_STARTED: () => NOT_STARTED,
   NO_TURN: () => NO_TURN,
+  PLANNED_WITH_LABEL: () => PLANNED_WITH_LABEL,
+  REPORT_PREVIEW_LINES: () => REPORT_PREVIEW_LINES,
+  SEVERITY_LABEL: () => SEVERITY_LABEL,
   SUPERVISOR_LEVEL_LABEL: () => SUPERVISOR_LEVEL_LABEL,
   WAITS_FOR_APPROVAL_LABEL: () => WAITS_FOR_APPROVAL_LABEL,
+  accountLimitPercentText: () => accountLimitPercentText,
+  accountLimitWindowLabel: () => accountLimitWindowLabel,
+  accountLimitsOf: () => accountLimitsOf,
+  accountLimitsText: () => accountLimitsText,
+  accountLimitsTitle: () => accountLimitsTitle,
   addAttemptUsage: () => addAttemptUsage,
   addModelUsage: () => addModelUsage,
   addPlannerUsage: () => addPlannerUsage,
   addUsage: () => addUsage,
   addUsageTotals: () => addUsageTotals,
   aheadOfDraft: () => aheadOfDraft,
+  approvalKindText: () => approvalKindText,
   approvalLabel: () => approvalLabel,
+  approvalStatusText: () => approvalStatusText,
+  assignedRunnerOf: () => assignedRunnerOf,
   assignmentIssue: () => assignmentIssue,
   assignmentIssueText: () => assignmentIssueText,
   awaitingLabel: () => awaitingLabel,
+  betweenRounds: () => betweenRounds,
+  blockNotice: () => blockNotice,
+  blockNotices: () => blockNotices,
   blockedByLabel: () => blockedByLabel,
   blockingFailures: () => blockingFailures,
   canMergeTasks: () => canMergeTasks,
   canSetDependencies: () => canSetDependencies,
   canSplitTask: () => canSplitTask,
   capConflictFiles: () => capConflictFiles,
+  cardEditNeedsUnstarted: () => cardEditNeedsUnstarted,
+  cardEditable: () => cardEditable,
+  checkOf: () => checkOf,
   clampThinkingEffort: () => clampThinkingEffort,
+  compactionText: () => compactionText,
+  confirmedOverride: () => confirmedOverride,
   contextMeterText: () => contextMeterText,
   contextMeterTitle: () => contextMeterTitle,
   costText: () => costText,
@@ -65,47 +85,89 @@ __export(plan_utils_exports, {
   dependencyCandidates: () => dependencyCandidates,
   dependentsNotice: () => dependentsNotice,
   dependentsOf: () => dependentsOf,
+  describeIsolationPreview: () => describeIsolationPreview,
+  describeMergeResult: () => describeMergeResult,
   diffRows: () => diffRows,
   diffStat: () => diffStat,
   diffSummary: () => diffSummary,
   drainNext: () => drainNext,
+  editableWhileRunning: () => editableWhileRunning,
   endAttemptUsage: () => endAttemptUsage,
   followTaskLog: () => followTaskLog,
   followTurn: () => followTurn,
   formatCost: () => formatCost,
   formatTokenCount: () => formatTokenCount,
   fromTranscript: () => fromTranscript,
+  handoffBaseLine: () => handoffBaseLine,
+  handoffBranchName: () => handoffBranchName,
+  handoffFindingsText: () => handoffFindingsText,
+  handoffPeekParts: () => handoffPeekParts,
+  handoffReferenceText: () => handoffReferenceText,
+  hasAccountLimits: () => hasAccountLimits,
   hasHiddenDetail: () => hasHiddenDetail,
+  hasLongReport: () => hasLongReport,
+  holdLabel: () => holdLabel,
   holdPrompt: () => holdPrompt,
+  isFileEditTool: () => isFileEditTool,
   isMeasured: () => isMeasured,
+  isRepoGroup: () => isRepoGroup,
   isTaskRunning: () => isTaskRunning,
   loadedSkillTokens: () => loadedSkillTokens,
+  logContinues: () => logContinues,
+  logResumes: () => logResumes,
+  loopBodyLabel: () => loopBodyLabel,
+  loopBodyRound: () => loopBodyRound,
+  loopCheckLabel: () => loopCheckLabel,
+  loopCheckState: () => loopCheckState,
+  loopLeaveNotice: () => loopLeaveNotice,
+  loopRemovalRefusal: () => loopRemovalRefusal,
+  loopRoundOf: () => loopRoundOf,
+  loopRowParts: () => loopRowParts,
+  manualOverrideConfirmation: () => manualOverrideConfirmation,
+  manualOverrideStopFirst: () => manualOverrideStopFirst,
   markAction: () => markAction,
-  markRequestFor: () => markRequestFor,
   markdownHtml: () => markdownHtml,
   markdownTokens: () => markdownTokens,
+  mergeOutcome: () => mergeOutcome,
   modelCostTitle: () => modelCostTitle,
   namedRepos: () => namedRepos,
   newTaskFields: () => newTaskFields,
+  noExecutorRefusal: () => noExecutorRefusal,
   opsEditable: () => opsEditable,
+  outOfRounds: () => outOfRounds,
   outputLines: () => outputLines,
   outputPreview: () => outputPreview,
+  overrideNeedsConfirmation: () => overrideNeedsConfirmation,
   parseCount: () => parseCount,
   partedPromptUsage: () => partedPromptUsage,
   pastGateConfirmation: () => pastGateConfirmation,
+  patchView: () => patchView,
   pausedOnLimit: () => pausedOnLimit,
+  planBlocks: () => planBlocks,
+  planMarkerParts: () => planMarkerParts,
   planUsage: () => planUsage,
   plannerContextFill: () => plannerContextFill,
+  receiptLabel: () => receiptLabel,
   reconcileApprovals: () => reconcileApprovals,
   reduceConversation: () => reduceConversation,
   reduceTaskLog: () => reduceTaskLog,
+  repairedLanded: () => repairedLanded,
+  repairedNotice: () => repairedNotice,
+  repeatingChecks: () => repeatingChecks,
   replayTaskLog: () => replayTaskLog,
+  repoBaseLine: () => repoBaseLine,
+  repoResultLines: () => repoResultLines,
   resolveTaskRef: () => resolveTaskRef,
   resolveUserTaskRef: () => resolveUserTaskRef,
   resumeLabel: () => resumeLabel,
   resumeTime: () => resumeTime,
   resumedSessionWindow: () => resumedSessionWindow,
+  runHoldsEditors: () => runHoldsEditors,
   runnerToolSubject: () => runnerToolSubject,
+  savedPatchView: () => savedPatchView,
+  savedPatchViews: () => savedPatchViews,
+  scriptTaskText: () => scriptTaskText,
+  severityLabel: () => severityLabel,
   skillTokens: () => skillTokens,
   skippedLabel: () => skippedLabel,
   startAttemptUsage: () => startAttemptUsage,
@@ -114,6 +176,10 @@ __export(plan_utils_exports, {
   subtreeIds: () => subtreeIds,
   summarizeToolCall: () => summarizeToolCall,
   takeAt: () => takeAt,
+  taskActionCommand: () => taskActionCommand,
+  taskChatAvailable: () => taskChatAvailable,
+  taskLogCommands: () => taskLogCommands,
+  taskLogHeaderView: () => taskLogHeaderView,
   taskOrderLabel: () => taskOrderLabel,
   taskPlacement: () => taskPlacement,
   taskRef: () => taskRef,
@@ -133,7 +199,9 @@ __export(plan_utils_exports, {
   unsendLatest: () => unsendLatest,
   usageLine: () => usageLine,
   usageText: () => usageText,
-  walkPlan: () => walkPlan
+  wakeUpItems: () => wakeUpItems,
+  walkPlan: () => walkPlan,
+  worstSeverity: () => worstSeverity
 });
 module.exports = __toCommonJS(plan_utils_exports);
 
@@ -243,6 +311,9 @@ function canSetDependencies(tasks, taskId, dependencies) {
   return cycle ? { ok: false, error: `Dependency cycle detected: ${[...cycle, cycle[0]].map((t) => `"${t.title}"`).join(" \u2192 ")}` } : { ok: true };
 }
 
+// src/services/repoPath.ts
+var SELF_REPO = ".";
+
 // src/services/TaskRefs.ts
 function taskOrderLabel(task, parent) {
   return parent ? `${parent.label ?? parent.order}.${task.order}` : String(task.order);
@@ -331,10 +402,21 @@ function awaitingLabel(task) {
 function blockedByLabel(refs) {
   return `Blocked by ${refs.join(", ")}`;
 }
+function holdLabel(reason) {
+  return `On hold: ${reason}`;
+}
 function skippedLabel(reason) {
   return reason ? `Skipped: ${reason}` : "Skipped";
 }
 var WAITS_FOR_APPROVAL_LABEL = "Waits for your approval";
+var RECEIPT_LABELS = {
+  done: "Completion received",
+  failed: "Failure report received",
+  blocked: "Blocked report received"
+};
+function receiptLabel(task) {
+  return isTaskRunning(task) && task.completionReceived ? RECEIPT_LABELS[task.completionReceived] : null;
+}
 function approvalLabel(count) {
   if (!count) return null;
   return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
@@ -386,6 +468,106 @@ function clampThinkingEffort(effort, variants) {
   return void 0;
 }
 
+// src/models/ScriptTask.ts
+var DEFAULT_SCRIPT_TIMEOUT_MS = 10 * 6e4;
+var MAX_SCRIPT_TIMEOUT_MS = 24 * 60 * 6e4;
+var SCRIPT_BODY_FIELDS = ["commands", "script", "timeoutMs"];
+function scriptBodyOf(task) {
+  if (task.type !== "script" || scriptBodyErrors(task).length > 0) return null;
+  const timeoutMs = task.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS;
+  return task.commands ? { commands: task.commands.map((argv) => [...argv]), timeoutMs } : { script: task.script ?? "", timeoutMs };
+}
+function scriptBodyErrors(task) {
+  if (task.type !== "script") {
+    return SCRIPT_BODY_FIELDS.filter((f) => task[f] !== void 0).map((field) => ({ field, message: `has "${field}", which only a script task has: set "type": "script", or leave it out` }));
+  }
+  const errors = [];
+  const { commands, script, timeoutMs } = task;
+  if (commands !== void 0 && script !== void 0) {
+    errors.push({ field: "commands", message: 'has both "commands" and "script": a script task runs exactly one of them' });
+  } else if (commands === void 0 && script === void 0) {
+    errors.push({ field: "commands", message: 'is a script task with neither "commands" nor "script": give it the argument vectors to run, or the script' });
+  }
+  if (commands !== void 0) errors.push(...commandsErrors(commands));
+  if (script !== void 0 && (typeof script !== "string" || !script.trim())) {
+    errors.push({ field: "script", message: 'has an empty "script": write the script it runs' });
+  }
+  if (timeoutMs !== void 0 && !(typeof timeoutMs === "number" && Number.isInteger(timeoutMs) && timeoutMs > 0 && timeoutMs <= MAX_SCRIPT_TIMEOUT_MS)) {
+    errors.push({ field: "timeoutMs", message: `has "timeoutMs" ${JSON.stringify(timeoutMs)}: the time limit is a whole number of milliseconds from 1 to ${MAX_SCRIPT_TIMEOUT_MS}, or left out for ten minutes` });
+  }
+  return errors;
+}
+function commandsErrors(commands) {
+  const shape = 'a list of argument vectors, each a list of strings, like [["git", "push", "origin", "main"]]';
+  if (!Array.isArray(commands) || commands.length === 0) return [{ field: "commands", message: `has "commands" that is not ${shape}` }];
+  for (const [i, argv] of commands.entries()) {
+    const n = i + 1;
+    if (!Array.isArray(argv) || !argv.every((word) => typeof word === "string")) {
+      return [{ field: "commands", message: `has command ${n} that is not an argument vector: "commands" is ${shape}` }];
+    }
+    if (argv.length === 0) return [{ field: "commands", message: `has command ${n} as an empty argument vector: name the program it runs` }];
+    if (!argv[0].trim()) return [{ field: "commands", message: `has command ${n} naming no program: its first word is the program it runs` }];
+  }
+  return [];
+}
+var PLAIN_WORD = /^[A-Za-z0-9_@%+=:,./-]+$/;
+var UNSEEN = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+function commandLine(argv) {
+  return argv.map(quotedWord).join(" ");
+}
+function quotedWord(word) {
+  if (PLAIN_WORD.test(word)) return word;
+  if (!UNSEEN.test(word)) return `'${word.replace(/'/g, `'\\''`)}'`;
+  return `$'${[...word].map(escaped).join("")}'`;
+}
+var ESCAPES = { "\\": "\\\\", "'": "\\'", "\n": "\\n", "\r": "\\r", "	": "\\t" };
+function escaped(char) {
+  return ESCAPES[char] ?? (UNSEEN.test(char) ? codeOf(char) : char);
+}
+function codeOf(char) {
+  const code = char.codePointAt(0) ?? 0;
+  const hex = code.toString(16).toUpperCase();
+  return code <= 255 ? `\\x${hex.padStart(2, "0")}` : code <= 65535 ? `\\u${hex.padStart(4, "0")}` : `\\U${hex.padStart(8, "0")}`;
+}
+function scriptBodyText(body) {
+  const shown = "commands" in body ? body.commands.map(commandLine) : [body.script.replace(/\r\n|[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (char) => char === "\r\n" || char === "\n" || char === "	" ? char : `<U+${(char.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0")}>`)];
+  return [...shown, "", `Time limit: ${timeLimitText(body.timeoutMs)}.`].join("\n");
+}
+function scriptTaskText(task) {
+  const body = scriptBodyOf(task);
+  return body ? scriptBodyText(body) : "This script task has no valid body, so it cannot run.";
+}
+function timeLimitText(ms) {
+  const units = [[36e5, "hour"], [6e4, "minute"], [1e3, "second"], [1, "millisecond"]];
+  const [size, name] = units.find(([unit]) => ms % unit === 0) ?? units[units.length - 1];
+  const n = ms / size;
+  return `${n} ${name}${n === 1 ? "" : "s"}`;
+}
+
+// src/models/Loop.ts
+function loopRoundOf(check) {
+  return check.loopRound ?? 1;
+}
+function foundWanting(check) {
+  return check.verdict?.outcome === "fail" && check.verdict.reported === "failed";
+}
+function betweenRounds(check) {
+  return !!check.loop && check.status === "failed" && foundWanting(check) && loopRoundOf(check) < check.loop.maxRounds;
+}
+function outOfRounds(check) {
+  return !!check.loop && check.status === "failed" && foundWanting(check) && loopRoundOf(check) >= check.loop.maxRounds;
+}
+function checkOf(tasks, taskId) {
+  return tasks.find((t) => t.loop?.body.includes(taskId));
+}
+function loopRemovalRefusal(task) {
+  return task.loop ? `"${task.title}" is a loop's check: remove its body tasks first, or drop its loop ("loop": null), so they do not run on their own` : null;
+}
+function loopReshapeRefusal(tasks, target, action) {
+  if (target.loop) return `"${target.title}" is a loop's check and cannot be ${action}: drop its loop first ("loop": null)`;
+  return checkOf(tasks, target.id) ? `"${target.title}" is in a loop's body and cannot be ${action}: take it out of the loop first` : null;
+}
+
 // src/services/PlannedTask.ts
 function findCycle(tasks) {
   return findDependencyCycle(tasks);
@@ -403,6 +585,8 @@ function canMergeTasks(tasks, selectedIds) {
   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 looped = loopReshapeRefusal(tasks, t, "merged");
+    if (looped) return { ok: false, error: looped };
   }
   const ordered = [...toMerge].sort((a, b) => a.order - b.order);
   const survivorId = "__merge_sim__";
@@ -418,7 +602,8 @@ function canSplitTask(tasks, 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 };
+  const looped = loopReshapeRefusal(tasks, target, "split");
+  return looped ? { ok: false, error: looped } : { ok: true };
 }
 
 // src/services/researchStepSummary.ts
@@ -481,6 +666,72 @@ function summarizeToolCall(tool, argsJson, toolLabel) {
   }
   return display;
 }
+var SEALED_RUN_MARK = "[Ran sealed";
+function ranSealed(output) {
+  return output.startsWith(SEALED_RUN_MARK);
+}
+function withoutSealedMark(output) {
+  if (!ranSealed(output)) return output;
+  const end = output.indexOf("\n");
+  return end < 0 ? "" : output.slice(end + 1);
+}
+
+// src/services/harness/agentTools.ts
+var KNOWN_TOOLS = {
+  // Claude Code
+  read: "read_file",
+  grep: "grep",
+  glob: "glob",
+  bash: "bash",
+  // Its second shell tool, under the same opt-in and launcher (ADR-0036 N6).
+  monitor: "bash",
+  ls: "list_dir",
+  webfetch: "fetch",
+  websearch: "web_search",
+  // Codex — its sandboxed command tool is a shell by another name
+  shell: "bash",
+  exec_command: "bash",
+  local_shell: "bash",
+  // OpenCode
+  list: "list_dir",
+  fetch: "fetch",
+  // Ordewell's own research shell (ADR-0026), under every runner's name for it
+  runcommand: "bash"
+};
+var ORDEWELL_TOOL_PREFIX = /^(mcp__ordewell__|ordewell_)/i;
+var FILE_EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "multiedit", "notebookedit", "applypatch", "patch", "add", "update", "delete", "filechange"]);
+function isFileEditTool(name) {
+  return FILE_EDIT_TOOLS.has(name.trim().toLowerCase().replace(/[_-]/g, ""));
+}
+function mapAgentTool(name) {
+  const normalized = name.trim().replace(ORDEWELL_TOOL_PREFIX, "").toLowerCase().replace(/[_-]/g, "");
+  const direct = KNOWN_TOOLS[normalized] ?? KNOWN_TOOLS[name.trim().toLowerCase()];
+  if (direct) {
+    return { tool: direct, toolLabel: name };
+  }
+  return { tool: "agent_tool", toolLabel: name };
+}
+function normalizeAgentArgs(tool, args) {
+  const out = { ...args };
+  const alias = (from, to) => {
+    if (out[to] === void 0 && out[from] !== void 0) out[to] = out[from];
+  };
+  if (tool === "read_file" || tool === "list_dir") {
+    alias("filePath", "path");
+    alias("file_path", "path");
+    alias("target", "path");
+  }
+  if (tool === "bash") {
+    alias("cmd", "command");
+    alias("script", "command");
+    if (typeof out.command !== "string" && Array.isArray(out.command)) {
+      out.command = out.command.join(" ");
+    }
+  }
+  if (tool === "fetch") alias("uri", "url");
+  if (tool === "web_search") alias("q", "query");
+  return out;
+}
 
 // src/conversation/format.ts
 var ANSI_OR_CTRL_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[()][AB012]|\x1b[=>]|[\x00-\x08\x0b-\x1f\x7f]/g;
@@ -610,61 +861,6 @@ function diffSummary({ added, removed }) {
   return `Added ${lines(added)}, removed ${lines(removed)}`;
 }
 
-// src/services/harness/agentTools.ts
-var KNOWN_TOOLS = {
-  // Claude Code
-  read: "read_file",
-  grep: "grep",
-  glob: "glob",
-  bash: "bash",
-  ls: "list_dir",
-  webfetch: "fetch",
-  websearch: "web_search",
-  // Codex — its sandboxed command tool is a shell by another name
-  shell: "bash",
-  exec_command: "bash",
-  local_shell: "bash",
-  // OpenCode
-  list: "list_dir",
-  fetch: "fetch",
-  // Ordewell's own research shell (ADR-0026), under every runner's name for it
-  runcommand: "bash"
-};
-var ORDEWELL_TOOL_PREFIX = /^(mcp__ordewell__|ordewell_)/i;
-var FILE_EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "multiedit", "notebookedit", "applypatch", "patch", "add", "update", "delete", "filechange"]);
-function isFileEditTool(name) {
-  return FILE_EDIT_TOOLS.has(name.trim().toLowerCase().replace(/[_-]/g, ""));
-}
-function mapAgentTool(name) {
-  const normalized = name.trim().replace(ORDEWELL_TOOL_PREFIX, "").toLowerCase().replace(/[_-]/g, "");
-  const direct = KNOWN_TOOLS[normalized] ?? KNOWN_TOOLS[name.trim().toLowerCase()];
-  if (direct) {
-    return { tool: direct, toolLabel: name };
-  }
-  return { tool: "agent_tool", toolLabel: name };
-}
-function normalizeAgentArgs(tool, args) {
-  const out = { ...args };
-  const alias = (from, to) => {
-    if (out[to] === void 0 && out[from] !== void 0) out[to] = out[from];
-  };
-  if (tool === "read_file" || tool === "list_dir") {
-    alias("filePath", "path");
-    alias("file_path", "path");
-    alias("target", "path");
-  }
-  if (tool === "bash") {
-    alias("cmd", "command");
-    alias("script", "command");
-    if (typeof out.command !== "string" && Array.isArray(out.command)) {
-      out.command = out.command.join(" ");
-    }
-  }
-  if (tool === "fetch") alias("uri", "url");
-  if (tool === "web_search") alias("q", "query");
-  return out;
-}
-
 // src/conversation/records.ts
 function settledMessage(id, role, text2, turnId) {
   return { type: "message", id, role, text: text2, streaming: false, ...turnId ? { turnId } : {} };
@@ -694,6 +890,20 @@ function subagentBlock(id, { toolCallId, model, usage, turnId, ...fields }) {
     ...turnId ? { turnId } : {}
   };
 }
+function compactionBlock(id, { trigger, compactionId, origin, status, summary, preTokens, postTokens, turnId }) {
+  return {
+    type: "compaction",
+    id,
+    trigger,
+    ...compactionId ? { compactionId } : {},
+    ...origin ? { origin } : {},
+    ...status ? { status } : {},
+    ...summary ? { summary } : {},
+    ...preTokens !== void 0 ? { preTokens } : {},
+    ...postTokens !== void 0 ? { postTokens } : {},
+    ...turnId ? { turnId } : {}
+  };
+}
 function usageBlock(id, { totals, bySubagent, byModel, model, contextFill }) {
   return { type: "usage", id, totals, ...byModel ? { byModel } : {}, ...model ? { model } : {}, ...bySubagent ? { bySubagent } : {}, ...contextFill ? { contextFill } : {} };
 }
@@ -706,7 +916,9 @@ var STATUS_OF_OUTCOME = {
 };
 function finishedTool(call, output, outcome) {
   const diff = outcome === "success" && isFileEditTool(call.toolLabel ?? call.tool) ? diffStat(output) : null;
-  return { ...call, status: STATUS_OF_OUTCOME[outcome], outcome, output, outputLineCount: outputLines(output).length, ...diff ? { diff } : {} };
+  const sealed2 = call.tool === "bash" && ranSealed(output);
+  const shown = sealed2 ? withoutSealedMark(output) : output;
+  return { ...call, status: STATUS_OF_OUTCOME[outcome], outcome, output: shown, outputLineCount: outputLines(shown).length, ...diff ? { diff } : {}, ...sealed2 ? { sealed: sealed2 } : {} };
 }
 function settledTool(call, step) {
   return finishedTool(call, step.result, step.outcome);
@@ -737,6 +949,12 @@ function planMarker(content) {
 // src/services/blocking.ts
 var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved"]);
 function blockingFailures(tasks) {
+  return planBlocks(tasks).blocked;
+}
+function repeatingChecks(tasks) {
+  return planBlocks(tasks).repeating;
+}
+function planBlocks(tasks) {
   const byId = /* @__PURE__ */ new Map();
   const index = (list) => {
     for (const t of list) {
@@ -746,6 +964,19 @@ function blockingFailures(tasks) {
   };
   index(tasks);
   const memo = /* @__PURE__ */ new Map();
+  const stopped = /* @__PURE__ */ new Map();
+  const repeats = (check) => {
+    if (!betweenRounds(check)) return false;
+    const known = stopped.get(check.id);
+    if (known !== void 0) return !known;
+    stopped.set(check.id, false);
+    const halted = (check.loop?.body ?? []).some((id) => {
+      const body = byId.get(id);
+      return !!body && (body.status === "failed" || body.status === "skipped" || failuresOf(id, /* @__PURE__ */ new Set()).length > 0);
+    });
+    stopped.set(check.id, halted);
+    return !halted;
+  };
   const failuresOf = (id, visiting) => {
     const known = memo.get(id);
     if (known) return known;
@@ -756,8 +987,10 @@ function blockingFailures(tasks) {
     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);
+      if (dep.status === "failed") {
+        if (betweenRounds(dep) && (dep.loop?.body.includes(id) || repeats(dep))) continue;
+        failed.add(depId);
+      } else for (const root of failuresOf(depId, visiting)) failed.add(root);
     }
     visiting.delete(id);
     const result = [...failed];
@@ -765,14 +998,17 @@ function blockingFailures(tasks) {
     return result;
   };
   const blocked = /* @__PURE__ */ new Map();
-  for (const id of byId.keys()) {
+  const repeating = /* @__PURE__ */ new Set();
+  for (const [id, task] of byId) {
     const failures = failuresOf(id, /* @__PURE__ */ new Set());
     if (failures.length > 0) blocked.set(id, failures);
+    if (repeats(task)) repeating.add(id);
   }
-  return blocked;
+  return { blocked, repeating };
 }
 
 // src/services/SessionMessage.ts
+var IDLE_ACTIVITY = { starting: false, running: false, scheduled: false, resumable: false, advancesOnItsOwn: false };
 var CHECKPOINT_TRUNCATE_LENGTH = 120;
 function truncateCheckpointSummary(summary) {
   const firstLine = summary.split("\n")[0].trim();
@@ -785,8 +1021,155 @@ function capConflictFiles(files, max = 5) {
   return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
 }
 
+// src/services/mergeResultNotice.ts
+function blockNotice({ repo, reason, files, expected, actual, rebasing }) {
+  switch (reason) {
+    case "merge-in-progress":
+      return `${repo} has a merge in progress`;
+    case "conflict":
+      return `${repo} would conflict in ${files.join(", ")}`;
+    case "uncommitted-changes":
+      return `${repo} has uncommitted changes to ${files.join(", ")}`;
+    case "partial-landing":
+      return `${repo} holds part of a task whose landing could not be rolled back`;
+    case "wrong-branch":
+      return `${repo === SELF_REPO ? "your checkout" : repo} is ${actual ? `on ${actual}` : rebasing ? "in the middle of a rebase" : "on a detached HEAD"}; this run started on ${expected}`;
+    case "git-error":
+      return `git could not check ${repo}`;
+  }
+}
+function blockNotices(blocked) {
+  return blocked.map(blockNotice);
+}
+function branchFix(blocked) {
+  if (blocked.length === 0 || blocked.some((b) => b.reason !== "wrong-branch")) return "";
+  const rebasing = blocked.filter((b) => b.rebasing);
+  if (rebasing.length > 0) {
+    const where = rebasing.map((b) => b.repo === SELF_REPO ? "your checkout" : b.repo).join(", ");
+    return ` Finish or abort the rebase in ${where}${rebasing.length < blocked.length ? " and check out the branch each other repository started on" : ""}, then press Merge all again.`;
+  }
+  const started = [...new Set(blocked.map((b) => b.expected))];
+  return started.length === 1 && blocked.length === 1 ? ` Check out ${started[0]} and press Merge all again.` : " Check out the branch each repository started on and press Merge all again.";
+}
+function landedNotice(landed) {
+  if (landed.length === 0) return "Nothing was merged.";
+  return landed.length === 1 ? `${landed[0]} was merged already and stays merged.` : `${landed.join(", ")} were merged already and stay merged.`;
+}
+function repairedLanded(handoff) {
+  return handoff.landed.filter((t) => t.repairedFiles?.length);
+}
+function repairedNotice(handoff) {
+  const repaired = repairedLanded(handoff);
+  if (repaired.length === 0) return "";
+  const named = repaired.map((t) => `${t.title}${t.repairedFiles?.length ? ` (${capConflictFiles(t.repairedFiles)})` : ""}`);
+  const list = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
+  return ` ${list} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
+}
+function describeMergeResult(result, branch, group, repaired = []) {
+  switch (result.outcome) {
+    case "merged": {
+      const base = group ? `Merged ${branch} into the checked-out branch of every repository.` : `Merged ${branch} into your checked-out branch.`;
+      const repairedNoticeText = repairedNotice({ landed: repaired });
+      return { level: "info", message: `${base}${repairedNoticeText}` };
+    }
+    case "blocked":
+      return { level: "warn", message: `Merged nothing, so every tree is as it was: ${blockNotices(result.blocked).join("; ")}.${branchFix(result.blocked)}` };
+    case "conflict":
+      return {
+        level: "warn",
+        message: result.repo === SELF_REPO ? `Merging ${branch} conflicted, so it was aborted: your tree is as it was.` : `Merging ${branch} conflicted in ${result.repo}${result.files?.length ? ` (${result.files.join(", ")})` : ""}, so it was aborted there. ${landedNotice(result.landed ?? [])}`
+      };
+    case "failed": {
+      const lone = result.repo === SELF_REPO;
+      const where = lone ? "" : ` in ${result.repo}`;
+      if (result.error) {
+        return { level: "error", message: `Could not merge ${branch}${where}: git said "${result.error}". ${lone ? "Your tree is as it was." : landedNotice(result.landed ?? [])}` };
+      }
+      return {
+        level: "error",
+        message: lone ? `Could not merge ${branch}: finish or abort the merge already in progress, then try again.` : `Could not merge ${branch}${where}: finish or abort any merge in progress there, then try again. ${landedNotice(result.landed ?? [])}`
+      };
+    }
+  }
+}
+function mergeOutcome(result, branch, group, repaired = []) {
+  const ok = result.outcome === "merged";
+  if (!group && result.outcome === "conflict") {
+    return { ok, message: `Merging ${branch} conflicted, so it was aborted: your tree is as it was. Merge it with git and resolve the conflict there.` };
+  }
+  const { message } = describeMergeResult(result, branch, group, repaired);
+  return { ok, message: ok || !group ? message : `${message} Each repository's ${branch} is a plain branch you can merge by hand.` };
+}
+
+// src/services/isolationPreviewText.ts
+var SHARED_NAMED = 5;
+var OPS_TASKS = "Ops and script tasks use your checkout.";
+function repoName(repo) {
+  if (repo.path !== ".") return repo.path;
+  return repo.top ? `Repository above this workspace (${repo.top})` : "This workspace";
+}
+function repoDetail(repo, status) {
+  const head = repo.head;
+  const base = head.kind === "branch" ? `on ${head.branch} (${head.commit})` : head.kind === "detached" ? `detached HEAD at ${head.commit}` : head.kind === "unknown" ? "branch not read" : head.branch ? `no commits yet on ${head.branch}` : "no commits yet";
+  const shared = head.kind === "unborn" && (status === "ready" || status === "dirty") ? "; tasks share it instead of isolating it" : "";
+  return `${base}${shared}${repo.dirty ? " \xB7 uncommitted changes to tracked files" : ""}`;
+}
+function sharedLine(shared) {
+  if (shared.length === 0) return void 0;
+  const more = shared.length - SHARED_NAMED;
+  const named = shared.slice(0, SHARED_NAMED).join(", ");
+  return `Shared live between tasks: ${more > 0 ? `${named} and ${more} more` : named}`;
+}
+function describeIsolationPreview(preview) {
+  const repos = preview.repos.map((repo) => ({ name: repoName(repo), detail: repoDetail(repo, preview.status) }));
+  const shared = sharedLine(preview.shared);
+  const notice = (summary, note) => ({ summary, repos, ...shared ? { shared } : {}, ...note ? { note } : {} });
+  switch (preview.status) {
+    case "ready":
+      return notice("Code tasks run in isolated git worktrees based on the repositories and branches below.", `${OPS_TASKS} The base branch is read again when a run starts.`);
+    case "dirty":
+      return notice(
+        "Code tasks get isolated worktrees from the repositories and branches below once you decide what to do with uncommitted changes.",
+        `Starting a run asks whether to stash them or run without isolation. ${OPS_TASKS}`
+      );
+    case "disabled":
+      return notice("Worktree isolation is turned off, so tasks run in the workspace without isolated worktrees.");
+    case "git-missing":
+      return notice("Git was not found, so tasks run in the workspace without isolated worktrees.");
+    case "no-commits":
+      return notice("No repository has a commit yet, so tasks run in the workspace without isolated worktrees.");
+    case "no-repo":
+      return notice("No Git repository detected. Tasks run in the workspace without isolated worktrees.");
+    case "failed":
+      return notice(
+        "Could not read the Git repositories just now, so Ordewell can't say yet whether code tasks get isolated worktrees.",
+        `${preview.error ?? "Git did not answer"}. It is checked again when a run starts.`
+      );
+  }
+}
+
+// src/services/mergeWording.ts
+function isRepoGroup(handoff) {
+  return handoff.repos.some((r) => r.path !== ".");
+}
+function handoffBranchName(handoff) {
+  return [...new Set(handoff.repos.map((r) => r.integrationBranch))].join(", ");
+}
+function repoBaseLine(repo, length) {
+  const commit = repo.baseRef.slice(0, length);
+  return repo.baseBranch ? `${repo.baseBranch} @ ${commit}` : `${repo.startedDetached ? "detached at" : "base"} ${commit}`;
+}
+function handoffBaseLine(handoff, length) {
+  const group = isRepoGroup(handoff);
+  return handoff.repos.map((repo) => `${group ? `${repo.path}: ` : ""}${repoBaseLine(repo, length)}`).join(", ");
+}
+function repoResultLines(handoff) {
+  return handoff.repos.map(({ path, landed }) => `${path}: ${landed.length === 0 ? "nothing to merge" : `${landed.length} task${landed.length === 1 ? "" : "s"} landed`}`);
+}
+
 // src/services/runSettingsText.ts
 var SUPERVISOR_LEVEL_LABEL = { off: "Off", watch: "Watch", act: "Act" };
+var PLANNED_WITH_LABEL = "Planned-with line in commits Ordewell writes";
 function parseCount(arg, min) {
   if (arg === void 0 || !/^\d+$/.test(arg)) return null;
   const n = Number(arg);
@@ -970,13 +1353,17 @@ function formatCost(currency, amount) {
 function contextMeterText(fill) {
   if (!fill) return null;
   const used = `ctx ${formatTokenCount(fill.usedTokens)}`;
-  if (!fill.windowTokens) return used;
-  const share = fill.usedTokens / fill.windowTokens * 100;
-  return `${used} (${share < 1 ? "<1" : Math.round(share)}%)`;
+  const share = fill.windowTokens ? fill.usedTokens / fill.windowTokens * 100 : void 0;
+  const meter = share === void 0 ? used : `${used} (${share < 1 ? "<1" : Math.round(share)}%)`;
+  return fill.autoCompaction ? `${meter} \xB7 no auto-compact` : meter;
 }
 function contextMeterTitle(fill) {
   const used = fill.usedTokens.toLocaleString("en-US");
-  return fill.windowTokens ? `${used} of ${fill.windowTokens.toLocaleString("en-US")} tokens` : `${used} tokens`;
+  const counts = fill.windowTokens ? `${used} of ${fill.windowTokens.toLocaleString("en-US")} tokens` : `${used} tokens`;
+  const off = fill.autoCompaction;
+  if (!off) return counts;
+  const why = off.off === "settings" ? "Automatic compaction is off in the settings file" : off.model ? `Automatic compaction is off: no catalog Ordewell holds states ${off.model}'s window` : "Automatic compaction is off: no planner model is selected";
+  return `${counts}. ${why}; /compact still condenses the conversation.`;
 }
 function costParts(totals) {
   const rank = (currency) => currency.toLowerCase() === "usd" ? "" : currency.toUpperCase();
@@ -1023,6 +1410,13 @@ function tasksTotalText(tasks) {
   return parts.length > 0 ? `Tasks total: ${parts.join(" \xB7 ")}` : null;
 }
 
+// src/services/conversationSummary.ts
+function isCheckpoint(value) {
+  if (!value || typeof value !== "object") return false;
+  const { id, keptFrom, trigger } = value;
+  return typeof id === "string" && id !== "" && Number.isInteger(keptFrom) && (trigger === "manual" || trigger === "auto");
+}
+
 // src/conversation/lanes.ts
 function findLastIndex(items, match) {
   for (let i = items.length - 1; i >= 0; i--) if (match(items[i])) return i;
@@ -1136,7 +1530,11 @@ function closeSubagent(block, cut) {
   return status === block.status && children.every((c, i) => c === block.children[i]) ? block : { ...block, status, children };
 }
 function closeOpenBlocks(view, cut) {
-  const blocks = view.blocks.map((b) => b.type === "subagent" ? closeSubagent(b, cut) : closeBlock(b, cut !== null));
+  const blocks = view.blocks.map((b) => {
+    if (b.type === "subagent") return closeSubagent(b, cut);
+    if (b.type === "compaction") return b.status === "running" && (cut === "stopped" || cut === "failed") ? { ...b, status: cut } : b;
+    return closeBlock(b, cut !== null);
+  });
   return blocks.every((b, i) => b === view.blocks[i]) ? view : { ...view, blocks };
 }
 
@@ -1152,7 +1550,7 @@ 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.type === "command" || block.type === "compaction" || block.type === "runner_loaded" || block.type === "handoff") continue;
     if (block.turnId !== turnId) continue;
     return isUnsettledSegment(block, turnId) ? i : -1;
   }
@@ -1168,10 +1566,11 @@ function openTurn(view, { turnId, prompt = "", skills = [], wakeUps = [], forced
   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) {
+function takePendingInputs(view, prompt, wakeUps, turnId, heldAt) {
   const pending = view.pendingInputs ?? [];
-  const users = pending.filter(({ input }) => input.source === "user");
-  const updates = pending.filter(({ input }) => input.source === "supervisor");
+  const arrived = ({ input }) => heldAt === void 0 || input.timestamp <= heldAt;
+  const users = pending.filter((p) => p.input.source === "user" && arrived(p));
+  const updates = pending.filter((p) => p.input.source === "supervisor" && arrived(p));
   const taken = /* @__PURE__ */ new Set();
   let matchedPrompt = false;
   for (let n = 1; prompt !== void 0 && n <= users.length; n++) {
@@ -1307,7 +1706,7 @@ function markPlan(view, content, turnId) {
   }
   return append(view, (id) => ({ type: "plan", id, text: "", ...marker }));
 }
-function requestApproval(view, { id: approvalId, kind, subject, scope, detail, turnId }) {
+function requestApproval(view, { id: approvalId, kind, subject, scope, detail, body, turnId }) {
   return append(view, (id) => ({
     type: "approval",
     id,
@@ -1317,6 +1716,7 @@ function requestApproval(view, { id: approvalId, kind, subject, scope, detail, t
     scope,
     status: "pending",
     ...detail ? { detail } : {},
+    ...body ? { body } : {},
     ...turnId ? { turnId } : {}
   }));
 }
@@ -1347,11 +1747,48 @@ function endTurn(view, { turnId, outcome }) {
   if (planText >= 0) next = { ...next, blocks: next.blocks.filter((_, i) => i !== planText) };
   return closeOpenBlocks(next, outcome === "stopped" ? "stopped" : outcome === "error" ? "failed" : null);
 }
-function markCompaction(view, summary) {
+function compactionAt(view, compactionId) {
+  return findLastIndex(view.blocks, (b) => b.type === "compaction" && b.compactionId === compactionId);
+}
+function followCompaction(view, { compaction, turnId }) {
+  const i = compactionAt(view, compaction.id);
+  const at = view.blocks[i];
+  const known = at?.type === "compaction" ? at : void 0;
+  if (compaction.phase === "started") {
+    if (known) return view;
+    return append(view, (id) => compactionBlock(id, { compactionId: compaction.id, origin: compaction.origin, trigger: compaction.trigger, status: "running", turnId }));
+  }
+  const { outcome, preTokens, postTokens } = compaction;
+  if (known && known.status !== "running") return view;
+  if (outcome === "unchanged") return known ? { ...view, blocks: view.blocks.filter((_, n) => n !== i) } : view;
+  if (!known && (outcome === "stopped" || outcome === "failed")) return view;
+  const ended = (id) => compactionBlock(id, {
+    compactionId: compaction.id,
+    origin: compaction.origin,
+    trigger: compaction.trigger,
+    status: outcome,
+    preTokens,
+    postTokens,
+    turnId: known?.turnId ?? turnId
+  });
+  return known ? { ...view, blocks: replaceAt(view.blocks, i, ended(known.id)) } : append(view, ended);
+}
+function markCompaction(view, entry) {
+  const { content: summary } = entry;
+  const checkpoint = isCheckpoint(entry.checkpoint) ? entry.checkpoint : void 0;
+  if (checkpoint) {
+    const i2 = compactionAt(view, checkpoint.id);
+    const known = view.blocks[i2];
+    if (known?.type !== "compaction") {
+      return append(view, (id) => compactionBlock(id, { compactionId: checkpoint.id, origin: "ordewell", trigger: checkpoint.trigger, status: "condensed", summary }));
+    }
+    if (known.status === "condensed" && known.summary === summary) return view;
+    return { ...view, blocks: replaceAt(view.blocks, i2, { ...known, status: "condensed", summary }) };
+  }
+  const settled = (id) => compactionBlock(id, { origin: "ordewell", trigger: "manual", status: "condensed", summary });
   const i = findLastIndex(view.blocks, (b) => b.type === "message" && b.role === "planner" && b.turnId === void 0 && b.text === summary);
   const announced = view.blocks[i];
-  if (announced?.type === "message") return { ...view, blocks: replaceAt(view.blocks, i, { ...announced, role: "system" }) };
-  return append(view, (id) => settledMessage(id, "system", summary));
+  return announced ? { ...view, blocks: replaceAt(view.blocks, i, settled(announced.id)) } : append(view, settled);
 }
 function syncTranscript(view, { plan, turnId }) {
   const history = plan.conversationHistory ?? [];
@@ -1360,12 +1797,13 @@ 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;
+    const heldAt = isNew ? void 0 : entry.timestamp;
+    if (entry.role === "user" && !entry.kind) next = takePendingInputs(next, entry.content, [], void 0, heldAt).view;
+    if (entry.kind === "wake_up") next = takePendingInputs(next, void 0, [entry.content], void 0, heldAt).view;
     if (isNew && entry.kind === "plan_generated") next = markPlan(next, entry.content, i === committed ? turnId : void 0);
     if (isNew && entry.kind === "system") next = append(next, (id) => settledMessage(id, "system", entry.content));
     if (isNew && entry.kind === "error") next = append(next, (id) => settledMessage(id, "error", entry.content));
-    if (isNew && entry.kind === "compaction") next = markCompaction(next, entry.content);
+    if (isNew && entry.kind === "compaction") next = markCompaction(next, entry);
     if (latest === void 0 || entry.timestamp > latest) latest = entry.timestamp;
   }
   return next === view && latest === view.transcriptAt ? view : { ...next, transcriptAt: latest };
@@ -1417,6 +1855,8 @@ function reduceConversation(view, input) {
       return append(view, (id) => settledMessage(id, "system", input.text));
     case "planner_usage":
       return reportUsage(view, input);
+    case "planner_compaction":
+      return followCompaction(view, input);
     default:
       return view;
   }
@@ -1432,13 +1872,22 @@ function fromEntry(entry, loaded = []) {
     const { skill } = entry;
     return (id) => skillLoadBlock(id(), skillLoadNotice(skill));
   }
+  if (entry.kind === "compaction") {
+    const checkpoint = isCheckpoint(entry.checkpoint) ? entry.checkpoint : void 0;
+    return (id) => compactionBlock(id(), {
+      compactionId: checkpoint?.id,
+      origin: "ordewell",
+      trigger: checkpoint?.trigger ?? "manual",
+      status: "condensed",
+      summary: 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":
@@ -1549,6 +1998,17 @@ function fromTranscript(conversationHistory, researchLog, plannerUsage, pendingT
   return { blocks, nextId, ...transcriptAt ? { transcriptAt } : {}, ...pendingInputs.length > 0 ? { pendingInputs } : {} };
 }
 
+// src/models/TaskLog.ts
+function secondsText(ms) {
+  return `${Math.round(ms / 100) / 10} s`;
+}
+function scriptExitText(exit) {
+  const seconds = secondsText(exit.durationMs);
+  if (exit.error !== void 0) return `could not start: ${exit.error}`;
+  const how = exit.signal ? `ended by ${exit.signal}` : `exited ${exit.code ?? "unknown"}`;
+  return `${how} after ${seconds}${exit.timedOut ? ": the time limit ran out" : ""}`;
+}
+
 // src/utils/sameMessage.ts
 function sameMessage(a, b) {
   const bare = (value) => value.trim().replace(/\.+$/, "").trimEnd();
@@ -1785,6 +2245,43 @@ function unqueueMessage(view, { messageId }) {
   const queued = view.queued.filter((m) => m.id !== messageId);
   return queued.length === view.queued.length ? view : { ...view, queued };
 }
+function runScriptStep(view, event) {
+  const [command, toolLabel] = "argv" in event ? [commandLine(event.argv), "Run"] : [event.script, "Script"];
+  return appendOutput({ ...view, working: true }, null, (id) => pendingTool(id, { tool: "bash", toolLabel, args: JSON.stringify({ command }) }));
+}
+function runningScriptStep(view) {
+  return findLastIndex(view.blocks, (b) => b.type === "tool" && b.status === "pending" && b.tool === "bash");
+}
+function scriptStepOutput(view, { text: text2, omittedChars }) {
+  const said = omittedChars ? `\u2026 ${omittedChars} characters omitted \u2026
+${text2}` : text2;
+  const i = runningScriptStep(view);
+  const block = view.blocks[i];
+  if (block?.type !== "tool") return append(view, (id) => settledMessage(id, "system", said));
+  const output = block.output + said;
+  return { ...view, blocks: replaceAt(view.blocks, i, { ...block, output, outputLineCount: outputLines(output).length }) };
+}
+function endScriptStep(view, event) {
+  const status = scriptExitText(event);
+  const passed = event.code === 0 && !event.signal && event.error === void 0;
+  const i = runningScriptStep(view);
+  const block = view.blocks[i];
+  const ended = { ...view, working: false };
+  if (block?.type !== "tool") return append(ended, (id) => settledMessage(id, "system", status));
+  const output = block.output.trim() ? `${block.output.replace(/\n+$/, "")}
+${status}` : status;
+  return { ...ended, blocks: replaceAt(view.blocks, i, finishedTool(block, output, passed ? "success" : "failure")) };
+}
+function sameHandoff(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function showHandoff(view, { handoff }) {
+  const i = findLastIndex(view.blocks, (b) => b.type === "handoff");
+  const block = view.blocks[i];
+  if (block?.type !== "handoff") return appendStep(view, (id) => ({ type: "handoff", id, handoff }));
+  if (sameHandoff(block.handoff, handoff)) return view;
+  return { ...view, blocks: replaceAt(view.blocks, i, { ...block, handoff }) };
+}
 function endCall(block) {
   return block.type === "tool" && block.status === "pending" ? finishedTool(block, "", "not_executed") : block;
 }
@@ -1857,6 +2354,14 @@ function reduceTaskLog(view, event) {
       return decideApproval2(view, event);
     case "approval_withdrawn":
       return settleApproval2(view, event.approvalId, (block) => ({ ...block, status: "withdrawn" }));
+    case "script_run":
+      return runScriptStep(view, event);
+    case "script_output":
+      return scriptStepOutput(view, event);
+    case "script_exit":
+      return endScriptStep(view, event);
+    case "handoff":
+      return showHandoff(view, event);
     case "runner_ended":
       return closeOpenBlocks({ ...endOpenCalls(view), working: false, streams: {}, latestText: void 0 }, "stopped");
     default:
@@ -1867,6 +2372,161 @@ function replayTaskLog(events, from = EMPTY_TASK_LOG) {
   return events.reduce(reduceTaskLog, from);
 }
 
+// src/models/Handoff.ts
+var SEVERITY_LABEL = {
+  blocker: "Blocker",
+  major: "Major",
+  minor: "Minor",
+  info: "Info"
+};
+function severityLabel(severity) {
+  return SEVERITY_LABEL[severity];
+}
+var SEVERITY_RANK = { blocker: 0, major: 1, minor: 2, info: 3 };
+function worstSeverity(findings) {
+  let worst = null;
+  for (const { severity } of findings) {
+    if (worst === null || SEVERITY_RANK[severity] < SEVERITY_RANK[worst]) worst = severity;
+  }
+  return worst;
+}
+function handoffReferenceText(ref, taskName = () => void 0) {
+  switch (ref.kind) {
+    case "file":
+      return `${ref.line !== void 0 ? `${ref.path}:${ref.line}` : ref.path}${ref.resolved === true ? "" : " (unresolved)"}`;
+    case "commit":
+      return `commit ${ref.sha}${ref.repo ? ` in ${ref.repo}` : ""}${ref.resolved === true ? "" : " (unresolved)"}`;
+    case "task":
+      return `task ${taskName(ref.task) ?? ref.task}${ref.finding ? ` ${ref.finding}` : ""}`;
+    case "url":
+      return ref.url;
+    case "patch":
+      return patchText(ref);
+  }
+}
+var FLAG_WORDS = {
+  excluded: "not carried (links and submodules)",
+  dropped: "dropped over the size cap",
+  normalized: "normalized by git attributes"
+};
+function counted(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function byteSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function patchFlagText(flag) {
+  const more = flag.count - flag.paths.length;
+  return `${FLAG_WORDS[flag.kind]}: ${counted(flag.count, "file")}${flag.paths.length ? ` (${flag.paths.join(", ")}${more > 0 ? `, +${more} more` : ""})` : ""}`;
+}
+function patchChangesText(patch) {
+  const binary = patch.binary > 0 ? `, ${patch.binary} binary` : "";
+  return `${counted(patch.files, "file")}${binary}, +${patch.added} -${patch.removed}, ${byteSize(patch.bytes)}`;
+}
+function patchLinesText(patch) {
+  const binary = patch.binary > 0 ? `, ${patch.binary} binary` : "";
+  return `${counted(patch.files, "file")}${binary}, +${patch.added} -${patch.removed}`;
+}
+function patchText(patch) {
+  const flags = patch.flags?.length ? `; ${patch.flags.map(patchFlagText).join("; ")}` : "";
+  return `patch ${patch.path} (attempt ${patch.attempt}): ${patchChangesText(patch)}, from commit ${patch.base.slice(0, 12)}${flags}`;
+}
+function patchView(patch) {
+  return {
+    path: patch.path,
+    attempt: `attempt ${patch.attempt}`,
+    changes: patchChangesText(patch),
+    base: `from commit ${patch.base.slice(0, 12)}`,
+    saved: `saved as ${patch.path} (attempt ${patch.attempt})`,
+    flags: (patch.flags ?? []).map(patchFlagText),
+    peek: `patch: ${patchLinesText(patch)}`
+  };
+}
+function savedPatchViews(handoff) {
+  return (handoff?.artifacts ?? []).filter((a) => a.kind === "patch").map(patchView);
+}
+function savedPatchView(handoff) {
+  return savedPatchViews(handoff)[0] ?? null;
+}
+
+// src/conversation/labels.ts
+var APPROVAL_KIND_TEXT = {
+  shell_command: "Run a command",
+  url_fetch: "Fetch a URL",
+  web_search: "Search the web",
+  external_path: "Read outside the workspace",
+  mcp_tool: "Use an MCP tool",
+  mcp_server: "Start a project MCP server",
+  runner_tool: "Use a tool",
+  task_start: "Start work"
+};
+function approvalKindText(kind) {
+  return APPROVAL_KIND_TEXT[kind];
+}
+var APPROVAL_SOURCE_TEXT = {
+  "pre-approved": "pre-approved",
+  remembered: "remembered",
+  mode: "policy",
+  "no-channel": "no approval channel",
+  excluded: "excluded",
+  guard: "blocked address",
+  secret: "secret check",
+  budget: "web-read budget",
+  unsupported: "not usable on this runner version"
+};
+function approvalStatusText(block) {
+  const policy = block.decidedBy && block.decidedBy !== "asked" ? APPROVAL_SOURCE_TEXT[block.decidedBy] : void 0;
+  switch (block.status) {
+    case "pending":
+      return "Waiting for you";
+    case "granted":
+      return policy ? `Auto-approved (${policy})` : block.forTask ? "Approved for this task" : "Approved";
+    case "denied":
+      return policy ? `Auto-denied (${policy})` : "Denied";
+    case "withdrawn":
+      return "Withdrawn";
+  }
+}
+function planMarkerParts(block) {
+  if (block.status === "building") return ["Building plan\u2026"];
+  const count = block.taskCount === void 0 ? [] : [`${block.taskCount} task${block.taskCount === 1 ? "" : "s"}`];
+  return [`Plan ${block.status}`, ...count];
+}
+function handoffFindingsText(count) {
+  return count === 0 ? "no findings" : `${count} finding${count === 1 ? "" : "s"}`;
+}
+function firstNonBlankLine(text2) {
+  return text2.split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "") ?? "";
+}
+function handoffPeekParts(handoff) {
+  const severity = handoff.severity ? [severityLabel(handoff.severity)] : [];
+  const commit = handoff.commit ? [`Commit: ${handoff.commit.subject.trim()}`] : [];
+  const summary = firstNonBlankLine(handoff.summary);
+  return [handoffFindingsText(handoff.findingCount), ...severity, ...handoff.patch ? [handoff.patch.peek] : [], ...commit, ...summary ? [summary] : []];
+}
+var COMPACTION_STATUS_TEXT = {
+  running: "Compacting context\u2026",
+  stopped: "Compaction stopped \xB7 nothing changed",
+  failed: "Compaction failed \xB7 nothing changed",
+  paused: "Context does not fit \xB7 the planner is paused",
+  pruned: "Older tool output trimmed from context",
+  unchanged: "Context unchanged"
+};
+function compactedBy({ origin, trigger }) {
+  if (origin === "native") return trigger === "auto" ? "The planner compacted its context on its own" : "The planner compacted its context";
+  if (origin === "ordewell") return trigger === "auto" ? "Context compacted automatically" : "Context compacted";
+  return trigger === "auto" ? "Context compacted by the runner on its own" : "Context compacted";
+}
+function compactionText(block) {
+  const status = block.status ? COMPACTION_STATUS_TEXT[block.status] : void 0;
+  if (status) return status;
+  const { preTokens, postTokens } = block;
+  const sizes = preTokens !== void 0 && postTokens !== void 0 ? ` \xB7 ${formatTokenCount(preTokens)} \u2192 ${formatTokenCount(postTokens)} tokens` : "";
+  return `${compactedBy(block)}${sizes}`;
+}
+
 // src/conversation/promptHold.ts
 var EMPTY_HOLD = [];
 function holdPrompt(hold, text2) {
@@ -1935,9 +2595,45 @@ function stopTurn(view, gate) {
   };
 }
 
+// src/services/WakePolicy.ts
+var REPORT_LEAD = ", whose result you asked for, has ended.";
+
+// src/conversation/wakeUp.ts
+var DIGEST_HEAD = "Run update:";
+var REPORT_PREVIEW_LINES = 8;
+function hasLongReport(text2) {
+  return wakeUpItems(text2).some((item) => item.kind === "report" && item.lines.length > REPORT_PREVIEW_LINES);
+}
+var REPORTED = /^task (#[\d.]+ ".*")$/;
+function wakeUpItems(text2) {
+  const items = [];
+  let report = null;
+  for (const line of text2.replace(/\r\n?/g, "\n").split("\n")) {
+    if (report && (line.startsWith("  ") || line === "")) {
+      report.lines.push(line.slice(2));
+      continue;
+    }
+    report = null;
+    if (line === DIGEST_HEAD && items.length === 0) continue;
+    const bullet = line.startsWith("- ") ? line.slice(2) : null;
+    const at = bullet?.indexOf(REPORT_LEAD) ?? -1;
+    const task = bullet === null || at < 0 ? void 0 : REPORTED.exec(bullet.slice(0, at))?.[1];
+    if (bullet !== null && task !== void 0) {
+      report = { kind: "report", task, lines: [bullet.slice(at + REPORT_LEAD.length).trimStart()] };
+      items.push(report);
+    } else items.push({ kind: "line", text: line });
+  }
+  return items.map((item) => item.kind === "report" ? { ...item, lines: trimmed(item.lines) } : item);
+}
+function trimmed(lines2) {
+  const kept = [...lines2];
+  while (kept.length > 1 && kept[kept.length - 1].trim() === "") kept.pop();
+  return kept;
+}
+
 // src/conversation/detail.ts
 function hasHiddenDetail(blocks) {
-  return blocks.some((b) => b.type === "thinking" || b.type === "tool" || b.type === "subagent" || b.type === "runner_loaded");
+  return blocks.some((b) => b.type === "thinking" || b.type === "tool" || b.type === "subagent" || b.type === "runner_loaded" || b.type === "message" && b.role === "wake_up" && hasLongReport(b.text) || b.type === "handoff" && (b.handoff.report?.replace(/\n+$/, "").split("\n").length ?? 0) > REPORT_PREVIEW_LINES);
 }
 
 // src/conversation/notices.ts
@@ -2029,8 +2725,26 @@ function followTaskLog(state, input) {
   }
 }
 
+// src/taskRow/editability.ts
+function editableWhileRunning(task, run) {
+  if (!NOT_STARTED.has(task.status)) return false;
+  if (!run) return true;
+  if ((run.awaitingApproval ?? 0) > 0) return false;
+  return run.isolation?.state !== "active" && run.isolation?.state !== "repairing";
+}
+function runHoldsEditors(isExecuting, activity) {
+  return isExecuting || activity.starting || activity.advancesOnItsOwn;
+}
+function cardEditable(runHolds, task, run) {
+  return !runHolds || editableWhileRunning(task, run);
+}
+function cardEditNeedsUnstarted(runHolds, task) {
+  return runHolds || NOT_STARTED.has(task.status);
+}
+
 // src/taskRow/actions.ts
 var UNSTARTED_AI = (t) => t.type === "ai" && NOT_STARTED.has(t.status);
+var UNSTARTED_RUN = (t) => t.type !== "user" && 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;
@@ -2041,7 +2755,7 @@ var TASK_RULES = [
   ["resume-now", RESUMABLE],
   ["cancel-resume", RESUMES],
   ["skip", HOLDS_UP],
-  ["force-start", UNSTARTED_AI],
+  ["force-start", UNSTARTED_RUN],
   // 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"],
@@ -2064,16 +2778,43 @@ function taskRowActions(task, placement = "task") {
 function markAction(task) {
   return task.status === "completed" ? "uncomplete" : "complete";
 }
-function markRequestFor(action) {
-  if (action === "complete") return "complete";
-  if (action === "uncomplete") return "uncomplete";
-  return null;
+function taskActionCommand(action, task, reason) {
+  switch (action) {
+    case "run":
+      return { command: "run_task", task };
+    case "retry":
+      return { command: "retry_task", task, from: "fresh" };
+    case "cancel":
+      return { command: "stop_task", task };
+    // The user says the limit has reset early: the task resumes in its saved session now.
+    case "resume-now":
+      return { command: "retry_task", task, from: "session" };
+    case "cancel-resume":
+      return { command: "cancel_resume", task };
+    case "skip":
+      return { command: "skip_task", task, ...reason ? { reason } : {} };
+    case "force-start":
+      return { command: "force_start", task };
+    case "complete":
+      return { command: "mark_complete", task };
+    case "uncomplete":
+      return { command: "mark_not_done", task };
+  }
+}
+function overrideNeedsConfirmation(task) {
+  return task.type !== "user";
+}
+function confirmedOverride(command, seen) {
+  return command.command === "mark_complete" || command.command === "mark_not_done" ? { ...command, confirmed: true, ...seen ? { seen } : {} } : command;
 }
 function opsEditable(task) {
   return UNSTARTED_AI(task);
 }
 
 // src/services/AssignmentScope.ts
+function assignedRunnerOf(task) {
+  return task.type === "ai" ? task.assignedRunner || void 0 : void 0;
+}
 var OVER = /* @__PURE__ */ new Set(["completed", "skipped"]);
 function assignmentIssue(task, scope) {
   if (task.type !== "ai" || OVER.has(task.status)) return null;
@@ -2098,15 +2839,105 @@ function assignmentConsequence({ status, awaitingReason, resumeAt }) {
   return "runs as assigned unless moved";
 }
 
+// src/taskRow/loop.ts
+function loopCheckState(check, goesOn) {
+  switch (check.status) {
+    case "completed":
+      return "passed";
+    case "in_progress":
+    case "running":
+    case "awaiting_user":
+      return "running";
+    case "failed":
+      if (betweenRounds(check)) return goesOn ? "repeating" : "stopped";
+      return outOfRounds(check) ? "out-of-rounds" : "failed";
+    case "pending":
+    case "approved":
+    case "blocked":
+      return loopRoundOf(check) > 1 ? "running" : "waiting";
+    default:
+      return "ended";
+  }
+}
+var roundsOf = (count) => `${count} round${count === 1 ? "" : "s"}`;
+function loopCheckLabel(check, state) {
+  const round = loopRoundOf(check);
+  const of = `round ${round} of ${check.loop.maxRounds}`;
+  switch (state) {
+    case "waiting":
+    case "ended":
+      return `Loop of up to ${roundsOf(check.loop.maxRounds)}`;
+    case "running":
+      return `Round ${round} of ${check.loop.maxRounds}`;
+    case "repeating":
+      return `Round ${round} of ${check.loop.maxRounds}: fixing`;
+    case "stopped":
+      return `Stopped in ${of}`;
+    case "failed":
+      return `Failed in ${of}`;
+    case "passed":
+      return `${check.verdict?.outcome === "pass" ? "Passed" : "Completed"} in ${of}`;
+    case "out-of-rounds":
+      return `Failed after ${roundsOf(round)}`;
+  }
+}
+function loopBodyRound(check, bodyStatus) {
+  if (!["in_progress", "running", "awaiting_user", "completed", "failed"].includes(bodyStatus)) return null;
+  return check.status === "failed" ? loopRoundOf(check) : Math.max(1, loopRoundOf(check) - 1);
+}
+function loopBodyLabel(checkRef, round, maxRounds) {
+  return `Runs if ${checkRef} fails${round === null ? "" : ` (round ${round} of ${maxRounds})`}`;
+}
+
 // src/taskRow/view.ts
+function taskChatAvailable(task) {
+  if (task.type === "user") return false;
+  return task.attempted === true || (task.attemptUsage?.length ?? 0) > 0;
+}
 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) ?? [];
+var asBlocking = (tasks) => tasks.map((t) => ({
+  id: t.id,
+  status: t.status ?? "",
+  dependencies: t.dependencies ?? [],
+  subtasks: asBlocking(t.subtasks ?? []),
+  ...t.loop ? { loop: t.loop, loopRound: t.loopRound, ...t.verdict ? { verdict: t.verdict } : {} } : {}
+}));
+function blockedBy(task, reading) {
+  if (!reading || !NOT_STARTED.has(task.status)) return [];
+  return reading.blocks.blocked.get(task.id) ?? [];
+}
+function loopOf(task, reading) {
+  const tasks = reading?.tasks;
+  if (task.loop) {
+    const check2 = { id: task.id, status: task.status, loop: task.loop, loopRound: task.loopRound, ...task.verdict ? { verdict: task.verdict } : {} };
+    const state = loopCheckState(check2, reading ? reading.blocks.repeating.has(task.id) : true);
+    const body = refsOf(task.loop.body, tasks);
+    const halted = reading ? task.loop.body.filter((id) => {
+      const status = reading.tasks.find((t) => t.id === id)?.status;
+      return status === "failed" || status === "skipped" || reading.blocks.blocked.has(id);
+    }) : [];
+    const detail = state === "repeating" ? `Found problems: runs again once ${body.join(", ")} ${body.length === 1 ? "has" : "have"} landed` : state === "stopped" ? `${refsOf(halted, tasks).join(", ")} did not pass: retry ${halted.length === 1 ? "it" : "them"} and the loop goes on` : null;
+    return { role: "check", state, label: loopCheckLabel(check2, state), detail, body };
+  }
+  const owner = reading && checkOf(reading.tasks, task.id);
+  if (!owner?.loop) return null;
+  const [check] = refsOf([owner.id], tasks);
+  const round = loopBodyRound({ status: owner.status ?? "", loopRound: owner.loopRound }, task.status);
+  return { role: "body", label: loopBodyLabel(check, round, owner.loop.maxRounds), check, round };
+}
+function handoffOf(task) {
+  if (!task.handoff) return null;
+  const patch = savedPatchView(task.handoff);
+  return {
+    ...task.handoff.commit ? { commit: task.handoff.commit } : {},
+    summary: task.handoff.summary,
+    findingCount: task.handoff.findingCount,
+    severity: worstSeverity(task.handoff.findings),
+    ...patch ? { patch } : {}
+  };
 }
 function flagOf(task, scope) {
   const issue = scope && task.assignedRunner !== void 0 ? assignmentIssue({ ...task, assignedRunner: task.assignedRunner }, scope) : null;
@@ -2117,17 +2948,26 @@ function taskRowView(task, context = {}) {
   const isolation = task.isolation && task.isolation.state !== "none" ? task.isolation : null;
   const spend = taskUsageSummary(task);
   const latestAttempt = task.attemptUsage?.at(-1);
-  const blocked = blockedBy(task, context.tasks);
+  const tasks = task.loop ? context.tasks?.map((t) => t.id === task.id ? { ...t, status: task.status, loopRound: task.loopRound, verdict: task.verdict } : t) : context.tasks;
+  const reading = tasks?.length ? { tasks, blocks: planBlocks(asBlocking(tasks)) } : null;
+  const blocked = blockedBy(task, reading);
+  const loop = loopOf(task, reading);
   return {
     usage: latestAttempt ? { totals: spend.totals, ...spend.contextFill ? { contextFill: spend.contextFill } : {}, attempt: latestAttempt.attempt } : task.type === "ai" && ["completed", "failed", "in_progress", "awaiting_user"].includes(task.status) ? { totals: {}, attempt: 0 } : null,
     orderLabel: taskOrderLabel(task, parent),
-    kind: task.type === "user" ? "user" : task.ops ? "ops" : "ai",
-    status: blocked.length > 0 ? "blocked" : taskStatusKind(task),
+    kind: task.type === "user" ? "user" : task.type === "script" ? "script" : task.ops ? "ops" : "ai",
+    // Between rounds a check waits for its fix as a task waits for its dependencies, and is no failure (ADR-0045 L3).
+    status: blocked.length > 0 ? "blocked" : loop?.role === "check" && loop.state === "repeating" ? "todo" : taskStatusKind(task),
     running: isTaskRunning(task),
+    chatAvailable: taskChatAvailable(task),
     awaiting: awaitingLabel(task),
     resumes: resumeLabel(task, context.now),
     approvals: approvalLabel(task.awaitingApproval),
+    receipt: receiptLabel(task),
     waitsForApproval: task.waitsForApproval && NOT_STARTED.has(task.status) ? WAITS_FOR_APPROVAL_LABEL : null,
+    holdReason: task.holdReason?.trim() || null,
+    research: task.type === "ai" && task.research === true,
+    runner: assignedRunnerOf(task) ?? null,
     ...flagOf(task, context.runnerScope),
     autonomous: task.type === "ai" && context.modes?.find((m) => m.id === task.taskMode)?.autonomous === true,
     repos: namedRepos(isolation?.repos),
@@ -2139,6 +2979,8 @@ function taskRowView(task, context = {}) {
     skipReason: task.status === "skipped" ? task.skipReason ?? null : null,
     opsChangedFiles: task.status === "awaiting_user" && task.awaitingReason === "files-changed",
     forcedPastGate: task.forcedPastGate?.length ? task.forcedPastGate : null,
+    loop,
+    handoff: handoffOf(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")),
@@ -2146,6 +2988,91 @@ function taskRowView(task, context = {}) {
     opsEditable: opsEditable(task)
   };
 }
+function loopRowParts(loop) {
+  if (loop.role === "body") return [loop.label];
+  const runs = loop.state === "waiting" || loop.state === "running" ? `Runs ${loop.body.join(", ")} if it fails` : null;
+  return [loop.label, loop.detail ?? runs].filter((part) => part !== null);
+}
+
+// src/taskRow/logHeader.ts
+var STATE_LABEL = {
+  done: "Done",
+  failed: "Failed",
+  running: "Running",
+  quiet: "Stalled",
+  awaiting: "Waiting for your input",
+  blocked: "Blocked",
+  skipped: "Skipped",
+  todo: "To do"
+};
+function stateOf(task, follow, approvals) {
+  if (task.status === "completed") return { kind: "done", label: STATE_LABEL.done };
+  if (task.status === "failed") return { kind: "failed", label: STATE_LABEL.failed };
+  if (task.status === "skipped") return { kind: "skipped", label: skippedLabel(task.skipReason ?? null) };
+  const approval = approvalLabel(approvals);
+  if (approval) return { kind: "approval", label: approval };
+  if (follow.view.working) return { kind: "running", label: "Working" };
+  if (task.status === "awaiting_user") {
+    return { kind: task.awaitingReason === "checkpoint" ? "checkpoint" : "awaiting", label: awaitingLabel(task) ?? STATE_LABEL.awaiting };
+  }
+  if (task.status === "blocked") return { kind: "blocked", label: STATE_LABEL.blocked };
+  if (follow.view.lastTurnEnd === "failed") return { kind: "failed", label: "Turn failed" };
+  if (follow.view.lastTurnEnd === "interrupted") return { kind: "todo", label: "Interrupted" };
+  const kind = taskStatusKind(task);
+  return { kind, label: STATE_LABEL[kind] };
+}
+function loggedUsage(view) {
+  const last = view.blocks.at(-1);
+  if (last?.type !== "usage") return null;
+  const text2 = usageText(last);
+  return text2 ? { text: text2, ...last.contextFill ? { contextFill: last.contextFill } : {} } : null;
+}
+function usageRow(text2, contextFill) {
+  return text2 ? { text: text2, ...contextFill ? { contextFill } : {} } : null;
+}
+function usageOf(task, follow, attempt) {
+  const attempts = task.attemptUsage ?? [];
+  const latest = attempts.at(-1);
+  const past = attempt > 0 && attempt !== latest?.attempt;
+  const total = taskUsageSummary(task);
+  const totalText = usageText(total);
+  if (!past) {
+    if (attempts.length > 0) return totalText ? [{ text: totalText, ...total.contextFill ? { contextFill: total.contextFill } : {} }] : [];
+    const logged = loggedUsage(follow.view);
+    return logged ? [logged] : [];
+  }
+  const onScreen = attempts.find((a) => a.attempt === attempt);
+  const own = onScreen ? usageRow(usageText({ totals: onScreen.totals, contextFill: plannerContextFill(onScreen) }), plannerContextFill(onScreen)) : loggedUsage(follow.view);
+  const rows = [];
+  if (own) rows.push(onScreen ? { ...own, text: `attempt ${onScreen.attempt}: ${own.text}` } : own);
+  if (totalText) rows.push({ text: `task total: ${totalText}`, ...total.contextFill ? { contextFill: total.contextFill } : {} });
+  return rows;
+}
+function taskLogCommands(view) {
+  for (let i = view.blocks.length - 1; i >= 0; i--) {
+    const block = view.blocks[i];
+    if (block.type === "runner_loaded") return block.commands;
+  }
+  return [];
+}
+function logContinues(task) {
+  const finished = task.status === "completed" || task.status === "failed" || task.status === "skipped";
+  return task.continuable === true && (finished || task.status === "awaiting_user" && task.awaitingReason === "usage-limit");
+}
+function logResumes(task) {
+  return task.continuable === true && task.status === "awaiting_user" && task.awaitingReason === "usage-limit";
+}
+function taskLogHeaderView(task, follow, approvals, attempt) {
+  return {
+    state: stateOf(task, follow, approvals),
+    resumes: resumeLabel(task),
+    continuable: logContinues(task),
+    resumable: logResumes(task),
+    working: follow.view.working,
+    usage: usageOf(task, follow, attempt),
+    commands: taskLogCommands(follow.view)
+  };
+}
 
 // src/taskRow/texts.ts
 function titledRefs(ids, tasks) {
@@ -2156,17 +3083,82 @@ function dependentsNotice(dependents, tasks = []) {
   const subject = dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`;
   return `${subject} on it and will lose that dependency: ${dependents.map((t) => (t.id ? titledTaskRefOf(tasks, t.id) : void 0) ?? titledTaskRef(t)).join(", ")}.`;
 }
+function loopLeaveNotice(tasks, taskId) {
+  const check = checkOf(tasks, taskId);
+  if (!check?.loop) return null;
+  const [named] = titledRefs([check.id], tasks);
+  return check.loop.body.length > 1 ? `It is in the body of ${named}'s loop, and leaves it.` : `It is the whole body of ${named}'s loop, so the loop is dropped with it.`;
+}
 function pastGateConfirmation(unmerged, subject = "This task") {
   return `${subject} waits for Merge all: the work of ${unmerged.join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task.`;
 }
+function manualOverrideConfirmation(direction, label) {
+  return direction === "complete" ? `Mark ${label} complete? You vouch for its work although no passing verdict said it was done. Any changes it kept may land in your run, and the tasks that depend on it are released to start on a future run.` : `Mark ${label} not done? This clears its completion and holds it until you retry or start it. The work it did stays where it is, and tasks that already ran on its result are not undone.`;
+}
+function manualOverrideStopFirst(direction, label) {
+  return `${label.charAt(0).toUpperCase()}${label.slice(1)} cannot be marked ${direction === "complete" ? "complete" : "not done"} while the plan is starting, running or waiting to resume, because the run could still move it on. Stop the run first, and mark it once everything has stopped.`;
+}
 function newTaskFields(title, prompt) {
   const name = title.trim();
   if (!name) return null;
   return { title: name, description: name, prompt: prompt?.trim() ? prompt : name, type: "ai" };
 }
+function noExecutorRefusal(type, manual, script) {
+  return type === "script" ? `A script task runs no model, so ${script}` : `Manual tasks do not run an executor, so ${manual}`;
+}
 
 // src/services/runView.ts
-var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
+var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null, activity: IDLE_ACTIVITY };
+
+// src/models/AccountLimits.ts
+function hasAccountLimits(snapshot) {
+  return (snapshot.status === "fresh" || snapshot.status === "stale") && snapshot.buckets.some((bucket) => bucket.windows.some((window) => window.usedPercent !== null));
+}
+function accountLimitsOf(snapshots, runner, model) {
+  if (!runner) return [];
+  return snapshots.filter((snapshot) => snapshot.harness === runner && (snapshot.provider === void 0 || (model?.startsWith(`${snapshot.provider}/`) ?? false)));
+}
+var WEEK = 7 * 24 * 60;
+var DAY = 24 * 60;
+var SLOT_LABELS = { primary: "Primary", secondary: "Secondary", tertiary: "Tertiary" };
+function accountLimitWindowLabel(window) {
+  if (window.period === "month") return "Monthly";
+  const minutes = window.durationMinutes;
+  if (minutes === null) return SLOT_LABELS[window.slot];
+  if (minutes === WEEK) return "Weekly";
+  if (minutes === DAY) return "Daily";
+  if (minutes % WEEK === 0) return `${minutes / WEEK}w`;
+  if (minutes % DAY === 0) return `${minutes / DAY}d`;
+  if (minutes % 60 === 0) return `${minutes / 60}h`;
+  return `${minutes}m`;
+}
+function accountLimitPercentText(percent) {
+  const shown = percent > 0 && percent < 1 ? "<1" : String(Math.round(percent));
+  return `${shown}% used`;
+}
+function accountLimitsText(snapshot) {
+  if (!hasAccountLimits(snapshot)) return null;
+  const parts = snapshot.buckets.flatMap((bucket, index) => {
+    const windows = bucket.windows.flatMap((window) => window.usedPercent === null ? [] : [`${accountLimitWindowLabel(window)} ${accountLimitPercentText(window.usedPercent)}`]);
+    if (windows.length === 0) return [];
+    return index === 0 ? windows : [`${bucket.name ?? bucket.id} ${windows.join(" \xB7 ")}`];
+  });
+  return `${snapshot.label} ${parts.join(" \xB7 ")}${snapshot.status === "stale" ? " (stale)" : ""}`;
+}
+function accountLimitsTitle(snapshot, time) {
+  const lines2 = snapshot.buckets.flatMap((bucket, index) => bucket.windows.map((window) => {
+    const owner = index === 0 ? snapshot.label : `${snapshot.label} ${bucket.name ?? bucket.id}`;
+    const share = window.usedPercent === null ? "not reported" : `${window.usedPercent}% used`;
+    const reset = window.resetsAt ? `, resets ${time(new Date(window.resetsAt))}` : "";
+    return `${owner} ${accountLimitWindowLabel(window)}: ${share}${reset}`;
+  }));
+  if (snapshot.plan) lines2.push(`Plan: ${snapshot.plan}`);
+  if (snapshot.readAt) {
+    const read = time(new Date(snapshot.readAt));
+    lines2.push(snapshot.status === "stale" ? `Last read ${read}; not current, a newer read is pending or failed` : `Read ${read}`);
+  }
+  return lines2.join("\n");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHECKPOINT_TRUNCATE_LENGTH,
@@ -2176,27 +3168,47 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   EMPTY_RUN,
   EMPTY_TASK_LOG,
   EMPTY_TASK_LOG_FOLLOW,
+  IDLE_ACTIVITY,
   NOT_STARTED,
   NO_TURN,
+  PLANNED_WITH_LABEL,
+  REPORT_PREVIEW_LINES,
+  SEVERITY_LABEL,
   SUPERVISOR_LEVEL_LABEL,
   WAITS_FOR_APPROVAL_LABEL,
+  accountLimitPercentText,
+  accountLimitWindowLabel,
+  accountLimitsOf,
+  accountLimitsText,
+  accountLimitsTitle,
   addAttemptUsage,
   addModelUsage,
   addPlannerUsage,
   addUsage,
   addUsageTotals,
   aheadOfDraft,
+  approvalKindText,
   approvalLabel,
+  approvalStatusText,
+  assignedRunnerOf,
   assignmentIssue,
   assignmentIssueText,
   awaitingLabel,
+  betweenRounds,
+  blockNotice,
+  blockNotices,
   blockedByLabel,
   blockingFailures,
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
   capConflictFiles,
+  cardEditNeedsUnstarted,
+  cardEditable,
+  checkOf,
   clampThinkingEffort,
+  compactionText,
+  confirmedOverride,
   contextMeterText,
   contextMeterTitle,
   costText,
@@ -2204,47 +3216,89 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   dependencyCandidates,
   dependentsNotice,
   dependentsOf,
+  describeIsolationPreview,
+  describeMergeResult,
   diffRows,
   diffStat,
   diffSummary,
   drainNext,
+  editableWhileRunning,
   endAttemptUsage,
   followTaskLog,
   followTurn,
   formatCost,
   formatTokenCount,
   fromTranscript,
+  handoffBaseLine,
+  handoffBranchName,
+  handoffFindingsText,
+  handoffPeekParts,
+  handoffReferenceText,
+  hasAccountLimits,
   hasHiddenDetail,
+  hasLongReport,
+  holdLabel,
   holdPrompt,
+  isFileEditTool,
   isMeasured,
+  isRepoGroup,
   isTaskRunning,
   loadedSkillTokens,
+  logContinues,
+  logResumes,
+  loopBodyLabel,
+  loopBodyRound,
+  loopCheckLabel,
+  loopCheckState,
+  loopLeaveNotice,
+  loopRemovalRefusal,
+  loopRoundOf,
+  loopRowParts,
+  manualOverrideConfirmation,
+  manualOverrideStopFirst,
   markAction,
-  markRequestFor,
   markdownHtml,
   markdownTokens,
+  mergeOutcome,
   modelCostTitle,
   namedRepos,
   newTaskFields,
+  noExecutorRefusal,
   opsEditable,
+  outOfRounds,
   outputLines,
   outputPreview,
+  overrideNeedsConfirmation,
   parseCount,
   partedPromptUsage,
   pastGateConfirmation,
+  patchView,
   pausedOnLimit,
+  planBlocks,
+  planMarkerParts,
   planUsage,
   plannerContextFill,
+  receiptLabel,
   reconcileApprovals,
   reduceConversation,
   reduceTaskLog,
+  repairedLanded,
+  repairedNotice,
+  repeatingChecks,
   replayTaskLog,
+  repoBaseLine,
+  repoResultLines,
   resolveTaskRef,
   resolveUserTaskRef,
   resumeLabel,
   resumeTime,
   resumedSessionWindow,
+  runHoldsEditors,
   runnerToolSubject,
+  savedPatchView,
+  savedPatchViews,
+  scriptTaskText,
+  severityLabel,
   skillTokens,
   skippedLabel,
   startAttemptUsage,
@@ -2253,6 +3307,10 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   subtreeIds,
   summarizeToolCall,
   takeAt,
+  taskActionCommand,
+  taskChatAvailable,
+  taskLogCommands,
+  taskLogHeaderView,
   taskOrderLabel,
   taskPlacement,
   taskRef,
@@ -2272,6 +3330,8 @@ var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
   unsendLatest,
   usageLine,
   usageText,
-  walkPlan
+  wakeUpItems,
+  walkPlan,
+  worstSeverity
 });
 //# sourceMappingURL=plan-utils.js.map