@ordewell/core 0.10.12 → 0.11.0

package/dist/{chunk-ESKK5I4F.mjs → chunk-4QXOWEGC.mjs}

@@ -3,25 +3,39 @@ import {
   MODE_NOT_THE_PLANNERS,
   OPS_NOT_READ_ONLY,
   PlanParseError,
+  SCRIPT_BODY_FIELDS,
   TASK_OPS_ENVELOPE_KEY,
+  betweenRounds,
+  checkOf,
   checkPlanInvariants,
+  clearedBodyFields,
+  commandLine,
   detectCycle,
   effectiveAllowlist,
   escapeControlCharsInStrings,
   extractObjectsWithKey,
+  loopRemovalRefusal,
+  loopReshapeRefusal,
+  loopRoundOf,
+  loopSpec,
+  notAScriptsFields,
+  notOnAScriptMessage,
   opsPlacementRefusal,
+  outOfRounds,
   plannedTask,
   resolveAssignment,
   stripTrailingCommas,
   taggedReadOnlyMode,
   taskWhere
-} from "./chunk-24EL4Z2W.mjs";
+} from "./chunk-YAFNYNFX.mjs";
 import {
+  SELF_REPO,
   addTaskToPlan,
   canSetDependencies,
   flattenTasks,
   flattenTasksWithParents,
   inheritedOps,
+  isUserMessage,
   opsFlag,
   pausedOnLimit,
   rejoinPlanTree,
@@ -35,8 +49,9 @@ import {
   titledTaskRef,
   titledTaskRefOf,
   updateTaskInPlan,
+  waitsMidAttempt,
   walkPlan
-} from "./chunk-PFH7WFIB.mjs";
+} from "./chunk-QTZ5XTBY.mjs";
 
 // src/models/Usage.ts
 function partedPromptUsage(parts) {
@@ -215,13 +230,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();
@@ -268,6 +287,611 @@ function tasksTotalText(tasks) {
   return parts.length > 0 ? `Tasks total: ${parts.join(" \xB7 ")}` : null;
 }
 
+// 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");
+}
+
+// src/models/TaskLog.ts
+var HEAD_LINES = 60;
+var TAIL_LINES = 40;
+var MAX_LINE_CHARS = 2e3;
+var DIGEST_ARGS_CHARS = 120;
+var DIGEST_MESSAGE_CHARS = 1e3;
+function capLine(line) {
+  return line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS)}\u2026` : line;
+}
+function trimToolOutput(output) {
+  const lines2 = output.split("\n");
+  const long = lines2.some((l) => l.length > MAX_LINE_CHARS);
+  if (lines2.length <= HEAD_LINES + TAIL_LINES) return long ? { output: lines2.map(capLine).join("\n") } : { output };
+  const omittedLines = lines2.length - HEAD_LINES - TAIL_LINES;
+  const kept = [
+    ...lines2.slice(0, HEAD_LINES),
+    `\u2026 ${omittedLines} line${omittedLines === 1 ? "" : "s"} omitted \u2026`,
+    ...lines2.slice(-TAIL_LINES)
+  ];
+  return { output: kept.map(capLine).join("\n"), omittedLines };
+}
+function sender({ from }) {
+  return from ? { from } : {};
+}
+function withSubagent(event, subagentId) {
+  return subagentId ? { ...event, subagentId } : event;
+}
+function toTaskLogEvent(event) {
+  switch (event.type) {
+    case "turn_start":
+      if (event.command) {
+        return { type: "command", name: event.command.name, ...event.command.args ? { args: event.command.args } : {}, ...event.messageId ? { messageId: event.messageId } : {} };
+      }
+      return {
+        type: "turn_start",
+        message: event.text,
+        ...event.messageId ? { messageId: event.messageId } : {},
+        ...event.forced ? { forced: true } : {},
+        ...sender(event)
+      };
+    case "turn_end":
+      return { type: "turn_end", reason: event.reason };
+    case "assistant_text_delta":
+      return { type: "text_delta", runId: event.runId, text: event.text };
+    case "assistant_text":
+      return { type: "text", runId: event.runId, text: event.text };
+    case "thinking_delta":
+    case "thinking":
+      return withSubagent({ type: event.type, text: event.text }, event.subagentId);
+    case "tool_call":
+      return withSubagent({ type: "tool_call", id: event.id, name: event.name, args: JSON.stringify(event.args) }, event.subagentId);
+    case "tool_result": {
+      const { output, omittedLines } = trimToolOutput(event.output);
+      return withSubagent({ type: "tool_result", id: event.id, output, success: event.success, ...omittedLines ? { omittedLines } : {} }, event.subagentId);
+    }
+    case "subagent_started":
+      return { type: "subagent_started", subagentId: event.subagentId, brief: event.brief, ...event.model ? { model: event.model } : {} };
+    case "subagent_finished":
+      return { type: "subagent_finished", subagentId: event.subagentId, outcome: event.outcome, digest: event.digest };
+    case "usage":
+      return { type: "usage", record: event.record };
+    case "message_queued":
+      return { type: "message_queued", messageId: event.messageId, text: event.text, ...event.forced ? { forced: true } : {}, ...sender(event) };
+    case "message_undelivered":
+      return { type: "message_undelivered", messageId: event.messageId, text: event.text, ...sender(event) };
+    case "message_removed":
+      return { type: "message_removed", messageId: event.messageId };
+    case "message_handed_over":
+      return { type: "message_handed_over", messageId: event.messageId };
+    case "message_delivered":
+      return { type: "message_delivered", messageId: event.messageId, text: event.text, ...sender(event) };
+    case "error":
+      return { type: "error", message: event.message };
+    case "permission_request":
+      return {
+        type: "approval_requested",
+        approvalId: event.id,
+        tool: event.name,
+        args: event.detail,
+        allowForTask: (event.suggestions?.length ?? 0) > 0,
+        ...event.decided ? { decided: event.decided.decision } : {},
+        ...event.toolUseId ? { toolCallId: event.toolUseId } : {}
+      };
+    case "permission_decided": {
+      const note = event.decision.decision === "deny" ? event.decision.note : void 0;
+      return { type: "approval_decided", approvalId: event.id, decision: event.decision.decision, ...note ? { note } : {} };
+    }
+    case "permission_withdrawn":
+      return { type: "approval_withdrawn", approvalId: event.id };
+    case "runner_loaded":
+      return { type: "runner_loaded", commands: event.commands, mcpServers: event.mcpServers };
+    case "compaction":
+      return {
+        type: "compaction",
+        trigger: event.trigger,
+        ...event.preTokens !== void 0 ? { preTokens: event.preTokens } : {},
+        ...event.postTokens !== void 0 ? { postTokens: event.postTokens } : {}
+      };
+    case "command_output":
+      return { type: "command_output", text: event.text };
+    case "script_run":
+      return "argv" in event ? { type: "script_run", argv: [...event.argv] } : { type: "script_run", script: event.script };
+    case "script_output":
+      return { type: "script_output", text: event.text, ...event.omittedChars ? { omittedChars: event.omittedChars } : {} };
+    case "script_exit":
+      return {
+        type: "script_exit",
+        code: event.code,
+        signal: event.signal,
+        durationMs: event.durationMs,
+        ...event.timedOut ? { timedOut: true } : {},
+        ...event.error !== void 0 ? { error: event.error } : {}
+      };
+    // The call is in the log already; its receipt is the task's state, not an entry.
+    case "completion_received":
+      return null;
+    // Logged once the plan's write-back settles: see `TaskLogRecorder.note`.
+    case "model_switched":
+    case "model_drifted":
+    case "background_agent":
+      return null;
+  }
+}
+function lastServedModel(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "usage" && event.record.model && !event.record.subagentId && !event.record.aggregate) return event.record.model;
+  }
+  return void 0;
+}
+function taskLogForSurface(events) {
+  return events.map((event) => event.type === "task_skills" ? { type: "task_skills", skills: event.skills.map(({ name, source, path }) => ({ name, source, path })) } : event);
+}
+function coalesceTaskLog(events) {
+  const out = [];
+  for (const event of events) {
+    const last = out[out.length - 1];
+    if (last?.type === "text_delta" && event.type === "text_delta" && last.runId === event.runId) {
+      out[out.length - 1] = { ...last, text: last.text + event.text };
+    } else if (last?.type === "thinking_delta" && event.type === "thinking_delta" && last.subagentId === event.subagentId) {
+      out[out.length - 1] = { ...last, text: last.text + event.text };
+    } else if (last?.type === "script_output" && event.type === "script_output" && !last.omittedChars && !event.omittedChars) {
+      out[out.length - 1] = { ...last, text: last.text + event.text };
+    } else {
+      out.push(event);
+    }
+  }
+  return out;
+}
+function scriptRunText(run) {
+  if ("argv" in run) return commandLine(run.argv);
+  const lines2 = run.script.trim().split("\n");
+  return lines2.length > 1 ? `${lines2[0]} \u2026 (${lines2.length} lines)` : lines2[0];
+}
+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" : ""}`;
+}
+function digestTaskLog(events, maxCalls) {
+  const outcomes = /* @__PURE__ */ new Map();
+  let lastText;
+  let lastError;
+  for (const event of events) {
+    if (event.type === "tool_result") outcomes.set(event.id, event.success);
+    else if (event.type === "text") lastText = event.text;
+    else if (event.type === "error") lastError = event.message;
+  }
+  const lines2 = [];
+  let step;
+  for (const event of events) {
+    if (event.type === "script_run") {
+      if (step !== void 0) lines2.push(`- ${step} \u2192 no result`);
+      step = scriptRunText(event);
+      continue;
+    }
+    if (event.type === "script_exit" && step !== void 0) {
+      lines2.push(`- ${step} \u2192 ${scriptExitText(event)}`);
+      step = void 0;
+      continue;
+    }
+    if (event.type !== "tool_call") continue;
+    const outcome = outcomes.get(event.id);
+    const args = event.args.length > DIGEST_ARGS_CHARS ? `${event.args.slice(0, DIGEST_ARGS_CHARS)}\u2026` : event.args;
+    lines2.push(`- ${event.name} ${args} \u2192 ${outcome === void 0 ? "no result" : outcome ? "ok" : "failed"}`);
+  }
+  if (step !== void 0) lines2.push(`- ${step} \u2192 no result`);
+  const omitted = lines2.length - maxCalls;
+  const out = omitted > 0 ? [`\u2026 ${omitted} earlier call${omitted === 1 ? "" : "s"} omitted \u2026`, ...lines2.slice(omitted)] : lines2;
+  const gap = () => out.length > 0 ? [""] : [];
+  const said = lastText?.trim();
+  if (said) {
+    const end = said.length > DIGEST_MESSAGE_CHARS ? `\u2026${said.slice(-DIGEST_MESSAGE_CHARS)}` : said;
+    out.push(...gap(), "Its last message:", ...end.split("\n").map((l) => `  ${l}`));
+  }
+  if (lastError) out.push(...gap(), `It stopped with an error: ${lastError}`);
+  return out.join("\n");
+}
+
+// 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;
+}
+var REPORT_MAX_CHARS = 2e4;
+var HANDOFF_LIMITS = {
+  summary: 1500,
+  commitSubject: 100,
+  commitBody: 500,
+  findings: 50,
+  title: 200,
+  detail: 2e3,
+  reference: 2e3,
+  evidence: 10,
+  artifacts: 20,
+  report: REPORT_MAX_CHARS
+};
+var DIGEST_FINDINGS = 25;
+function storedHandoff(handoff) {
+  const summary = handoff.summary.trim();
+  const findings = (handoff.findings ?? []).map((f, i) => ({ id: `F${i + 1}`, ...f }));
+  const artifacts = handoff.artifacts ?? [];
+  const report = handoff.report?.trim();
+  const commit = handoff.status === "done" && handoff.commit ? withoutTrailers(handoff.commit) : void 0;
+  if (!commit && !summary && findings.length === 0 && artifacts.length === 0 && !report) return void 0;
+  return {
+    ...commit ? { commit } : {},
+    summary,
+    findings,
+    findingCount: findings.length,
+    ...artifacts.length > 0 ? { artifacts } : {},
+    ...report ? { report } : {}
+  };
+}
+function withPatch(handoff, patch) {
+  if (!handoff) return { summary: "", findings: [], findingCount: 0, artifacts: [patch] };
+  return { ...handoff, artifacts: [...handoff.artifacts ?? [], patch] };
+}
+function savedPatchOf(handoff) {
+  return handoff?.artifacts?.find((a) => a.kind === "patch");
+}
+var ATTRIBUTION_TRAILER = /^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)+:\s*\S/;
+var GENERATED_WITH = /^\W*Generated (?:with|by)\b/i;
+var TRAILER = /^[A-Za-z0-9-]+:\s*\S/;
+function withoutTrailers({ subject, body }) {
+  const kept = (body ?? "").split("\n").filter((line) => !ATTRIBUTION_TRAILER.test(line.trim()) && !GENERATED_WITH.test(line.trim()));
+  const paragraphs = kept.join("\n").trim().split(/\n\s*\n/);
+  const last = paragraphs.at(-1).split("\n");
+  if (paragraphs.length > 1 && last.every((line) => TRAILER.test(line.trim()))) paragraphs.pop();
+  const cleaned = paragraphs.join("\n\n").trim();
+  return { subject, ...cleaned ? { body: cleaned } : {} };
+}
+function handoffDigest(handoff) {
+  return {
+    ...handoff.commit ? { commit: handoff.commit } : {},
+    summary: handoff.summary,
+    findings: handoff.findings.slice(0, DIGEST_FINDINGS),
+    findingCount: handoff.findingCount,
+    ...handoff.artifacts ? { artifacts: handoff.artifacts } : {}
+  };
+}
+function namedHandoff(plan, handoff) {
+  const named = (refs) => refs.map((r) => r.kind === "task" ? { ...r, task: taskRefOf(plan, r.task) ?? r.task } : r);
+  return {
+    ...handoff,
+    findings: handoff.findings.map((f) => f.evidence ? { ...f, evidence: named(f.evidence) } : f),
+    ...handoff.artifacts ? { artifacts: named(handoff.artifacts) } : {}
+  };
+}
+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 patchLines(patch) {
+  const view = patchView(patch);
+  return [`Patch: ${view.changes}, ${view.base}`, view.saved, ...view.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;
+}
+function findingLines(f, taskName = () => void 0) {
+  return [
+    `- ${f.id} [${f.severity}] ${f.title}`,
+    ...f.detail ? f.detail.split("\n").map((l) => `  ${l}`) : [],
+    ...f.evidence?.length ? [`  Evidence: ${f.evidence.map((e) => handoffReferenceText(e, taskName)).join("; ")}`] : []
+  ];
+}
+function artifactLines(handoff, taskName = () => void 0) {
+  return handoff.artifacts?.length ? [`Artifacts: ${handoff.artifacts.map((a) => handoffReferenceText(a, taskName)).join("; ")}`] : [];
+}
+function openingLines(handoff) {
+  const { commit, summary } = handoff;
+  if (!commit) return [summary];
+  return [`Commit: ${commit.subject}`, ...commit.body ? commit.body.split("\n") : [], ...summary ? ["", summary] : []];
+}
+var HANDOFF_PUSH_CHARS = 4e3;
+function boundedHandoffLines(handoff, omission, taskName = () => void 0, footer = "") {
+  const lines2 = openingLines(handoff);
+  let shown = 0;
+  const closing = (count) => [
+    ...handoff.findingCount > count ? [omission(handoff.findingCount - count)] : [],
+    ...footer ? ["", footer] : []
+  ];
+  for (const finding of handoff.findings) {
+    const next = [...shown === 0 ? ["", "Findings:"] : [], ...findingLines(finding, taskName)];
+    if ([...lines2, ...next, ...closing(shown + 1)].join("\n").length > HANDOFF_PUSH_CHARS) break;
+    lines2.push(...next);
+    shown++;
+  }
+  lines2.push(...closing(shown));
+  const artifacts = artifactLines(handoff, taskName);
+  if (artifacts.length) lines2.push("", ...artifacts);
+  return lines2;
+}
+function handoffPreviewLines(handoff, options = {}) {
+  const limit = Math.max(0, options.maxFindings ?? handoff.findings.length);
+  const shown = handoff.findings.slice(0, limit);
+  const more = handoff.findingCount - shown.length;
+  const summary = handoff.summary.trim();
+  const { commit } = handoff;
+  const patches = (handoff.artifacts ?? []).filter((a) => a.kind === "patch");
+  const others = (handoff.artifacts ?? []).filter((a) => a.kind !== "patch");
+  const artifacts = others.length ? artifactLines({ ...handoff, artifacts: others }, options.taskName) : [];
+  return [
+    ...commit ? [`Commit: ${commit.subject}`, ...commit.body ? commit.body.split("\n") : []] : [],
+    ...summary ? summary.split("\n") : [],
+    ...shown.map((f) => `${f.id} [${f.severity}] ${f.title}`),
+    ...more > 0 ? [`+${more} more finding${more === 1 ? "" : "s"}, in the attempt's log`] : [],
+    ...artifacts,
+    ...patches.flatMap(patchLines)
+  ];
+}
+function handoffWakeLines(handoff, taskName = () => void 0) {
+  return boundedHandoffLines(
+    handoff,
+    (more) => `+${more} more finding${more === 1 ? "" : "s"}; read with task_output.`,
+    taskName,
+    "The report, if the task wrote one, is in the attempt's log: read it with task_output."
+  );
+}
+function handoffLines(handoff, taskName = () => void 0) {
+  const lines2 = openingLines(handoff);
+  if (handoff.findings.length > 0) lines2.push("", "Findings:", ...handoff.findings.flatMap((f) => findingLines(f, taskName)));
+  const more = handoff.findingCount - handoff.findings.length;
+  if (more > 0) lines2.push(`+${more} more finding${more === 1 ? "" : "s"}, in the attempt's log`);
+  const artifacts = artifactLines(handoff, taskName);
+  if (artifacts.length > 0) lines2.push("", ...artifacts);
+  if ("report" in handoff && handoff.report) lines2.push("", "Report:", handoff.report);
+  return lines2;
+}
+function readableTaskIds(plan, taskId) {
+  const tasks = flattenTasks(plan);
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const readable = /* @__PURE__ */ new Set([taskId]);
+  const pending = [...byId.get(taskId)?.dependencies ?? []];
+  for (let id = pending.pop(); id !== void 0; id = pending.pop()) {
+    if (readable.has(id)) continue;
+    readable.add(id);
+    pending.push(...byId.get(id)?.dependencies ?? []);
+  }
+  for (const id of byId.get(taskId)?.loop?.body ?? []) readable.add(id);
+  const check = checkOf(tasks, taskId);
+  if (check) readable.add(check.id);
+  return readable;
+}
+var RESEND = "Fix or drop each reference named, then call task_complete again; nothing was recorded.";
+function checkHandoff(handoff, producerId, plan) {
+  const readable = readableTaskIds(plan, producerId);
+  const refusals = [];
+  const check = (ref, field) => {
+    if (ref.kind === "url") {
+      if (!isWebUrl(ref.url)) refusals.push(`${field}.url: ${JSON.stringify(ref.url)} is refused: only an http or https URL is accepted.`);
+      return ref;
+    }
+    if (ref.kind !== "task") return ref;
+    const target = resolveTaskRef(plan, ref.task);
+    if (!target) {
+      refusals.push(`${field}.task: ${JSON.stringify(ref.task)} names no task in the plan: give its "#order", its id or its title.`);
+      return ref;
+    }
+    const named = titledTaskRefOf(plan, target.id) ?? target.id;
+    if (!readable.has(target.id)) {
+      refusals.push(`${field}.task: ${JSON.stringify(ref.task)} is ${named}, which this task may not read: only itself, a task it depends on, or its loop's other end.`);
+      return ref;
+    }
+    if (ref.finding !== void 0) {
+      const count = target.handoff?.findingCount ?? 0;
+      if (Number(ref.finding.slice(1)) > count) {
+        refusals.push(`${field}.finding: ${JSON.stringify(ref.finding)} is not a finding of ${named}: ${count > 0 ? `its latest handoff has F1 to F${count}` : "its latest handoff has none"}.`);
+      }
+    }
+    return { ...ref, task: target.id };
+  };
+  const findings = handoff.findings?.map((f, i) => f.evidence ? { ...f, evidence: f.evidence.map((e, j) => check(e, `findings[${i}].evidence[${j}]`)) } : f);
+  const artifacts = handoff.artifacts?.map((a, i) => a.kind === "patch" ? a : check(a, `artifacts[${i}]`));
+  if (refusals.length > 0) return { ok: false, refusal: [...refusals, RESEND].join("\n") };
+  return { ok: true, handoff: { ...handoff, ...findings ? { findings } : {}, ...artifacts ? { artifacts } : {} } };
+}
+function isWebUrl(url) {
+  try {
+    const { protocol } = new URL(url);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+// src/services/researchStepSummary.ts
+function ellipsize(text2, max) {
+  const oneLine2 = text2.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max)}\u2026` : oneLine2;
+}
+function summarizeToolCall(tool, argsJson, toolLabel) {
+  const display = toolLabel?.trim() || tool;
+  if (tool === "agent_tool") {
+    try {
+      const args = JSON.parse(argsJson);
+      const hint = args.path ?? args.file_path ?? args.filePath ?? args.pattern ?? args.query ?? args.url ?? args.command;
+      if (hint) return `${display} ${ellipsize(String(hint), 50)}`;
+    } catch {
+    }
+    return display;
+  }
+  if (tool === "spawn_research_agent") {
+    try {
+      const args = JSON.parse(argsJson);
+      const prompt = typeof args.prompt === "string" ? args.prompt : "";
+      const oneLine2 = prompt.replace(/\s+/g, " ").trim();
+      return `spawn: "${oneLine2.slice(0, 60)}${oneLine2.length > 60 ? "\u2026" : ""}"`;
+    } catch {
+      return "spawn_research_agent";
+    }
+  }
+  try {
+    const args = JSON.parse(argsJson);
+    if (tool === "find_symbol" && args.symbol) {
+      return `find_symbol ${args.symbol}${args.language ? ` [${args.language}]` : ""}`;
+    }
+    if (tool === "web_search" && args.query) {
+      return `web_search "${ellipsize(String(args.query), 50)}"`;
+    }
+    if (tool === "fetch" && args.url) {
+      return `fetch ${ellipsize(String(args.url), 60)}`;
+    }
+    if (tool === "glob" && args.pattern) {
+      return `glob ${ellipsize(String(args.pattern), 50)}`;
+    }
+    if (tool === "grep" && args.pattern) {
+      const mode = args.output_mode && args.output_mode !== "content" ? ` (${args.output_mode})` : "";
+      const scope = args.include ? ` in ${args.include}` : "";
+      return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
+    }
+    const path = args.filePath || args.file_path || args.path;
+    if (path) {
+      const basename = String(path).split("/").pop() || String(path);
+      return `${display} ${basename}`;
+    }
+    if (args.pattern) {
+      return `${display} ${args.pattern}`;
+    }
+    if (args.command) {
+      return `bash: ${String(args.command).slice(0, 40)}`;
+    }
+  } catch {
+  }
+  return display;
+}
+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);
+}
+function classifyOutcome(success, output) {
+  if (!success) {
+    if (/^(Command|Fetch|Web search) refused:/.test(output) || /is not available\. You are a read-only research subagent/.test(output)) return "refused";
+    if (/not approved/i.test(output) || /^Access denied:/.test(output) || /needs user approval/i.test(output)) return "denied";
+    return "failure";
+  }
+  return "success";
+}
+
 // src/services/harness/agentTools.ts
 var KNOWN_TOOLS = {
   // Claude Code
@@ -275,6 +899,8 @@ var KNOWN_TOOLS = {
   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",
@@ -501,6 +1127,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 } : {} };
 }
@@ -513,7 +1153,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);
@@ -654,7 +1296,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 };
 }
 
@@ -864,17 +1510,17 @@ function endTurn(view, { reason }) {
 }
 function queueMessage(view, { messageId, text: text2, forced, from }) {
   const listed = view.queued.find((m) => m.id === messageId);
-  const sender = from ? { from } : {};
+  const sender2 = 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;
     const handedOver = listed?.handedOver ? { handedOver: true } : {};
-    return { ...view, queued: [...rest.slice(0, placed), { id: messageId, text: text2, forced: true, ...handedOver, ...sender }, ...rest.slice(placed)] };
+    return { ...view, queued: [...rest.slice(0, placed), { id: messageId, text: text2, forced: true, ...handedOver, ...sender2 }, ...rest.slice(placed)] };
   }
-  if (!listed) return { ...view, queued: [...view.queued, { id: messageId, text: text2, ...sender }] };
+  if (!listed) return { ...view, queued: [...view.queued, { id: messageId, text: text2, ...sender2 }] };
   if (!listed.handedOver) return view;
-  return { ...view, queued: view.queued.map((m) => m === listed ? { id: m.id, text: m.text, ...m.forced ? { forced: true } : {}, ...sender } : m) };
+  return { ...view, queued: view.queued.map((m) => m === listed ? { id: m.id, text: m.text, ...m.forced ? { forced: true } : {}, ...sender2 } : m) };
 }
 function handOver(view, { messageId }) {
   const listed = view.queued.find((m) => m.id === messageId);
@@ -888,6 +1534,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;
 }
@@ -960,6 +1643,14 @@ function reduceTaskLog(view, event) {
       return decideApproval(view, event);
     case "approval_withdrawn":
       return settleApproval(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:
@@ -1002,10 +1693,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";
@@ -1026,28 +1728,62 @@ import { v4 as uuidv4 } from "uuid";
 
 // src/services/TaskEditValidator.ts
 function lockedTaskRefusal(task, action = "changed") {
-  if (task.status === "in_progress") return `"${task.title}" is running and cannot be ${action} now: the user can stop it first, or change it after it finishes`;
+  if (task.status === "in_progress") return runningRefusal(task, action);
   if (task.status === "completed") return `"${task.title}" is completed and cannot be ${action}: rearm it to run it again, or add a new task for further work`;
   return null;
 }
+function reshapeRefusal(task, action) {
+  return waitsMidAttempt(task) ? runningRefusal(task, action) : lockedTaskRefusal(task, action);
+}
+function runningRefusal(task, action) {
+  return `"${task.title}" is running and cannot be ${action} now: the user can stop it first, or change it after it finishes`;
+}
+function startedEditRefusal(task) {
+  return `"${task.title}" started before this change was saved, so it was not changed: only a task that has not started can be edited while the plan runs`;
+}
 var AI_ONLY_FIELDS = ["assignedModel", "taskMode", "autonomy", "ops"];
+var NOT_KEPT_BY_A_SCRIPT = [...AI_ONLY_FIELDS, "prompt", "skills", "userSteps"];
 function typeCoherenceCheck(target, changes) {
   if (!changes.type || changes.type === target.type) return null;
+  if ((changes.type === "script" || target.type === "script") && !NOT_STARTED.has(target.status)) {
+    return { ok: false, error: `"${target.title}" has started, so whether it is a script task is fixed: add a new task instead` };
+  }
+  const body = target.type === "script" ? SCRIPT_BODY_FIELDS.filter((f) => target[f] !== void 0) : [];
   if (changes.type === "user") {
     if (!Array.isArray(changes.userSteps) || changes.userSteps.length === 0) {
       return { ok: false, error: `"${target.title}" cannot become a manual task without user steps: include "userSteps" in this edit` };
     }
     return {
       ok: true,
-      clear: AI_ONLY_FIELDS.filter((f) => target[f] !== void 0),
+      clear: [...AI_ONLY_FIELDS.filter((f) => target[f] !== void 0), ...body],
       // User tasks are held to HITL, so a flip that kept the AI task's slice would be refused by the plan's own rules.
       ...target.sliceType !== "HITL" ? { set: { sliceType: "HITL" } } : {}
     };
   }
+  if (changes.type === "script") {
+    if (changes.commands === void 0 && changes.script === void 0) {
+      return { ok: false, error: `"${target.title}" cannot become a script task without a body: include "commands" or "script" in this edit` };
+    }
+    return { ok: true, clear: NOT_KEPT_BY_A_SCRIPT.filter((f) => target[f] !== void 0) };
+  }
   if (!changes.prompt || !changes.prompt.trim()) {
     return { ok: false, error: `"${target.title}" cannot become an AI task without a prompt: include "prompt" in this edit` };
   }
-  return { ok: true, clear: target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [] };
+  return { ok: true, clear: [...target.userSteps && target.userSteps.length > 0 ? ["userSteps"] : [], ...body] };
+}
+function scriptCheck(target, changes) {
+  if ((changes.type ?? target.type) !== "script") {
+    const body = SCRIPT_BODY_FIELDS.filter((f) => changes[f] !== void 0);
+    if (body.length === 0) return null;
+    return { ok: false, error: `"${target.title}" is not a script task, so it has no ${body.map((f) => `"${f}"`).join(", ")}: set "type": "script" with it, or leave it out` };
+  }
+  const extra = [..."assignedRunner" in changes && changes.assignedRunner !== void 0 ? ["assignedRunner"] : [], ...notAScriptsFields(changes)];
+  if (extra.length > 0) return { ok: false, error: `"${target.title}" ${notOnAScriptMessage(extra)}` };
+  const replaced = [
+    ...changes.commands !== void 0 && !("script" in changes) && target.script !== void 0 ? ["script"] : [],
+    ...changes.script !== void 0 && !("commands" in changes) && target.commands !== void 0 ? ["commands"] : []
+  ];
+  return replaced.length > 0 ? { ok: true, clear: replaced } : null;
 }
 function opsCheck(target, isSubtask, changes) {
   if (!("ops" in changes) || !!changes.ops === !!target.ops) return null;
@@ -1055,8 +1791,8 @@ function opsCheck(target, isSubtask, changes) {
     return { ok: false, error: `"${target.title}" has started, so whether it is an ops task is fixed` };
   }
   if (!changes.ops) return null;
-  const refused = opsPlacementRefusal(changes.type ?? target.type, isSubtask);
-  return refused ? { ok: false, error: `"${target.title}" ${refused}` } : null;
+  const refused2 = opsPlacementRefusal(changes.type ?? target.type, isSubtask);
+  return refused2 ? { ok: false, error: `"${target.title}" ${refused2}` } : null;
 }
 function validateTaskEdit(actor, tasks, taskId, changes) {
   const found = flattenTasksWithParents(tasks).find(({ task }) => task.id === taskId);
@@ -1070,9 +1806,12 @@ function validateTaskEdit(actor, tasks, taskId, changes) {
   }
   const coherence = typeCoherenceCheck(target, changes);
   if (coherence && !coherence.ok) return coherence;
+  const script = scriptCheck(target, changes);
+  if (script && !script.ok) return script;
   const ops = opsCheck(target, parent !== null, changes);
   if (ops) return ops;
-  return coherence ?? { ok: true };
+  if (!script) return coherence ?? { ok: true };
+  return { ...coherence, ok: true, clear: [...coherence?.clear ?? [], ...script.clear ?? []] };
 }
 
 // src/services/TaskOps.ts
@@ -1089,7 +1828,12 @@ var UPDATABLE_FIELDS = [
   "autonomy",
   "sliceType",
   "ops",
-  "skills"
+  "skills",
+  "commands",
+  "script",
+  "timeoutMs",
+  "loop",
+  "research"
 ];
 function taskOpsProtocol(executionNote = "", tools = false) {
   const updateChanges = [...UPDATABLE_FIELDS.filter((f) => f !== "taskMode"), "thinkingEffort", "readOnly"].map((f) => f === "dependencies" ? '"dependencies"?:["<id or #order>"]' : `"${f}"?`).join(",");
@@ -1097,7 +1841,7 @@ function taskOpsProtocol(executionNote = "", tools = false) {
     tools ? "- To modify specific tasks, call edit_plan, never a JSON reply. Its argument is:" : "- To modify specific tasks, reply with ONLY this JSON object:",
     tools ? '  {"ops": [' : '  {"taskOps": [',
     `    {"op":"update","taskId":"<id or #order>","changes":{${updateChanges}}},`,
-    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?,"readOnly"?,"ops"?},"handle"?:"<name>"},',
+    '    {"op":"add","task":{"title","description","prompt","dependencies":["<id or #order>"],"assignedRunner"?,"assignedModel"?,"readOnly"?,"research"?,"ops"?},"handle"?:"<name>"},',
     '    {"op":"remove","taskId":"<id or #order>"},',
     '    {"op":"reorder","taskIds":["<id or #order>", "... every task exactly once"]},   // only to re-prioritise INDEPENDENT tasks',
     '    {"op":"merge","taskIds":["<id or #order>", "..."],"merged":{"title","description","prompt"?,"assignedRunner"?,"assignedModel"?,...},"handle"?:"<name>"},',
@@ -1108,11 +1852,14 @@ function taskOpsProtocol(executionNote = "", tools = false) {
     'Every "<id or #order>" ref in a batch resolves against the plan shown above, before any op in the batch runs \u2014 an earlier remove/merge/split never shifts what a later "#N" means. "#N" is top-level task N; a subtask is named by its dotted label ("#2.1"), as the plan lists it.',
     'Give "add", "merge", or "split" a "handle" (any name you choose, unused elsewhere in this batch) to let a LATER op in the same batch reference the task it produces \u2014 for "split", the handle names its last part. A handle used before its defining op is rejected.',
     `When creating or changing tasks, set "assignedRunner" and "assignedModel" ({"modelId","modelLabel","thinkingEffort"?}) using only the runners and models ${tools ? "list_runners and list_models return" : "listed in <available_models>"}.`,
-    'Set "readOnly": true on a task that must not change any file, never on one that must run commands (tests, scripts, builds) or an ops task, and "readOnly": false to lift it; you never set "taskMode". A task you move, split or edit keeps being read-only or not unless you say otherwise, and so do the subtasks of a read-only task you add.',
+    'Set "readOnly": true on a task that must land nothing: it runs tests, scripts and builds sealed through Ordewell run_command (no network), and may try changes in its throwaway worktree, which is thrown away when it ends. Never on an ops task, and "readOnly": false to lift it; you never set "taskMode". A task you move, split or edit keeps being read-only or not unless you say otherwise, and so do the subtasks of a read-only task you add.',
+    `"research": true on a read-only top-level AI task makes it a research task, whose task_complete report wakes you when it ends; "research": false lifts it. Lifting "readOnly" lifts it too. It is never a subtask, an ops task or a loop's body.`,
+    `"loop" makes a task the check of a loop (see LOOPS in your instructions): {"body": ["<id, #order or handle>", ...], "maxRounds"?: 1 to 10}; null drops the loop. A handle cannot be referenced before the op that defines it, so adding a loop takes three ops in this order: "add" the check without "loop", with a "handle"; "add" each body task, depending on the check's handle, with a handle of its own; then "update" the check, by its handle, with "loop": {"body": [the body handles]}.`,
     'Keep dependencies consistent: no cycles, no references to removed tasks, and never touch running or completed tasks \u2014 "rearm" is the one exception, below.',
-    ...tools ? ["edit_plan checks the batch when you call it and answers with what it will change, or with the error to fix \u2014 call it again in the same reply. The edit is applied when your reply ends; edits you make in one reply join one batch."] : [],
+    ...tools ? ["edit_plan checks the batch when you call it and applies it at once, whole or not at all: it answers with what it changed and the id and ref of each task it added, or with the error to fix, having changed nothing \u2014 call it again in the same reply. Each call is a batch of its own against the plan as it then stands, and a later call, run_task or retry_task in the same reply may name a task an earlier call added by the handle it gave."] : [],
     'Just declare the dependencies you want \u2014 display order is repaired for you afterwards, so a rewire or a newly added prerequisite never needs a "reorder" op. Only a task that is running or completed cannot be shifted, so an edit that would need one to move is rejected.' + executionNote,
-    'Flipping "type" between "ai" and "user" is a content change, not just a label: an update to "user" needs "userSteps" in the SAME op, and an update to "ai" needs "prompt" in the SAME op \u2014 the model/mode/effort/autonomy fields (flipping to "user", which also makes the task HITL) or the userSteps (flipping to "ai") are cleared automatically.',
+    'Flipping "type" between "ai", "user" and "script" is a content change, not just a label: an update to "user" needs "userSteps" in the SAME op, an update to "ai" needs "prompt", and an update to "script" needs "commands" or "script" \u2014 the fields the old type had and the new one does not are cleared automatically (flipping to "user" also makes the task HITL). Only a task that has not started can flip to or from "script".',
+    'A script task ("type":"script", top-level only) is run by Ordewell with no model: "commands" is a list of argument vectors run in order with no shell, stopping at the first that fails (e.g. [["git","push","origin","main"]]), or "script" is one script for the shell; "timeoutMs" is its time limit (ten minutes when left out). Give it exactly one of "commands" or "script", and never "prompt", "assignedRunner", "assignedModel", "skills", "readOnly" or "ops". Writing one body replaces the other. Changing its body or time limit takes it out of what the user approved, so it waits for their approval again.',
     `"skills" in "changes" REPLACES the task's whole skill list. To add one, send the names the plan block shows in its skills:[...] plus the new one; to drop one, send the rest; [] removes them all.`,
     '"rearm" puts a failed OR completed task back to pending \u2014 verdict and output summary are cleared, any dependents it had blocked are released, and it may carry field changes (e.g. a corrected "prompt") applied in the same op. A running task cannot be re-armed. Never rearm a task just to relabel it \u2014 only when it should actually run again.'
   ];
@@ -1152,7 +1899,7 @@ function parseTaskOpsObject(json, text2) {
   }
   return ops;
 }
-function resolveRef(ref, originalTree, liveTree, handleOwner, handleId, opIndex) {
+function resolveRef(ref, originalTree, liveTree, handleOwner, handleId, opIndex, earlierHandles) {
   if (typeof ref !== "string" && typeof ref !== "number") return { error: `invalid reference "${String(ref)}"` };
   const s = String(ref).trim();
   const ownerIdx = handleOwner.get(s);
@@ -1164,6 +1911,8 @@ function resolveRef(ref, originalTree, liveTree, handleOwner, handleId, opIndex)
     if (!id) return { error: `handle "${s}" was never resolved` };
     return { id };
   }
+  const earlier = earlierHandles.get(s);
+  if (earlier !== void 0) return findInTasks(liveTree, earlier) ? { id: earlier } : { error: `handle "${s}" names a task that is no longer in the plan` };
   if (findInTasks(liveTree, s)) return { id: s };
   const task = resolveTaskRef(originalTree, s);
   return task ? { id: task.id } : { error: `task "${s}" not found` };
@@ -1175,7 +1924,7 @@ function updatableChanges(raw) {
   }
   if ("ops" in changes) changes.ops = opsFlag(changes.ops);
   if ("skills" in changes) changes.skills = skillNames(changes.skills);
-  return changes;
+  return clearedBodyFields(changes);
 }
 function findInTasks(tasks, id) {
   return taskPlacement(tasks, id)?.task;
@@ -1184,11 +1933,11 @@ function findTopLevel(tasks, id) {
   return tasks.find((t) => t.id === id);
 }
 function isPinned(t) {
-  return t.status === "in_progress" || t.status === "completed";
+  return t.status === "in_progress" || waitsMidAttempt(t) || t.status === "completed";
 }
 function lockedInSubtree(parent) {
   for (const sub of parent.subtasks ?? []) {
-    const locked = lockedTaskRefusal(sub, "removed") ?? lockedInSubtree(sub);
+    const locked = reshapeRefusal(sub, "removed") ?? lockedInSubtree(sub);
     if (locked) return locked;
   }
   return null;
@@ -1236,9 +1985,18 @@ function describeMoves(before, after) {
   return moved.length ? moved.map((m) => `"${m.t.title}" #${m.from}\u2192#${m.to}`).join(", ") : null;
 }
 function pinnedRefusal(other, pin, side) {
-  const word = pin.status === "in_progress" ? "running" : "completed";
+  const word = pin.status === "completed" ? "completed" : "running";
   return `"${other.title}" would have to run ${side} "${pin.title}", which is ${word} and cannot be moved`;
 }
+function opLabel(ref) {
+  return `op ${ref.number} (${ref.kind})`;
+}
+function opRefusalText({ op, message }) {
+  return op ? `${opLabel(op)}: ${message}` : message;
+}
+function refused(tasks, refusals) {
+  return { ok: false, tasks, errors: refusals.map(opRefusalText), refusals, summary: [] };
+}
 function canMergeTasks(tasks, selectedIds) {
   if (selectedIds.length < 2) return { ok: false, error: "Select at least two tasks to merge" };
   const idSet = new Set(selectedIds);
@@ -1247,6 +2005,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__";
@@ -1262,7 +2022,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 };
 }
 function askedReadOnly(spec) {
   return typeof spec?.readOnly === "boolean" ? spec.readOnly : void 0;
@@ -1276,20 +2037,8 @@ function changedFields(target, written, landed, catalog) {
   return fields;
 }
 var NO_CATALOG = { modelsByRunner: {} };
-var keptIds = /* @__PURE__ */ new WeakMap();
-function idsOf(op) {
-  if (typeof op !== "object" || op === null) return uuidv4;
-  const ids = keptIds.get(op) ?? [];
-  keptIds.set(op, ids);
-  let next = 0;
-  return () => {
-    if (next === ids.length) ids.push(uuidv4());
-    return ids[next++];
-  };
-}
-function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
-  const ops = [...held, ...newOps];
-  const opLabel = (i) => i < held.length ? `earlier op ${i + 1} (${ops[i].op})` : `op ${i - held.length + 1} (${ops[i].op})`;
+function applyTaskOps(currentTasks, ops, runners, catalog, earlierHandles = /* @__PURE__ */ new Map()) {
+  const opLabel2 = (i) => ({ number: i + 1, kind: ops[i].op });
   let tasks = JSON.parse(JSON.stringify(currentTasks));
   const errors = [];
   const summary = [];
@@ -1300,26 +2049,30 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
     const handle = op.handle;
     if (handle === void 0) continue;
     if (typeof handle !== "string" || !handle.trim()) {
-      errors.push(`${opLabel(i)}: handle must be a non-empty string`);
+      errors.push({ op: opLabel2(i), message: `handle must be a non-empty string` });
       continue;
     }
     if (handleOwner.has(handle)) {
-      errors.push(`${opLabel(i)}: handle "${handle}" is already used earlier in this batch`);
+      errors.push({ op: opLabel2(i), message: `handle "${handle}" is already used earlier in this batch` });
+      continue;
+    }
+    if (earlierHandles.has(handle)) {
+      errors.push({ op: opLabel2(i), message: `handle "${handle}" already names a task an earlier edit in this reply added: choose another` });
       continue;
     }
     if (resolveTaskRef(currentTasks, handle)) {
-      errors.push(`${opLabel(i)}: handle "${handle}" collides with an existing task reference`);
+      errors.push({ op: opLabel2(i), message: `handle "${handle}" collides with an existing task reference` });
       continue;
     }
     handleOwner.set(handle, i);
   }
-  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
+  if (errors.length) return refused(currentTasks, errors);
   const resolveDeps = (deps, opIndex) => {
     const ids = [];
     const bad = [];
     const liveFlat = flattenTasks(tasks);
     for (const d of Array.isArray(deps) ? deps : []) {
-      const r = resolveRef(d, currentTasks, tasks, handleOwner, handleId, opIndex);
+      const r = resolveRef(d, currentTasks, tasks, handleOwner, handleId, opIndex, earlierHandles);
       if ("error" in r) {
         bad.push(`${String(d)} (${r.error})`);
         continue;
@@ -1354,62 +2107,87 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         if (typeof done2 === "string") return done2;
         subtasks.push(done2);
       }
-      return { ...t, dependencies: ids, subtasks };
+      if (!t.loop) return { ...t, dependencies: ids, subtasks };
+      const body = resolveDeps(t.loop.body, opIndex);
+      if (body.bad.length) return `unknown tasks in the loop's "body"${parentTitle !== void 0 ? ` of ${taskWhere(t.title, parentTitle)}` : ""}: ${body.bad.join(", ")}`;
+      return { ...t, dependencies: ids, subtasks, loop: { ...t.loop, body: body.ids } };
     };
     const done = walk(planned.task);
     return typeof done === "string" ? { error: done } : { task: done };
   };
   const refusalOf = (planned) => [...planned.ignored, ...planned.errors][0]?.message;
-  const prepareEdit = (op, opIndex, label, audience, refuseRunning = false) => {
-    const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, opIndex);
-    if ("error" in ref) return { error: `${label}: ${ref.error}` };
+  const prepareEdit = (op, opIndex, audience, refuseRunning = false) => {
+    const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, opIndex, earlierHandles);
+    if ("error" in ref) return { error: ref.error };
     const target = findInTasks(tasks, ref.id);
-    if (!target) return { error: `${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)` };
-    if (refuseRunning && target.status === "in_progress") return { error: `${label}: ${lockedTaskRefusal(target, "re-armed")}` };
-    if (op.changes && "taskMode" in op.changes) return { error: `${label}: ${MODE_NOT_THE_PLANNERS}` };
+    if (!target) return { error: `task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)` };
+    if (refuseRunning && target.status === "in_progress") return { error: lockedTaskRefusal(target, "re-armed") };
+    const planners = op.changes ? ["readOnly", "thinkingEffort"].filter((f) => op.changes?.[f] !== void 0 && op.changes?.[f] !== null && op.changes?.[f] !== false) : [];
+    if ((op.changes?.type ?? target.type) === "script" && planners.length > 0) return { error: `"${target.title}" ${notOnAScriptMessage(planners)}` };
+    if (op.changes && "taskMode" in op.changes) return { error: MODE_NOT_THE_PLANNERS };
     const changes = updatableChanges(op.changes);
     if (op.changes && "thinkingEffort" in op.changes) {
       const model = changes.assignedModel ?? target.assignedModel;
-      if (!model) return { error: `${label}: "thinkingEffort" is the assigned model's \u2014 set "assignedModel" with it` };
+      if (!model) return { error: `"thinkingEffort" is the assigned model's \u2014 set "assignedModel" with it` };
       changes.assignedModel = { ...model, thinkingEffort: op.changes.thinkingEffort ?? void 0 };
     }
     const changesForCheck = { ...changes };
     delete changesForCheck.dependencies;
     const check = validateTaskEdit(audience, tasks, target.id, changesForCheck);
-    if (!check.ok) return { error: `${label}: ${check.error}` };
+    if (!check.ok) return { error: check.error };
     for (const field of check.clear ?? []) changes[field] = void 0;
     Object.assign(changes, check.set);
     const readOnly = askedReadOnly(op.changes);
-    if (readOnly === true && (changes.type ?? target.type) === "user") return { error: `${label}: ${MANUAL_NOT_READ_ONLY}` };
-    if ((changes.ops ?? target.ops) && (readOnly ?? isReadOnly(target, catalog))) return { error: `${label}: ${OPS_NOT_READ_ONLY}` };
+    if (readOnly === true && (changes.type ?? target.type) === "user") return { error: MANUAL_NOT_READ_ONLY };
+    if ((changes.ops ?? target.ops) && (readOnly ?? isReadOnly(target, catalog))) return { error: OPS_NOT_READ_ONLY };
     const landed2 = { ...changes };
+    if (readOnly === false && target.research && op.changes?.research !== true) landed2.research = false;
     const written = { ...target, ...changes };
-    if (written.type === "user" || runners.includes(written.assignedRunner)) {
+    const kept = target.type === "ai" && written.assignedRunner === target.assignedRunner;
+    if (written.type !== "ai" || kept || runners.includes(written.assignedRunner)) {
       const resolved = resolveAssignment({ writer: "edit", task: written, before: target, readOnly, catalog: catalog ?? NO_CATALOG });
-      if (!resolved.ok) return { error: `${label}: ${resolved.error}` };
+      if (!resolved.ok) return { error: resolved.error };
       if (resolved.task.assignedModel !== written.assignedModel) landed2.assignedModel = resolved.task.assignedModel;
       if (resolved.task.taskMode !== written.taskMode) landed2.taskMode = resolved.task.taskMode;
       adjustments.push(...resolved.adjustments);
     }
     if ("dependencies" in changes) {
       const { ids, bad } = resolveDeps(changes.dependencies, opIndex);
-      if (bad.length) return { error: `${label}: unknown dependencies: ${bad.join(", ")}` };
+      if (bad.length) return { error: `unknown dependencies: ${bad.join(", ")}` };
       landed2.dependencies = ids;
     }
+    if ("loop" in changes) {
+      const spec = loopSpec(changes.loop);
+      if ("error" in spec) return { error: `"${target.title}" ${spec.error}` };
+      if (spec.loop) {
+        const { ids, bad } = resolveDeps(spec.loop.body, opIndex);
+        if (bad.length) return { error: `unknown tasks in the loop's "body": ${bad.join(", ")}` };
+        landed2.loop = { ...spec.loop, body: ids };
+      } else {
+        landed2.loop = void 0;
+        landed2.loopRound = void 0;
+      }
+    }
     return { target, changes: landed2, fields: changedFields(target, changes, landed2, catalog), check };
   };
-  const breachKey = (e) => `${e.taskId ?? ""}\0${e.field}`;
-  const standing = new Set(checkPlanInvariants(currentTasks, runners, catalog?.runnerModes).map(breachKey));
+  const breaches = (list) => {
+    const runnerOf = new Map(flattenTasks(list).map((t) => [t.id, t.assignedRunner]));
+    return checkPlanInvariants(list, runners, catalog?.runnerModes).map((error) => {
+      const runner = error.field === "assignedRunner" ? `\0${runnerOf.get(error.taskId ?? "") ?? ""}` : "";
+      return { error, key: `${error.taskId ?? ""}\0${error.field}${runner}` };
+    });
+  };
+  const standing = new Set(breaches(currentTasks).map((b) => b.key));
   const brokenBy = /* @__PURE__ */ new Map();
-  let lastLabel = opLabel(0);
+  let lastLabel = opLabel2(0);
   for (const [i, op] of ops.entries()) {
-    const label = opLabel(i);
-    const newId = idsOf(op);
+    const label = opLabel2(i);
+    const newId = uuidv4;
     switch (op.op) {
       case "update": {
-        const prep = prepareEdit(op, i, label, "planner");
+        const prep = prepareEdit(op, i, "planner");
         if ("error" in prep) {
-          errors.push(prep.error);
+          errors.push({ op: label, message: prep.error });
           break;
         }
         const { target, changes, fields, check } = prep;
@@ -1419,7 +2197,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
             summary.push(`"${target.title}" is already ${readOnly ? "" : "not "}read-only`);
             break;
           }
-          errors.push(`${label}: no valid changes provided`);
+          errors.push({ op: label, message: `no valid changes provided` });
           break;
         }
         tasks = updateTaskInPlan(tasks, target.id, changes);
@@ -1430,19 +2208,19 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
       case "add": {
         const spec = op.task ?? {};
         if (!spec.title) {
-          errors.push(`${label}: new task needs a title`);
+          errors.push({ op: label, message: `new task needs a title` });
           break;
         }
         const planned = plannedTask(spec, intake, { freshIds: true, newId });
-        const refused = refusalOf(planned);
-        if (refused) {
-          errors.push(`${label}: ${refused}`);
+        const refused2 = refusalOf(planned);
+        if (refused2) {
+          errors.push({ op: label, message: `${refused2}` });
           break;
         }
         adjustments.push(...planned.adjustments);
         const resolved = resolveTree(planned, i);
         if ("error" in resolved) {
-          errors.push(`${label}: ${resolved.error}`);
+          errors.push({ op: label, message: `${resolved.error}` });
           break;
         }
         tasks = addTaskToPlan(tasks, resolved.task);
@@ -1451,19 +2229,19 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         break;
       }
       case "remove": {
-        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i);
+        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i, earlierHandles);
         if ("error" in ref) {
-          errors.push(`${label}: ${ref.error}`);
+          errors.push({ op: label, message: `${ref.error}` });
           break;
         }
         const target = findInTasks(tasks, ref.id);
         if (!target) {
-          errors.push(`${label}: task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)`);
+          errors.push({ op: label, message: `task "${op.taskId}" no longer exists in this batch (removed, merged, or split by an earlier op)` });
           break;
         }
-        const locked = lockedTaskRefusal(target, "removed") ?? lockedInSubtree(target);
+        const locked = reshapeRefusal(target, "removed") ?? lockedInSubtree(target) ?? loopRemovalRefusal(target);
         if (locked) {
-          errors.push(`${label}: ${locked}`);
+          errors.push({ op: label, message: `${locked}` });
           break;
         }
         tasks = removeTaskFromPlan(tasks, target.id);
@@ -1471,20 +2249,20 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         break;
       }
       case "reorder": {
-        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i, earlierHandles));
         const badRef = refs.find((r) => "error" in r);
         if (badRef) {
-          errors.push(`${label}: ${badRef.error}`);
+          errors.push({ op: label, message: `${badRef.error}` });
           break;
         }
         const resolved = refs.map((r) => findTopLevel(tasks, r.id));
         if (resolved.some((t) => !t)) {
-          errors.push(`${label}: unknown task in reorder list`);
+          errors.push({ op: label, message: `unknown task in reorder list` });
           break;
         }
         const orderIds = resolved.map((t) => t.id);
-        if (new Set(orderIds).size !== tasks.length) {
-          errors.push(`${label}: reorder must list every top-level task exactly once (${tasks.length} tasks)`);
+        if (orderIds.length !== tasks.length || new Set(orderIds).size !== tasks.length) {
+          errors.push({ op: label, message: `reorder must list every top-level task exactly once (${tasks.length} tasks)` });
           break;
         }
         const byId = new Map(tasks.map((t) => [t.id, t]));
@@ -1493,37 +2271,37 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         break;
       }
       case "merge": {
-        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i));
+        const refs = (op.taskIds ?? []).map((r) => resolveRef(r, currentTasks, tasks, handleOwner, handleId, i, earlierHandles));
         const badRef = refs.find((r) => "error" in r);
         if (badRef) {
-          errors.push(`${label}: ${badRef.error}`);
+          errors.push({ op: label, message: `${badRef.error}` });
           break;
         }
         const resolved = refs.map((r) => findTopLevel(tasks, r.id));
         if (resolved.some((t) => !t)) {
-          errors.push(`${label}: unknown task in merge list (already removed, merged, or split by an earlier op)`);
+          errors.push({ op: label, message: `unknown task in merge list (already removed, merged, or split by an earlier op)` });
           break;
         }
         const toMerge = [...new Map(resolved.map((t) => [t.id, t])).values()].sort((a, b) => a.order - b.order);
         if (toMerge.length < 2) {
-          errors.push(`${label}: merge needs at least two tasks`);
+          errors.push({ op: label, message: `merge needs at least two tasks` });
           break;
         }
-        const locked = toMerge.map((t) => lockedTaskRefusal(t, "merged")).find((refusal) => refusal !== null);
+        const locked = toMerge.map((t) => reshapeRefusal(t, "merged") ?? loopReshapeRefusal(tasks, t, "merged")).find((refusal) => refusal !== null);
         if (locked) {
-          errors.push(`${label}: ${locked}`);
+          errors.push({ op: label, message: `${locked}` });
           break;
         }
         const idSet = new Set(toMerge.map((t) => t.id));
         const unionDepsRaw = [...new Set(toMerge.flatMap((t) => t.dependencies))].filter((d) => !idSet.has(d));
         const { ids, bad } = resolveDeps(unionDepsRaw, i);
         if (bad.length) {
-          errors.push(`${label}: unknown dependencies: ${bad.join(", ")}`);
+          errors.push({ op: label, message: `unknown dependencies: ${bad.join(", ")}` });
           break;
         }
         const spec = op.merged ?? {};
         if (!spec.title) {
-          errors.push(`${label}: merged task needs a title`);
+          errors.push({ op: label, message: `merged task needs a title` });
           break;
         }
         const writes = toMerge.find((t) => !isReadOnly(t, catalog));
@@ -1536,7 +2314,8 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
             fields: {
               description: toMerge.map((t) => t.description).filter(Boolean).join("\n\n"),
               prompt: toMerge.map((t) => t.prompt).filter(Boolean).join("\n\n---\n\n") || void 0,
-              type: toMerge.some((t) => t.type === "user") ? "user" : "ai",
+              // A merge that takes in a script runs a body, which the merged task must state: no body is guessed (ADR-0035).
+              type: toMerge.some((t) => t.type === "user") ? "user" : toMerge.some((t) => t.type === "script") ? "script" : "ai",
               assignedRunner: toMerge[0].assignedRunner,
               assignedModel: toMerge.find((t) => t.assignedModel)?.assignedModel,
               taskMode: (writes ?? toMerge[0]).taskMode,
@@ -1548,15 +2327,15 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
             }
           }
         });
-        const refused = refusalOf(planned);
-        if (refused) {
-          errors.push(`${label}: ${refused}`);
+        const refused2 = refusalOf(planned);
+        if (refused2) {
+          errors.push({ op: label, message: `${refused2}` });
           break;
         }
         adjustments.push(...planned.adjustments);
         const built = resolveTree({ ...planned, task: { ...planned.task, dependencies: [] } }, i);
         if ("error" in built) {
-          errors.push(`${label}: ${built.error}`);
+          errors.push({ op: label, message: `${built.error}` });
           break;
         }
         const mergedTask = { ...built.task, dependencies: ids };
@@ -1581,24 +2360,24 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         break;
       }
       case "split": {
-        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i);
+        const ref = resolveRef(op.taskId, currentTasks, tasks, handleOwner, handleId, i, earlierHandles);
         if ("error" in ref) {
-          errors.push(`${label}: ${ref.error}`);
+          errors.push({ op: label, message: `${ref.error}` });
           break;
         }
         const target = findTopLevel(tasks, ref.id);
         if (!target) {
-          errors.push(`${label}: task "${op.taskId}" not found`);
+          errors.push({ op: label, message: `task "${op.taskId}" not found` });
           break;
         }
-        const locked = lockedTaskRefusal(target, "split");
+        const locked = reshapeRefusal(target, "split") ?? loopReshapeRefusal(tasks, target, "split");
         if (locked) {
-          errors.push(`${label}: ${locked}`);
+          errors.push({ op: label, message: `${locked}` });
           break;
         }
         const parts = op.parts ?? [];
         if (parts.length < 2) {
-          errors.push(`${label}: split needs at least two parts`);
+          errors.push({ op: label, message: `split needs at least two parts` });
           break;
         }
         const newTasks = [];
@@ -1607,7 +2386,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         for (let p = 0; p < parts.length; p++) {
           const spec = parts[p];
           if (!spec || !spec.title) {
-            errors.push(`${label}: split part ${p + 1} needs a title`);
+            errors.push({ op: label, message: `split part ${p + 1} needs a title` });
             buildError = true;
             break;
           }
@@ -1615,7 +2394,7 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
           if (p === 0) {
             const { ids, bad } = resolveDeps(target.dependencies, i);
             if (bad.length) {
-              errors.push(`${label}: split part 1 unknown dependencies: ${bad.join(", ")}`);
+              errors.push({ op: label, message: `split part 1 unknown dependencies: ${bad.join(", ")}` });
               buildError = true;
               break;
             }
@@ -1641,16 +2420,16 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
               }
             }
           });
-          const refused = refusalOf(planned);
-          if (refused) {
-            errors.push(`${label}: split part ${p + 1}: ${refused}`);
+          const refused2 = refusalOf(planned);
+          if (refused2) {
+            errors.push({ op: label, message: `split part ${p + 1}: ${refused2}` });
             buildError = true;
             break;
           }
           adjustments.push(...planned.adjustments);
           const resolved = resolveTree({ ...planned, task: { ...planned.task, dependencies: [] } }, i);
           if ("error" in resolved) {
-            errors.push(`${label}: split part ${p + 1}: ${resolved.error}`);
+            errors.push({ op: label, message: `split part ${p + 1}: ${resolved.error}` });
             buildError = true;
             break;
           }
@@ -1674,44 +2453,43 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
         break;
       }
       case "rearm": {
-        const prep = prepareEdit(op, i, label, "direct", true);
+        const prep = prepareEdit(op, i, "direct", true);
         if ("error" in prep) {
-          errors.push(prep.error);
+          errors.push({ op: label, message: prep.error });
           break;
         }
         const { target, changes, fields, check } = prep;
-        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0, awaitingReason: void 0, resumeAt: void 0, skipReason: void 0 });
+        tasks = updateTaskInPlan(tasks, target.id, { ...changes, status: "pending", verdict: void 0, outputSummary: void 0, handoff: void 0, awaitingReason: void 0, resumeAt: void 0, skipReason: void 0, loopRound: void 0 });
         const clearedNote = check.clear?.length ? `; cleared ${check.clear.join(", ")}` : "";
         const changedNote = fields.length ? ` (${fields.join(", ")})` : "";
         summary.push(`Re-armed "${target.title}"${changedNote}${clearedNote}`);
         break;
       }
       default:
-        errors.push(`${label}: unknown op "${op.op}"`);
+        errors.push({ op: label, message: `unknown op "${op.op}"` });
     }
     if (errors.length) break;
     lastLabel = label;
-    const now = new Set(checkPlanInvariants(tasks, runners, catalog?.runnerModes).map(breachKey));
+    const now = new Set(breaches(tasks).map((b) => b.key));
     for (const key of brokenBy.keys()) if (!now.has(key)) brokenBy.delete(key);
     for (const key of now) if (!standing.has(key) && !brokenBy.has(key)) brokenBy.set(key, label);
   }
   if (!errors.length) {
-    for (const e of checkPlanInvariants(tasks, runners, catalog?.runnerModes)) {
-      const key = breachKey(e);
-      if (!standing.has(key)) errors.push(`${brokenBy.get(key) ?? lastLabel}: ${e.message}`);
+    for (const { error, key } of breaches(tasks)) {
+      if (!standing.has(key)) errors.push({ op: brokenBy.get(key) ?? lastLabel, message: error.message });
     }
   }
   if (!errors.length) {
     const repaired = repairOrder(tasks);
     if ("error" in repaired) {
-      errors.push(repaired.error);
+      errors.push({ message: repaired.error });
     } else {
       const moves = describeMoves(tasks, repaired.tasks);
       if (moves) summary.push(`Reordered to keep dependencies first: ${moves}`);
       tasks = renumberTasks(repaired.tasks);
     }
   }
-  if (errors.length) return { ok: false, tasks: currentTasks, errors, summary: [] };
+  if (errors.length) return refused(currentTasks, errors);
   const landed = new Map(flattenTasks(tasks).map((t) => [t.id, t]));
   const told = /* @__PURE__ */ new Set();
   const standingAdjustments = adjustments.filter((a) => {
@@ -1722,35 +2500,238 @@ function applyTaskOps(currentTasks, newOps, runners, catalog, held = []) {
     told.add(key);
     return true;
   });
-  return { ok: true, tasks, errors: [], summary, handles: handleId, adjustments: standingAdjustments };
+  return { ok: true, tasks, errors: [], refusals: [], summary, handles: handleId, adjustments: standingAdjustments };
 }
 
-// src/services/continuation.ts
-function sessionOwner(task) {
-  return task.runnerSessionOwner ?? task.attemptUsage?.at(-1)?.runner;
+// src/services/AssignmentScope.ts
+function assignedRunnerOf(task) {
+  return task.type === "ai" ? task.assignedRunner || void 0 : void 0;
 }
-function continuability(task) {
-  const refuse = (reason) => ({ ok: false, reason: `Task "${task.title}" cannot be continued: ${reason}` });
-  if (task.type !== "ai") return refuse("it is not run by an agent.");
-  if (task.status === "awaiting_user" && task.awaitingReason === "conflict") {
-    return refuse("its work is waiting on a merge conflict. Resolve or repair the conflict instead.");
-  }
-  const finished = task.status === "completed" || task.status === "failed" || task.status === "skipped";
-  if (!finished && !pausedOnLimit(task)) return refuse("only a completed, failed or skipped task, or one paused on a usage limit, can be.");
-  if (!task.runnerSessionId) return refuse("its runner left no saved session to resume. Use Retry instead.");
-  const owner = sessionOwner(task);
-  if (owner && owner !== task.assignedRunner) {
-    return refuse(`its saved session belongs to ${owner}; Retry starts fresh on ${task.assignedRunner} and carries over its files.`);
+var OVER = /* @__PURE__ */ new Set(["completed", "skipped"]);
+function assignmentIssue(task, scope) {
+  if (task.type !== "ai" || OVER.has(task.status)) return null;
+  if (!scope.enabledRunners.includes(task.assignedRunner)) return { kind: "runner-off", runner: task.assignedRunner };
+  const model = task.assignedModel;
+  const allowed = effectiveAllowlist(scope.allowlist[task.assignedRunner], task.assignedRunner, scope.models);
+  if (model && allowed && !allowed.includes(model.modelId)) {
+    return { kind: "model-off-list", runner: task.assignedRunner, modelId: model.modelId, modelLabel: model.modelLabel || model.modelId };
   }
-  return { ok: true, sessionId: task.runnerSessionId };
+  return null;
 }
-function canContinue(task) {
-  return continuability(task).ok;
+function assignmentIssueText(issue) {
+  return issue.kind === "runner-off" ? `${issue.runner} is switched off` : `${issue.modelLabel} is not in the allowlist`;
 }
-
-// src/services/blocking.ts
-var UNSTARTED = /* @__PURE__ */ new Set(["pending", "approved"]);
+function assignmentConsequence({ status, awaitingReason, resumeAt }) {
+  if (status === "failed") return "failed; a retry would run it there unless moved";
+  if (status === "awaiting_user" && awaitingReason === "usage-limit") {
+    return resumeAt ? "paused on a usage limit; resumes there at the reset unless moved" : "paused on a usage limit; a retry would run it there unless moved";
+  }
+  if (status === "awaiting_user" && (awaitingReason === "conflict" || awaitingReason === "files-changed")) return "waiting for the user; what runs next runs there unless moved";
+  if (status === "in_progress" || status === "awaiting_user") return "already running as assigned";
+  return "runs as assigned unless moved";
+}
+
+// src/services/conflictFiles.ts
+function capConflictFiles(files, max = 5) {
+  return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
+}
+
+// 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 reposWithWork(handoff) {
+  const withWork = handoff.repos.filter((r) => r.landed.length > 0);
+  return (withWork.length > 0 ? withWork : handoff.repos).map((r) => r.path);
+}
+function mergeTarget(handoff) {
+  if (!isRepoGroup(handoff)) return handoff.repos[0]?.baseBranch ?? "the branch you have checked out";
+  const targets = handoff.repos.filter((r) => reposWithWork(handoff).includes(r.path));
+  const branches = new Set(targets.map((r) => r.baseBranch));
+  const [only] = branches;
+  if (branches.size === 1 && only) return `${only} in each of ${targets.map((r) => r.path).join(", ")}`;
+  return `each of ${targets.map((r) => `${r.path} (${r.baseBranch ?? "as checked out"})`).join(", ")}`;
+}
+function checkoutRule(handoff) {
+  const named = handoff.repos.filter((r) => r.baseBranch);
+  if (named.length === 0) return "";
+  if (!isRepoGroup(handoff)) return ` Nothing is merged unless ${named[0].baseBranch} is checked out.`;
+  return " Nothing is merged unless each repository is on the branch it started on.";
+}
+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/continuation.ts
+function sessionOwner(task) {
+  return task.runnerSessionOwner ?? task.attemptUsage?.at(-1)?.runner;
+}
+function continuability(task) {
+  const refuse = (reason) => ({ ok: false, reason: `Task "${task.title}" cannot be continued: ${reason}` });
+  if (task.type !== "ai") return refuse("it is not run by an agent.");
+  if (task.status === "awaiting_user" && task.awaitingReason === "conflict") {
+    return refuse("its work is waiting on a merge conflict. Resolve or repair the conflict instead.");
+  }
+  const finished = task.status === "completed" || task.status === "failed" || task.status === "skipped";
+  if (!finished && !pausedOnLimit(task)) return refuse("only a completed, failed or skipped task, or one paused on a usage limit, can be.");
+  if (!task.runnerSessionId) return refuse("its runner left no saved session to resume. Use Retry instead.");
+  const owner = sessionOwner(task);
+  if (owner && owner !== task.assignedRunner) {
+    return refuse(`its saved session belongs to ${owner}; Retry starts fresh on ${task.assignedRunner} and carries over its files.`);
+  }
+  return { ok: true, sessionId: task.runnerSessionId };
+}
+function canContinue(task) {
+  return continuability(task).ok;
+}
+
+// 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) {
@@ -1760,6 +2741,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;
@@ -1770,8 +2764,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];
@@ -1779,14 +2775,37 @@ 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/runSettingsText.ts
+var SUPERVISOR_LEVEL_LABEL = { off: "Off", watch: "Watch", act: "Act" };
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+var onOff = (value) => value ? "on" : "off";
+var supervisorSummary = (run) => `Supervisor: ${SUPERVISOR_LEVEL_LABEL[run.supervisorLevel]}, ${plural(run.supervisorRetryLimit, "retry", "retries")} per task, ${plural(run.wakeUpReadBudget, "read", "reads")} per wake-up`;
+var automergeSummary = (run) => `Merge automatically (gates, end of run): ${onOff(run.mergeAtGatesAutomatically)}`;
+var PLANNED_WITH_LABEL = "Planned-with line in commits Ordewell writes";
+var trailerSummary = (run) => `${PLANNED_WITH_LABEL}: ${onOff(run.plannedWithTrailer)}`;
+var autorunSummary = (run) => `Autorun: ${onOff(run.autorun)}`;
+var ACT_RISK = "Tasks it adds run too, ops tasks included, which can act on real systems unattended.";
+var AUTORUN_RISK = "Plans start without review, ops tasks included, which can act on real systems unattended. In Full, the planner may also start tasks it adds later.";
+function parseSwitch(arg) {
+  return arg === "on" ? true : arg === "off" ? false : null;
+}
+function parseCount(arg, min) {
+  if (arg === void 0 || !/^\d+$/.test(arg)) return null;
+  const n = Number(arg);
+  return n >= min ? n : null;
 }
 
 // src/services/SessionMessage.ts
+var IDLE_ACTIVITY = { starting: false, running: false, scheduled: false, resumable: false, advancesOnItsOwn: false };
 function serializeTask(t) {
   return {
     id: t.id,
@@ -1809,17 +2828,28 @@ function serializeTask(t) {
     ...t.status === "awaiting_user" && t.awaitingReason === "usage-limit" && t.resumeAt ? { resumeAt: t.resumeAt } : {},
     ...t.status === "skipped" && t.skipReason ? { skipReason: t.skipReason } : {},
     ...t.ops ? { ops: true } : {},
+    ...t.research !== void 0 ? { research: t.research } : {},
+    ...t.handoff ? { handoff: structuredClone(t.handoff) } : {},
+    ...t.attempted ? { attempted: true } : {},
     ...t.attemptUsage ? { attemptUsage: structuredClone(t.attemptUsage) } : {},
     ...t.skills?.length ? { skills: [...t.skills] } : {},
-    ...t.addedBy ? { addedBy: t.addedBy } : {}
+    ...t.addedBy ? { addedBy: t.addedBy } : {},
+    ...t.commands ? { commands: t.commands.map((argv) => [...argv]) } : {},
+    ...t.script !== void 0 ? { script: t.script } : {},
+    ...t.timeoutMs !== void 0 ? { timeoutMs: t.timeoutMs } : {},
+    ...t.loop ? { loop: { body: [...t.loop.body], maxRounds: t.loop.maxRounds } } : {},
+    ...t.loop && t.loopRound !== void 0 ? { loopRound: t.loopRound } : {}
   };
 }
-function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [], awaitingApproval = 0, mergeGate = [], checkpoint = "", waitsForApproval = false) {
+function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [], awaitingApproval = 0, mergeGate = [], checkpoint = "", waitsForApproval = false, holdReason = null, completionReceived = null) {
   return {
     id: t.id,
+    type: t.type,
     status: t.status,
-    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [] } : null,
+    verdict: t.verdict ? { outcome: t.verdict.outcome, reason: t.verdict.reason, checks: t.verdict.checks || [], ...t.verdict.reported ? { reported: t.verdict.reported } : {} } : null,
     idleSince,
+    ...completionReceived ? { completionReceived } : {},
+    ...t.attempted ? { attempted: true } : {},
     ...t.attemptUsage ? { attemptUsage: structuredClone(t.attemptUsage) } : {},
     ...isolation ? { isolation } : {},
     ...t.status === "awaiting_user" && t.awaitingReason ? { awaitingReason: t.awaitingReason } : {},
@@ -1831,7 +2861,12 @@ function serializeTaskStatus(t, idleSince = null, isolation = null, queued = [],
     ...awaitingApproval > 0 ? { awaitingApproval } : {},
     ...mergeGate.length > 0 ? { mergeGate: [...mergeGate] } : {},
     ...t.forcedPastGate?.length ? { forcedPastGate: [...t.forcedPastGate] } : {},
-    ...waitsForApproval ? { waitsForApproval: true } : {}
+    ...waitsForApproval ? { waitsForApproval: true } : {},
+    ...holdReason ? { holdReason } : {},
+    ...t.research ? { research: true } : {},
+    ...t.handoff ? { handoff: structuredClone(t.handoff) } : {},
+    ...t.loop ? { loop: { body: [...t.loop.body], maxRounds: t.loop.maxRounds } } : {},
+    ...t.loop && t.loopRound !== void 0 ? { loopRound: t.loopRound } : {}
   };
 }
 function surfaceConversation(history) {
@@ -1866,6 +2901,7 @@ function serializePlan(plan) {
     generatedAt: plan.generatedAt,
     runSettings: plan.runSettings,
     ...plan.plannerResend ? { plannerResend: plan.plannerResend } : {},
+    ...plan.plannerContextPause ? { plannerContextPause: plan.plannerContextPause } : {},
     conversationHistory: surfaceConversation(plan.conversationHistory),
     prdMarkdown: plan.prdMarkdown
   };
@@ -1887,127 +2923,10 @@ function truncateCheckpointSummary(summary) {
   return firstLine.slice(0, CHECKPOINT_TRUNCATE_LENGTH - 1) + "\u2026";
 }
 
-// src/services/AssignmentScope.ts
-var OVER = /* @__PURE__ */ new Set(["completed", "skipped"]);
-function assignmentIssue(task, scope) {
-  if (task.type !== "ai" || OVER.has(task.status)) return null;
-  if (!scope.enabledRunners.includes(task.assignedRunner)) return { kind: "runner-off", runner: task.assignedRunner };
-  const model = task.assignedModel;
-  const allowed = effectiveAllowlist(scope.allowlist[task.assignedRunner], task.assignedRunner, scope.models);
-  if (model && allowed && !allowed.includes(model.modelId)) {
-    return { kind: "model-off-list", runner: task.assignedRunner, modelId: model.modelId, modelLabel: model.modelLabel || model.modelId };
-  }
-  return null;
-}
-function assignmentIssueText(issue) {
-  return issue.kind === "runner-off" ? `${issue.runner} is switched off` : `${issue.modelLabel} is not in the allowlist`;
-}
-function assignmentConsequence({ status, awaitingReason, resumeAt }) {
-  if (status === "failed") return "failed; a retry would run it there unless moved";
-  if (status === "awaiting_user" && awaitingReason === "usage-limit") {
-    return resumeAt ? "paused on a usage limit; resumes there at the reset unless moved" : "paused on a usage limit; a retry would run it there unless moved";
-  }
-  if (status === "awaiting_user" && (awaitingReason === "conflict" || awaitingReason === "files-changed")) return "waiting for the user; what runs next runs there unless moved";
-  if (status === "in_progress" || status === "awaiting_user") return "already running as assigned";
-  return "runs as assigned unless moved";
-}
-
-// src/services/conflictFiles.ts
-function capConflictFiles(files, max = 5) {
-  return files.length <= max ? files.join(", ") : `${files.slice(0, max).join(", ")}, +${files.length - max} more`;
-}
-
-// src/services/researchStepSummary.ts
-function ellipsize(text2, max) {
-  const oneLine2 = text2.replace(/\s+/g, " ").trim();
-  return oneLine2.length > max ? `${oneLine2.slice(0, max)}\u2026` : oneLine2;
-}
-function summarizeToolCall(tool, argsJson, toolLabel) {
-  const display = toolLabel?.trim() || tool;
-  if (tool === "agent_tool") {
-    try {
-      const args = JSON.parse(argsJson);
-      const hint = args.path ?? args.file_path ?? args.filePath ?? args.pattern ?? args.query ?? args.url ?? args.command;
-      if (hint) return `${display} ${ellipsize(String(hint), 50)}`;
-    } catch {
-    }
-    return display;
-  }
-  if (tool === "spawn_research_agent") {
-    try {
-      const args = JSON.parse(argsJson);
-      const prompt = typeof args.prompt === "string" ? args.prompt : "";
-      const oneLine2 = prompt.replace(/\s+/g, " ").trim();
-      return `spawn: "${oneLine2.slice(0, 60)}${oneLine2.length > 60 ? "\u2026" : ""}"`;
-    } catch {
-      return "spawn_research_agent";
-    }
-  }
-  try {
-    const args = JSON.parse(argsJson);
-    if (tool === "find_symbol" && args.symbol) {
-      return `find_symbol ${args.symbol}${args.language ? ` [${args.language}]` : ""}`;
-    }
-    if (tool === "web_search" && args.query) {
-      return `web_search "${ellipsize(String(args.query), 50)}"`;
-    }
-    if (tool === "fetch" && args.url) {
-      return `fetch ${ellipsize(String(args.url), 60)}`;
-    }
-    if (tool === "glob" && args.pattern) {
-      return `glob ${ellipsize(String(args.pattern), 50)}`;
-    }
-    if (tool === "grep" && args.pattern) {
-      const mode = args.output_mode && args.output_mode !== "content" ? ` (${args.output_mode})` : "";
-      const scope = args.include ? ` in ${args.include}` : "";
-      return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
-    }
-    const path = args.filePath || args.file_path || args.path;
-    if (path) {
-      const basename = String(path).split("/").pop() || String(path);
-      return `${display} ${basename}`;
-    }
-    if (args.pattern) {
-      return `${display} ${args.pattern}`;
-    }
-    if (args.command) {
-      return `bash: ${String(args.command).slice(0, 40)}`;
-    }
-  } catch {
-  }
-  return display;
-}
-function classifyOutcome(success, output) {
-  if (!success) {
-    if (/^(Command|Fetch|Web search) refused:/.test(output) || /is not available\. You are a read-only research subagent/.test(output)) return "refused";
-    if (/not approved/i.test(output) || /^Access denied:/.test(output) || /needs user approval/i.test(output)) return "denied";
-    return "failure";
-  }
-  return "success";
-}
-
-// src/services/runSettingsText.ts
-var SUPERVISOR_LEVEL_LABEL = { off: "Off", watch: "Watch", act: "Act" };
-var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
-var onOff = (value) => value ? "on" : "off";
-var supervisorSummary = (run) => `Supervisor: ${SUPERVISOR_LEVEL_LABEL[run.supervisorLevel]}, ${plural(run.supervisorRetryLimit, "retry", "retries")} per task, ${plural(run.wakeUpReadBudget, "read", "reads")} per wake-up`;
-var automergeSummary = (run) => `Merge automatically (gates, end of run): ${onOff(run.mergeAtGatesAutomatically)}`;
-var autorunSummary = (run) => `Autorun: ${onOff(run.autorun)}`;
-var ACT_RISK = "Tasks it adds run too, ops tasks included, which can act on real systems unattended.";
-var AUTORUN_RISK = "Plans start without review, ops tasks included, which can act on real systems unattended. In Full, the planner may also start tasks it adds later.";
-function parseSwitch(arg) {
-  return arg === "on" ? true : arg === "off" ? false : null;
-}
-function parseCount(arg, min) {
-  if (arg === void 0 || !/^\d+$/.test(arg)) return null;
-  const n = Number(arg);
-  return n >= min ? n : null;
-}
-
 // src/services/runView.ts
-var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null };
-function split({ verdict, idleSince, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate, waitsForApproval, ...plan }) {
-  return { plan, status: { verdict, idleSince, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate, waitsForApproval } };
+var EMPTY_RUN = { tasks: [], runMerge: null, handoff: null, mergeResult: null, activity: IDLE_ACTIVITY };
+function split({ verdict, idleSince, completionReceived, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate, waitsForApproval, holdReason, handoff, attempted, ...plan }) {
+  return { plan, status: { verdict, idleSince, completionReceived, isolation, checkpoint, queued, continuable, awaitingApproval, mergeGate, forcedPastGate, waitsForApproval, holdReason, handoff, attempted } };
 }
 function refresh(previous, tasks) {
   const held = new Map([...walkPlan(previous)].map(({ task }) => [task.id, task]));
@@ -2019,7 +2938,7 @@ function refresh(previous, tasks) {
   };
   return tasks.map(fold);
 }
-function withStatus({ awaitingReason: _reason, resumeAt: _resumeAt, skipReason: _skipped, attemptUsage: _usage, ...plan }, { id: _id, ...status }) {
+function withStatus({ awaitingReason: _reason, resumeAt: _resumeAt, skipReason: _skipped, attemptUsage: _usage, loopRound: _round, ...plan }, { id: _id, ...status }) {
   return { ...plan, ...status };
 }
 function applyStatus(tasks, updates) {
@@ -2061,7 +2980,13 @@ var PATCHABLE = /* @__PURE__ */ new Set([
   "ops",
   "skills",
   "addedBy",
-  "attemptUsage"
+  "attemptUsage",
+  "commands",
+  "script",
+  "timeoutMs",
+  "loop",
+  "loopRound",
+  "research"
 ]);
 function patchTask(task, changes) {
   const fields = Object.entries(changes).filter(([key]) => PATCHABLE.has(key));
@@ -2107,15 +3032,14 @@ function reduceRun(view, input) {
         tasks: applyStatus(view.tasks, new Map(input.tasks.map((t) => [t.id, t]))),
         runMerge: input.runMerge ?? null,
         handoff: stillToMerge(view.handoff, input.runMerge),
-        usage: input.usage
+        usage: input.usage,
+        ...input.activity ? { activity: input.activity } : {}
       };
     case "task_started":
     case "task_updated": {
       const tasks = changeTask(view.tasks, input.taskId, (task) => input.type === "task_started" ? startTask(task) : patchTask(task, input.changes));
       return tasks === view.tasks ? view : { ...view, tasks };
     }
-    case "plan_edit_held":
-      return { ...view, heldEdit: input.held ?? void 0 };
     case "isolation_handoff":
       return { ...view, handoff: handoffOf(input) };
     case "isolation_merge":
@@ -2143,6 +3067,7 @@ function reduceRun(view, input) {
     case "planner_text_retracted":
     case "planner_usage":
     case "planner_liveness":
+    case "planner_compaction":
     case "subagent_started":
     case "subagent_finished":
     case "research_step":
@@ -2159,6 +3084,95 @@ function reduceRun(view, input) {
   }
 }
 
+// src/taskRow/texts.ts
+function titledRefs(ids, tasks) {
+  return ids.map((id) => titledTaskRefOf(tasks, id) ?? id);
+}
+function dependentsNotice(dependents, tasks = []) {
+  if (dependents.length === 0) return null;
+  const subject = dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`;
+  return `${subject} on it and will lose that dependency: ${dependents.map((t) => (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/conversationSummary.ts
+var KEPT_USER_MESSAGES = 2;
+var SUMMARY_OPEN = "<conversation_summary>";
+var SUMMARY_CLOSE = "</conversation_summary>";
+function summaryRequest(planLines) {
+  return [
+    "The user asked to condense this planning conversation. Write a summary that will replace everything said so far, so the conversation can carry on from it alone.",
+    "Keep: the goal, the decisions made, the constraints, the open questions, the key file and code findings, and where the plan stands now.",
+    "Reply in plain prose. Do not emit task operations, plan JSON or task reads, and do not run tools \u2014 the tasks are not changing in this turn.",
+    `Put the summary between ${SUMMARY_OPEN} and ${SUMMARY_CLOSE}, and nothing outside the tags.`,
+    ...planLines ? ["<current_plan>", ...planLines, "</current_plan>"] : []
+  ].join("\n");
+}
+function extractSummary(reply) {
+  const matches = [...reply.matchAll(new RegExp(`${SUMMARY_OPEN}([\\s\\S]*?)${SUMMARY_CLOSE}`, "g"))];
+  const summary = matches.at(-1)?.[1].trim();
+  return summary || null;
+}
+function condensedNotice(summary, trigger = "manual") {
+  return [
+    trigger === "manual" ? "Conversation condensed: the summary below stands in for the earlier messages from here on, and the last two exchanges were kept as they were. The full conversation stays in the history. The task list is unchanged." : "Conversation condensed automatically to fit the model's context: the summary below stands in for the earlier messages from here on, and the most recent exchanges that fit were kept as they were. The full conversation stays in the history. Task and run state are the current plan's, not this summary's.",
+    "",
+    summary
+  ].join("\n");
+}
+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");
+}
+function newestCheckpoint(transcript) {
+  let newest = null;
+  for (const [at, entry] of transcript.entries()) {
+    if (entry.kind !== "compaction") continue;
+    if (at === 0) newest = { at, keptFrom: 1 };
+    else if (isCheckpoint(entry.checkpoint) && entry.checkpoint.keptFrom >= (newest?.keptFrom ?? 0) && entry.checkpoint.keptFrom <= at) {
+      newest = { at, keptFrom: entry.checkpoint.keptFrom };
+    }
+  }
+  return newest;
+}
+function modelContext(transcript) {
+  const checkpoint = newestCheckpoint(transcript);
+  const verbatim = (checkpoint ? transcript.slice(checkpoint.keptFrom) : transcript).filter((m) => m.kind !== "compaction");
+  return checkpoint ? [transcript[checkpoint.at], ...verbatim] : verbatim;
+}
+function contextFloor(transcript) {
+  return newestCheckpoint(transcript)?.keptFrom ?? 0;
+}
+function compactionCut(transcript) {
+  const floor = contextFloor(transcript);
+  const userAt = transcript.flatMap((m, i) => i >= floor && isUserMessage(m) ? [i] : []);
+  if (userAt.length <= KEPT_USER_MESSAGES) return null;
+  return userAt[userAt.length - KEPT_USER_MESSAGES];
+}
+
 // src/conversation/reduce.ts
 var EMPTY_CONVERSATION = { blocks: [], nextId: 1 };
 function isUnsettledSegment(block, turnId) {
@@ -2171,7 +3185,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;
   }
@@ -2187,10 +3201,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++) {
@@ -2326,7 +3341,7 @@ function markPlan(view, content, turnId) {
   }
   return append(view, (id) => ({ type: "plan", id, text: "", ...marker }));
 }
-function requestApproval2(view, { id: approvalId, kind, subject, scope, detail, turnId }) {
+function requestApproval2(view, { id: approvalId, kind, subject, scope, detail, body, turnId }) {
   return append(view, (id) => ({
     type: "approval",
     id,
@@ -2336,6 +3351,7 @@ function requestApproval2(view, { id: approvalId, kind, subject, scope, detail,
     scope,
     status: "pending",
     ...detail ? { detail } : {},
+    ...body ? { body } : {},
     ...turnId ? { turnId } : {}
   }));
 }
@@ -2366,11 +3382,48 @@ function endTurn2(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 ?? [];
@@ -2379,12 +3432,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 };
@@ -2436,6 +3490,8 @@ function reduceConversation(view, input) {
       return append(view, (id) => settledMessage(id, "system", input.text));
     case "planner_usage":
       return reportUsage2(view, input);
+    case "planner_compaction":
+      return followCompaction(view, input);
     default:
       return view;
   }
@@ -2451,13 +3507,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":
@@ -2568,6 +3633,82 @@ function fromTranscript(conversationHistory, researchLog, plannerUsage, pendingT
   return { blocks, nextId, ...transcriptAt ? { transcriptAt } : {}, ...pendingInputs.length > 0 ? { pendingInputs } : {} };
 }
 
+// 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) {
@@ -2636,9 +3777,100 @@ function stopTurn(view, gate) {
   };
 }
 
+// src/services/WakePolicy.ts
+var REPORT_LEAD = ", whose result you asked for, has ended.";
+function createWakePolicy(options) {
+  const { debounceMs } = options;
+  if (!Number.isFinite(debounceMs) || debounceMs < 0) {
+    throw new RangeError(`debounceMs must be a finite, non-negative number of milliseconds, got ${debounceMs}`);
+  }
+  let attention = [];
+  let sinceLast = [];
+  const dueAt = () => {
+    const first = attention[0];
+    if (!first) return null;
+    return attention.some((e) => e.kind === "run_finished") ? first.at : first.at + debounceMs;
+  };
+  return {
+    push(event) {
+      if (event.kind === "task_passed") {
+        sinceLast.push(event);
+        return;
+      }
+      if (event.kind === "task_idle" && attention.some((e) => e.kind === "task_idle" && e.taskId === event.taskId)) return;
+      if (event.kind === "run_finished" && attention.some((e) => e.kind === "run_finished")) return;
+      if (event.kind === "usage_limit") {
+        const at = attention.findIndex((e) => e.kind === "usage_limit" && e.runner === event.runner);
+        const taskIds = event.taskId === void 0 ? [] : [event.taskId];
+        if (at < 0) {
+          attention.push({ ...event, taskIds });
+          return;
+        }
+        const joined = attention[at];
+        attention = attention.map((e, i) => i !== at ? e : {
+          ...joined,
+          taskIds: [.../* @__PURE__ */ new Set([...joined.taskIds ?? [], ...taskIds])],
+          resumeAt: event.resumeAt ?? joined.resumeAt ?? null
+        });
+        return;
+      }
+      attention.push(event);
+    },
+    poll(now) {
+      const due = dueAt();
+      if (due === null || now < due) return null;
+      const batch = { attention, sinceLast };
+      attention = [];
+      sinceLast = [];
+      return batch;
+    },
+    dueAt,
+    snapshot() {
+      return { attention: [...attention], sinceLast: [...sinceLast] };
+    },
+    restore(snapshot) {
+      attention = [...snapshot?.attention ?? []];
+      sinceLast = [...snapshot?.sinceLast ?? []];
+    }
+  };
+}
+
+// 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
@@ -2730,8 +3962,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;
@@ -2742,7 +3992,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"],
@@ -2765,24 +4015,138 @@ 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/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 handoffOf2(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;
@@ -2793,17 +4157,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),
@@ -2815,6 +4188,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: handoffOf2(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")),
@@ -2822,23 +4197,90 @@ 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/texts.ts
-function titledRefs(ids, tasks) {
-  return ids.map((id) => titledTaskRefOf(tasks, id) ?? id);
+// 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 dependentsNotice(dependents, tasks = []) {
-  if (dependents.length === 0) return null;
-  const subject = dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`;
-  return `${subject} on it and will lose that dependency: ${dependents.map((t) => (t.id ? titledTaskRefOf(tasks, t.id) : void 0) ?? titledTaskRef(t)).join(", ")}.`;
+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 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 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 newTaskFields(title, prompt) {
-  const name = title.trim();
-  if (!name) return null;
-  return { title: name, description: name, prompt: prompt?.trim() ? prompt : name, type: "ai" };
+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)
+  };
 }
 
 export {
@@ -2866,7 +4308,59 @@ export {
   modelCostTitle,
   subagentCostTitle,
   tasksTotalText,
+  hasAccountLimits,
+  accountLimitsOf,
+  accountLimitWindowLabel,
+  accountLimitPercentText,
+  accountLimitsText,
+  accountLimitsTitle,
+  trimToolOutput,
+  toTaskLogEvent,
+  lastServedModel,
+  taskLogForSurface,
+  coalesceTaskLog,
+  scriptRunText,
+  secondsText,
+  scriptExitText,
+  digestTaskLog,
+  SEVERITY_LABEL,
+  severityLabel,
+  worstSeverity,
+  REPORT_MAX_CHARS,
+  HANDOFF_LIMITS,
+  DIGEST_FINDINGS,
+  storedHandoff,
+  withPatch,
+  savedPatchOf,
+  handoffDigest,
+  namedHandoff,
+  handoffReferenceText,
+  byteSize,
+  patchFlagText,
+  patchChangesText,
+  patchLinesText,
+  patchText,
+  patchLines,
+  patchView,
+  savedPatchViews,
+  savedPatchView,
+  findingLines,
+  artifactLines,
+  openingLines,
+  HANDOFF_PUSH_CHARS,
+  boundedHandoffLines,
+  handoffPreviewLines,
+  handoffWakeLines,
+  handoffLines,
+  readableTaskIds,
+  checkHandoff,
+  summarizeToolCall,
+  SEALED_RUN_MARK,
+  ranSealed,
+  withoutSealedMark,
+  classifyOutcome,
   sameMessage,
+  isFileEditTool,
   mapAgentTool,
   normalizeAgentArgs,
   toolHeadline,
@@ -2886,52 +4380,97 @@ export {
   taskStatusKind,
   awaitingLabel,
   blockedByLabel,
+  holdLabel,
   skippedLabel,
   WAITS_FOR_APPROVAL_LABEL,
+  receiptLabel,
   approvalLabel,
   resumeTime,
   resumeLabel,
+  startedEditRefusal,
   validateTaskEdit,
   UPDATABLE_FIELDS,
   taskOpsProtocol,
   textHasTaskOps,
   parseTaskOpsJson,
+  opLabel,
+  opRefusalText,
   canMergeTasks,
   canSplitTask,
   applyTaskOps,
-  sessionOwner,
-  continuability,
-  canContinue,
-  blockingFailures,
-  serializeTask,
-  serializeTaskStatus,
-  surfaceTask,
-  surfacePlan,
-  surfacePlanState,
-  serializePlan,
-  executionSummary,
-  CHECKPOINT_TRUNCATE_LENGTH,
-  truncateCheckpointSummary,
+  REPORT_LEAD,
+  createWakePolicy,
+  summaryRequest,
+  extractSummary,
+  condensedNotice,
+  modelContext,
+  contextFloor,
+  compactionCut,
+  assignedRunnerOf,
   assignmentIssue,
   assignmentIssueText,
   assignmentConsequence,
   capConflictFiles,
-  summarizeToolCall,
-  classifyOutcome,
+  blockNotice,
+  blockNotices,
+  repairedLanded,
+  repairedNotice,
+  describeMergeResult,
+  mergeOutcome,
+  describeIsolationPreview,
+  isRepoGroup,
+  reposWithWork,
+  mergeTarget,
+  checkoutRule,
+  handoffBranchName,
+  repoBaseLine,
+  handoffBaseLine,
+  repoResultLines,
+  sessionOwner,
+  continuability,
+  canContinue,
+  blockingFailures,
+  repeatingChecks,
+  planBlocks,
   SUPERVISOR_LEVEL_LABEL,
   supervisorSummary,
   automergeSummary,
+  PLANNED_WITH_LABEL,
+  trailerSummary,
   autorunSummary,
   ACT_RISK,
   AUTORUN_RISK,
   parseSwitch,
   parseCount,
+  IDLE_ACTIVITY,
+  serializeTask,
+  serializeTaskStatus,
+  surfacePlan,
+  surfacePlanState,
+  serializePlan,
+  executionSummary,
+  CHECKPOINT_TRUNCATE_LENGTH,
+  truncateCheckpointSummary,
   EMPTY_RUN,
   reduceRun,
+  titledRefs,
+  dependentsNotice,
+  loopLeaveNotice,
+  pastGateConfirmation,
+  manualOverrideConfirmation,
+  manualOverrideStopFirst,
+  newTaskFields,
+  noExecutorRefusal,
   EMPTY_CONVERSATION,
   reconcileApprovals,
   reduceConversation,
   fromTranscript,
+  approvalKindText,
+  approvalStatusText,
+  planMarkerParts,
+  handoffFindingsText,
+  handoffPeekParts,
+  compactionText,
   EMPTY_HOLD,
   holdPrompt,
   drainNext,
@@ -2942,21 +4481,36 @@ export {
   NO_TURN,
   followTurn,
   stopTurn,
+  REPORT_PREVIEW_LINES,
+  hasLongReport,
+  wakeUpItems,
   hasHiddenDetail,
   taskStartedNotice,
   markdownTokens,
   markdownHtml,
   EMPTY_TASK_LOG_FOLLOW,
   followTaskLog,
+  editableWhileRunning,
+  runHoldsEditors,
+  cardEditable,
+  cardEditNeedsUnstarted,
   taskRowActions,
   markAction,
-  markRequestFor,
+  taskActionCommand,
+  overrideNeedsConfirmation,
+  confirmedOverride,
   opsEditable,
+  loopCheckState,
+  loopCheckLabel,
+  loopBodyRound,
+  loopBodyLabel,
+  taskChatAvailable,
   namedRepos,
   taskRowView,
-  titledRefs,
-  dependentsNotice,
-  pastGateConfirmation,
-  newTaskFields
+  loopRowParts,
+  taskLogCommands,
+  logContinues,
+  logResumes,
+  taskLogHeaderView
 };
-//# sourceMappingURL=chunk-ESKK5I4F.mjs.map
+//# sourceMappingURL=chunk-4QXOWEGC.mjs.map