@ordewell/cli 0.10.5 → 0.10.6

package/dist/main.js

@@ -631,18 +631,18 @@ var ApiClient = class _ApiClient {
     return this.call("POST", `/api/plans/${sessionId}/review/approve`, "Approve failed");
   }
   markTaskComplete(sessionId, taskId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/complete`, "Mark complete failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/complete`, "Mark complete failed");
   }
   /** Skip: end the task without landing its work, so what depends on it goes ahead once the work it waited on is done; never a mark complete. */
   skipTask(sessionId, taskId, reason) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/skip`, "Skip failed", reason ? { reason } : {});
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/skip`, "Skip failed", reason ? { reason } : {});
   }
   markTaskIncomplete(sessionId, taskId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/uncomplete`, "Mark not done failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/uncomplete`, "Mark not done failed");
   }
-  /** Keep a task paused on a usage limit from resuming on its own; `cancelled` is false when none was scheduled. */
+  /** Keep a task paused on a usage limit from resuming on its own; a task with none scheduled is refused with the reason. */
   cancelResume(sessionId, taskId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resume/cancel`, "Cancel resume failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/resume/cancel`, "Cancel resume failed");
   }
   /** Keep what waits on the planner's usage limit from being sent at the reset; `cancelled` is false when nothing waited. */
   cancelPlannerResend(sessionId) {
@@ -650,55 +650,55 @@ var ApiClient = class _ApiClient {
   }
   /** Resume a task paused on a usage limit now, in its saved session, once the user says the limit has reset. */
   resumeNow(sessionId, taskId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resume/now`, "Resume failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/resume/now`, "Resume failed");
   }
   /** run | force-start | retry | cancel — real orchestrator work, not a status patch. */
   taskControl(sessionId, taskId, action) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/${action}`, `${action} failed`);
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/${action}`, `${action} failed`);
   }
   /** A user message to a structured task: delivered now if it waits for input, else queued behind its turn. */
   sendTaskMessage(sessionId, taskId, text) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages`, "Send message failed", { text });
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/messages`, "Send message failed", { text });
   }
   /** Force send: interrupt the task's running turn and deliver `text` next, ahead of anything queued (ADR-0023, F1). */
   forceSendTaskMessage(sessionId, taskId, text) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/now`, "Send now failed", { text });
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/messages/now`, "Send now failed", { text });
   }
   /** Run the task runner's own command `/name args` as a turn of its own (#66). */
   invokeTaskCommand(sessionId, taskId, name, args) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/commands`, "Command failed", { name, args });
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/commands`, "Command failed", { name, args });
   }
-  /** Force send a message still queued; `sent` is false once the runner already has it. */
+  /** Force send a message still queued; one the runner already has is refused with the reason. */
   forceSendQueuedTaskMessage(sessionId, taskId, messageId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}/now`, "Send now failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/messages/${encodeURIComponent(messageId)}/now`, "Send now failed");
   }
   /** Continue a finished structured task in its saved session, with `text` as its next turn. */
   continueTask(sessionId, taskId, text) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/continue`, "Continue failed", { text });
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/continue`, "Continue failed", { text });
   }
-  /** `removed` is false once the message was already delivered. */
+  /** Take back a queued message; one already delivered is refused with the reason. */
   removeQueuedTaskMessage(sessionId, taskId, messageId) {
-    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}`, "Remove message failed");
+    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/messages/${encodeURIComponent(messageId)}`, "Remove message failed");
   }
   interruptTask(sessionId, taskId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/interrupt`, "Interrupt failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/interrupt`, "Interrupt failed");
   }
   /** Let a task go on from the checkpoint it waits at; refused, with the reason, when none waits. */
   approveTaskCheckpoint(sessionId, taskId) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/approve`, "Approve checkpoint failed");
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/checkpoint/approve`, "Approve checkpoint failed");
   }
   /** Turn a task back at its checkpoint; `reason` is what the agent is told. */
   rejectTaskCheckpoint(sessionId, taskId, reason) {
-    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/reject`, "Reject checkpoint failed", reason ? { reason } : {});
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/checkpoint/reject`, "Reject checkpoint failed", reason ? { reason } : {});
   }
   addTask(sessionId, task) {
     return this.call("POST", `/api/plans/${sessionId}/tasks`, "Add task failed", task);
   }
   updateTask(sessionId, taskId, changes) {
-    return this.call("PUT", `/api/plans/${sessionId}/tasks/${taskId}`, "Update task failed", changes);
+    return this.call("PUT", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}`, "Update task failed", changes);
   }
   removeTask(sessionId, taskId) {
-    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${taskId}`, "Remove task failed");
+    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}`, "Remove task failed");
   }
   /**
    * Make a saved session live on the server. `getSession` only reads the file;
@@ -708,7 +708,7 @@ var ApiClient = class _ApiClient {
   async adoptSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
     const res = await this.call("POST", `/api/sessions/${sessionId}/load${qs}`, "Failed to load session");
-    return { plan: res.plan, goal: res.goal ?? "" };
+    return { plan: res.plan, goal: res.goal ?? "", ...res.run ? { run: res.run } : {} };
   }
   deleteSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
@@ -739,7 +739,7 @@ var ApiClient = class _ApiClient {
   }
   /** The ancestors a task waits on at its merge gate (ADR-0020); empty when nothing gates it. */
   async getMergeGate(sessionId, taskId) {
-    const res = await this.call("GET", `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`, "Could not read the merge gate");
+    const res = await this.call("GET", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/merge-gate`, "Could not read the merge gate");
     return res.mergeGate ?? [];
   }
   async reviewRunDiff(sessionId) {
@@ -769,7 +769,7 @@ var ApiClient = class _ApiClient {
     await this.call("POST", `/api/plans/${sessionId}/isolation/${segment}`, failure);
   }
   async resolveConflictAsTask(sessionId, taskId) {
-    const res = await this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resolve-conflict`, "Could not add a resolver task");
+    const res = await this.call("POST", `/api/plans/${sessionId}/tasks/${encodeURIComponent(taskId)}/resolve-conflict`, "Could not add a resolver task");
     return res.plan;
   }
   async closeSession(sessionId) {
@@ -798,13 +798,13 @@ var ApiClient = class _ApiClient {
   async getTaskLogAttempts(sessionId, taskId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
     const res = await this.call("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log${qs}`, "Could not read the task log");
-    return res.attempts;
+    return res;
   }
   /** One attempt's saved log, for `replayTaskLog`. */
   async getTaskLog(sessionId, taskId, attempt, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
     const res = await this.call("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log/${attempt}${qs}`, "Could not read the task log");
-    return res.events;
+    return res;
   }
   /**
    * The one place a session socket is built, so the token travels on both
@@ -1045,12 +1045,7 @@ function allTasksOf(plan) {
   return (0, import_core5.rejoinPlanTree)(tasks, executionLog);
 }
 function resolveTaskId(plan, identifier) {
-  const allTasks = allTasksOf(plan);
-  const byRef = (0, import_core5.resolveTaskRef)(allTasks, identifier);
-  if (byRef) return byRef.id;
-  const prefixMatches = allTasks.filter((t) => typeof t.id === "string" && t.id.startsWith(identifier));
-  if (prefixMatches.length === 1) return prefixMatches[0].id;
-  return void 0;
+  return (0, import_core5.resolveUserTaskRef)(allTasksOf(plan), identifier)?.id;
 }
 
 // src/utils/session.ts
@@ -1863,7 +1858,8 @@ async function handleRun(subArgs, injectedApi) {
   const onBlocked = hasFlag(subArgs, "--stash") ? "stash" : hasFlag(subArgs, "--without-isolation") ? "shared" : void 0;
   await followExecution(api, sessionId, async () => {
     try {
-      await api.executePlan(sessionId);
+      const started = await api.executePlan(sessionId);
+      if (started.message) console.error(started.message);
     } catch (err) {
       console.error(`Failed to start execution: ${err.message}`);
       process.exit(1);
@@ -2808,7 +2804,7 @@ function servedApprovalRecord(plan) {
 }
 
 // src/commands/stop.ts
-async function handleStop(subArgs) {
+async function handleStop(subArgs, injectedApi) {
   if (subArgs.includes("--server") || subArgs[0] === "server") {
     const stopped = await stopDaemon(resolvePort(subArgs));
     if (!stopped) process.exit(1);
@@ -2825,10 +2821,9 @@ async function handleStop(subArgs) {
     sessionId = last.sessionId;
     console.error(`Stopping last session: ${sessionId}`);
   }
-  const port = await ensureDaemon(resolvePort(subArgs));
-  const api = new ApiClient(port);
-  await api.stopExecution(sessionId);
-  console.log("Execution stopped.");
+  const api = await connect(subArgs, injectedApi);
+  const { message } = await api.stopExecution(sessionId);
+  console.log(message ?? "Execution stopped.");
 }
 
 // src/commands/web.ts
@@ -3243,7 +3238,7 @@ var PAST_TENSE = {
   retry: "Task retried.",
   cancel: "Task cancelled."
 };
-async function withResolvedTask(subArgs, usage, injectedApi, run) {
+async function sessionAndRef(subArgs, usage, injectedApi) {
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   let sessionId = flag(subArgs, "--session-id");
   if (!sessionId) {
@@ -3254,12 +3249,20 @@ async function withResolvedTask(subArgs, usage, injectedApi, run) {
     }
     sessionId = last.sessionId;
   }
-  const identifier = positionals(subArgs)[0];
-  if (!identifier) {
+  const ref = positionals(subArgs)[0];
+  if (!ref) {
     console.error(usage);
     process.exit(1);
   }
   const api = injectedApi || new ApiClient(await ensureDaemon(resolvePort(subArgs)));
+  return { api, sessionId, ref, workspace };
+}
+async function withTaskRef(subArgs, usage, injectedApi, run) {
+  const { api, sessionId, ref } = await sessionAndRef(subArgs, usage, injectedApi);
+  await run(api, sessionId, ref);
+}
+async function withResolvedTask(subArgs, usage, injectedApi, run) {
+  const { api, sessionId, ref, workspace } = await sessionAndRef(subArgs, usage, injectedApi);
   let plan;
   try {
     plan = (await api.getSession(sessionId, workspace)).plan;
@@ -3267,35 +3270,37 @@ async function withResolvedTask(subArgs, usage, injectedApi, run) {
     console.error(`Failed to load session: ${err.message}`);
     process.exit(1);
   }
-  const taskId = resolveTaskId(plan, identifier);
+  const taskId = resolveTaskId(plan, ref);
   if (!taskId) {
-    console.error(`Task not found: "${identifier}"`);
+    console.error(`Task not found: "${ref}"`);
     process.exit(1);
   }
   await run(api, sessionId, taskId, plan);
 }
 var PASSES_GATE = /* @__PURE__ */ new Set(["run", "force-start"]);
-async function confirmPastGate(subArgs, api, sessionId, taskId, confirm2) {
-  if (hasFlag(subArgs, "--yes")) return;
-  const unmerged = await api.getMergeGate(sessionId, taskId).catch(() => []);
-  if (unmerged.length === 0) return;
+async function confirmPastGate(subArgs, api, sessionId, ref, confirm2) {
+  const unmerged = await api.getMergeGate(sessionId, ref).catch(() => []);
+  if (unmerged.length === 0) return false;
+  if (hasFlag(subArgs, "--yes")) return true;
   const question = `${(0, import_core21.pastGateConfirmation)(unmerged.map((d) => (0, import_core21.titledTaskRef)(d)))} Start it anyway?`;
   if (!await confirm2(question)) fail("Not started: nothing was changed. Pass --yes to start it without a prompt.");
+  return true;
 }
 function makeHandler(action, command = action) {
   const yes = PASSES_GATE.has(action) ? " [--yes]" : "";
   return async function handle(subArgs, injectedApi, confirm2 = askYesNo) {
-    await withResolvedTask(
+    await withTaskRef(
       subArgs,
       `Usage: ordewell ${command} <task-id-or-order> [--session-id <id>] [--workspace /path]${yes}`,
       injectedApi,
-      async (api, sessionId, taskId) => {
-        if (PASSES_GATE.has(action)) await confirmPastGate(subArgs, api, sessionId, taskId, confirm2);
+      async (api, sessionId, ref) => {
+        const pastGate = PASSES_GATE.has(action) ? await confirmPastGate(subArgs, api, sessionId, ref, confirm2) : false;
+        const control = pastGate && action === "run" ? "force-start" : action;
         try {
-          const { queued } = await api.taskControl(sessionId, taskId, action);
-          console.log(queued ?? PAST_TENSE[action]);
+          const { message, queued } = await api.taskControl(sessionId, ref, control);
+          console.log(message ?? queued ?? PAST_TENSE[control]);
         } catch (err) {
-          console.error(`Failed to ${action} task: ${err.message}`);
+          console.error(`Failed to ${control} task: ${err.message}`);
           process.exit(1);
         }
       }
@@ -3309,10 +3314,10 @@ async function handleContinue(subArgs, injectedApi) {
     console.error(usage);
     process.exit(1);
   }
-  await withResolvedTask(subArgs, usage, injectedApi, async (api, sessionId, taskId) => {
+  await withTaskRef(subArgs, usage, injectedApi, async (api, sessionId, ref) => {
     try {
-      await api.continueTask(sessionId, taskId, message);
-      console.log("Task continued.");
+      const sent = await api.continueTask(sessionId, ref, message);
+      console.log(sent.message ?? "Task continued.");
     } catch (err) {
       console.error(`Failed to continue task: ${err.message}`);
       process.exit(1);
@@ -3332,11 +3337,10 @@ async function handleCheckpoint(subArgs, injectedApi) {
 ${usage}`);
     process.exit(1);
   }
-  await withResolvedTask(subArgs, usage, injectedApi, async (api, sessionId, taskId) => {
+  await withTaskRef(subArgs, usage, injectedApi, async (api, sessionId, ref) => {
     try {
-      if (answer === "approve") await api.approveTaskCheckpoint(sessionId, taskId);
-      else await api.rejectTaskCheckpoint(sessionId, taskId, reason || void 0);
-      console.log(answer === "approve" ? "Checkpoint approved." : "Checkpoint rejected.");
+      const sent = answer === "approve" ? await api.approveTaskCheckpoint(sessionId, ref) : await api.rejectTaskCheckpoint(sessionId, ref, reason || void 0);
+      console.log(sent.message ?? (answer === "approve" ? "Checkpoint approved." : "Checkpoint rejected."));
     } catch (err) {
       console.error(`Failed to ${answer} checkpoint: ${err.message}`);
       process.exit(1);
@@ -3350,14 +3354,14 @@ var handleCancel = makeHandler("cancel");
 
 // src/commands/mark-complete.ts
 async function handleMarkComplete(subArgs, api) {
-  await withResolvedTask(
+  await withTaskRef(
     subArgs,
     "Usage: ordewell mark-complete <task-id-or-order> [--session-id <id>]",
     api,
-    async (client, sessionId, taskId) => {
+    async (client, sessionId, ref) => {
       try {
-        await client.markTaskComplete(sessionId, taskId);
-        console.log("Task marked complete.");
+        const done = await client.markTaskComplete(sessionId, ref);
+        console.log(done.message ?? "Task marked complete.");
       } catch (err) {
         console.error(`Failed to mark task complete: ${err.message}`);
         process.exit(1);
@@ -3366,14 +3370,14 @@ async function handleMarkComplete(subArgs, api) {
   );
 }
 async function handleUncomplete(subArgs, api) {
-  await withResolvedTask(
+  await withTaskRef(
     subArgs,
     "Usage: ordewell uncomplete <task-id-or-order> [--session-id <id>]",
     api,
-    async (client, sessionId, taskId) => {
+    async (client, sessionId, ref) => {
       try {
-        await client.markTaskIncomplete(sessionId, taskId);
-        console.log("Task marked not done.");
+        const done = await client.markTaskIncomplete(sessionId, ref);
+        console.log(done.message ?? "Task marked not done.");
       } catch (err) {
         console.error(`Failed to mark task not done: ${err.message}`);
         process.exit(1);
@@ -3382,14 +3386,14 @@ async function handleUncomplete(subArgs, api) {
   );
 }
 async function handleSkip(subArgs, api) {
-  await withResolvedTask(
+  await withTaskRef(
     subArgs,
     "Usage: ordewell skip <task-id-or-order> [--reason <text>] [--session-id <id>]",
     api,
-    async (client, sessionId, taskId) => {
+    async (client, sessionId, ref) => {
       try {
-        await client.skipTask(sessionId, taskId, flag(subArgs, "--reason"));
-        console.log("Task skipped: none of its work lands, and the tasks that depend on it go ahead without it once the work it waited on is done.");
+        const done = await client.skipTask(sessionId, ref, flag(subArgs, "--reason"));
+        console.log(done.message ?? "Task skipped: none of its work lands, and the tasks that depend on it go ahead without it once the work it waited on is done.");
       } catch (err) {
         console.error(`Failed to skip task: ${err.message}`);
         process.exit(1);
@@ -3674,9 +3678,6 @@ function handoffArrived(state, handoff) {
   );
   return state.overlay ? told : { ...told, overlay: { kind: "handoff", index: 0, diff: null } };
 }
-function withDeferral(fresh, known) {
-  return known?.deferredTo && handoffBranch(known) === handoffBranch(fresh) ? { ...fresh, deferredTo: known.deferredTo } : fresh;
-}
 function runHandoffAction(state, id) {
   const { sessionId } = state;
   const handoff = currentHandoff(state);
@@ -3745,8 +3746,7 @@ function confirmedHandoff(state, kind) {
     sessionId,
     branch: handoffBranch(handoff),
     ...(0, import_core10.isRepoGroup)(handoff) ? { group: true } : {},
-    ...repaired.length > 0 ? { repaired } : {},
-    ...midRun(state) ? { midRun: true } : {}
+    ...repaired.length > 0 ? { repaired } : {}
   } : { type: "isolationDiscard", sessionId, branch: handoffBranch(handoff) };
   return { state: closed, effects: [effect] };
 }
@@ -4147,21 +4147,23 @@ async function handleApprove(subArgs, injectedApi) {
   const sessionId = resolveSessionId(subArgs);
   const api = await connect(subArgs, injectedApi);
   await followExecution(api, sessionId, async () => {
+    let approved;
     try {
-      await api.approveReview(sessionId);
+      approved = await api.approveReview(sessionId);
     } catch (err) {
       console.error(`Failed to approve: ${err.message}`);
       process.exit(1);
     }
-    console.error("Plan approved: continuing execution.");
+    console.error(approved.message ?? "Plan approved: continuing execution.");
   });
 }
 
 // src/commands/task-assign.ts
 var import_core29 = require("@ordewell/core");
-var import_plan_utils = require("@ordewell/core/plan-utils");
+var import_plan_utils3 = require("@ordewell/core/plan-utils");
 
 // src/tui/taskAssignment.ts
+var import_plan_utils = require("@ordewell/core/plan-utils");
 function runnerServes(runner, model) {
   return !runner || !model.runners || model.runners.length === 0 || model.runners.includes(runner);
 }
@@ -4184,7 +4186,7 @@ function effortsForTask(models, task) {
 }
 function assignedModelFor(model, currentEffort) {
   const variants = model.variants ?? [];
-  const thinkingEffort = variants.some((variant) => variant.id === currentEffort) ? currentEffort : void 0;
+  const thinkingEffort = (0, import_plan_utils.clampThinkingEffort)(currentEffort, variants);
   return {
     modelId: model.id,
     modelLabel: model.label,
@@ -4198,6 +4200,7 @@ function modesForTask(modesByRunner, task) {
 }
 
 // src/tui/state.ts
+var import_plan_utils2 = require("@ordewell/core/plan-utils");
 var import_core28 = require("@ordewell/core");
 
 // src/tui/editor.ts
@@ -4394,12 +4397,7 @@ function resumesTask(task) {
   return task?.status === "awaiting_user" && task.awaitingReason === "usage-limit";
 }
 function findTask(tasks, id) {
-  for (const task of tasks) {
-    if (task.id === id) return task;
-    const found = findTask(task.subtasks ?? [], id);
-    if (found) return found;
-  }
-  return void 0;
+  return (0, import_plan_utils2.taskPlacement)(tasks, id)?.task;
 }
 function refFor(state, task) {
   return (0, import_core28.taskRefOf)(state.tasks, task.id) ?? (0, import_core28.taskRef)(task);
@@ -4485,8 +4483,8 @@ function initialState(overrides = {}) {
 }
 
 // src/commands/task-assign.ts
-var refOf = (tasks, task) => (0, import_plan_utils.taskRefOf)(tasks, task.id) ?? (0, import_plan_utils.taskRef)(task);
-var namedOf = (tasks, task) => (0, import_plan_utils.titledTaskRefOf)(tasks, task.id) ?? (0, import_plan_utils.titledTaskRef)(task);
+var refOf = (tasks, task) => (0, import_plan_utils3.taskRefOf)(tasks, task.id) ?? (0, import_plan_utils3.taskRef)(task);
+var namedOf = (tasks, task) => (0, import_plan_utils3.titledTaskRefOf)(tasks, task.id) ?? (0, import_plan_utils3.titledTaskRef)(task);
 async function withTask(subArgs, usage, injectedApi, run, { joinValue = false } = {}) {
   await withResolvedTask(subArgs, usage, injectedApi, async (api, sessionId, taskId, plan) => {
     const tasks = taskViews(plan);
@@ -4548,8 +4546,9 @@ Model \xB7 ${namedOf(tasks, task)}${task.assignedRunner ? ` (${task.assignedRunn
     const assignedModel = assignedModelFor(model, task.assignedModel?.thinkingEffort);
     await api.updateTask(sessionId, task.id, { assignedModel });
     console.log(`Task ${refOf(tasks, task)} model set to ${model.label}.`);
-    if (task.assignedModel?.thinkingEffort && !assignedModel.thinkingEffort) {
-      console.log(`  ${model.label} does not expose "${task.assignedModel.thinkingEffort}", so the effort went back to the runner default.`);
+    const was = task.assignedModel?.thinkingEffort;
+    if (was && assignedModel.thinkingEffort !== was) {
+      console.log(`  ${model.label} does not expose "${was}", so the effort is now ${assignedModel.thinkingEffort ? `"${assignedModel.thinkingEffort}", its nearest level` : "the runner default"}.`);
     }
   });
 }
@@ -4625,15 +4624,16 @@ Mode \xB7 ${namedOf(tasks, task)}${task.assignedRunner ? ` (${task.assignedRunne
 var DEPS_USAGE = "Usage: ordewell task-deps <task-id-or-order> [<id,id,\u2026>|none] [--session-id <id>]";
 async function handleTaskDeps(subArgs, injectedApi) {
   await withTask(subArgs, DEPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
-    const candidates = (0, import_plan_utils.dependencyCandidates)(tasks, task.id);
+    const candidates = (0, import_plan_utils3.dependencyCandidates)(tasks, task.id);
+    const held = task.dependencies.filter((id) => !candidates.some((c) => c.id === id)).flatMap((id) => (0, import_plan_utils3.resolveTaskRef)(tasks, id) ?? []);
     if (!value) {
       console.log(`
 Dependencies \xB7 ${namedOf(tasks, task)}
 `);
       if (candidates.length === 0) {
-        console.log(`  Nothing runs before ${refOf(tasks, task)}, so it has no possible dependencies.`);
+        console.log(`  No earlier siblings to offer as dependencies for ${refOf(tasks, task)}.`);
       }
-      for (const c of candidates) {
+      for (const c of [...candidates, ...held]) {
         const chosen = task.dependencies.includes(c.id);
         console.log(`  ${chosen ? "*" : " "} ${c.id}  ${namedOf(tasks, c)}${c.status === "completed" ? "  (already completed)" : ""}`);
       }
@@ -4641,8 +4641,8 @@ Dependencies \xB7 ${namedOf(tasks, task)}
   * = current. ${DEPS_USAGE}`);
       return;
     }
-    const dependencies = value.toLowerCase() === "none" ? [] : value.split(",").map((s) => s.trim()).filter(Boolean).map((token) => tasks.find((t) => t.id === token || String(t.order) === token)?.id ?? token);
-    const check = (0, import_plan_utils.canSetDependencies)(tasks, task.id, dependencies);
+    const dependencies = value.toLowerCase() === "none" ? [] : value.split(",").map((s) => s.trim()).filter(Boolean).map((token) => (0, import_plan_utils3.resolveUserTaskRef)(tasks, token)?.id ?? token);
+    const check = (0, import_plan_utils3.canSetDependencies)(tasks, task.id, dependencies);
     if (!check.ok) fail(check.error ?? "Invalid dependencies.");
     await api.updateTask(sessionId, task.id, { dependencies });
     console.log(dependencies.length > 0 ? `Task ${refOf(tasks, task)} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task ${refOf(tasks, task)} no longer depends on anything.`);
@@ -4871,7 +4871,7 @@ var import_core33 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
 var import_core31 = require("@ordewell/core");
-var import_plan_utils2 = require("@ordewell/core/plan-utils");
+var import_plan_utils4 = require("@ordewell/core/plan-utils");
 var DEFAULT_EFFORT = "__runner_default__";
 function picker(title, items, action, extra = {}) {
   return { title, items, filter: "", index: 0, multi: false, chosen: [], filterable: false, action, ...extra };
@@ -4980,7 +4980,7 @@ function pickerItemsFor(state, action) {
     }));
   }
   if (action.kind === "set-task-deps") {
-    return (0, import_plan_utils2.dependencyCandidates)(state.tasks, action.taskId).map((candidate) => ({
+    return (0, import_plan_utils4.dependencyCandidates)(state.tasks, action.taskId).map((candidate) => ({
       id: candidate.id,
       label: titledRefFor(state, candidate),
       detail: candidate.status === "completed" ? "already completed" : void 0
@@ -6651,12 +6651,7 @@ function openTaskView(state, sessionId, taskId) {
   if (!task) return step(say(state, "system", `No task ${taskId} in this plan.`));
   const taskView = {
     taskId,
-    view: import_core40.EMPTY_TASK_LOG,
-    attempts: [],
-    attempt: 0,
-    pending: [],
-    loaded: false,
-    followLatest: true,
+    ...import_core40.EMPTY_TASK_LOG_FOLLOW,
     queuedIndex: null
   };
   return step({ ...state, taskView, focus: "chat", scroll: 0 }, [{ type: "openTaskLog", sessionId, taskId }]);
@@ -6672,67 +6667,35 @@ function clampQueueIndex(tv) {
   const max = tv.view.queued.length - 1;
   return tv.queuedIndex <= max ? tv : { ...tv, queuedIndex: max };
 }
-function applyLive(tv, attempt, events) {
-  if (attempt <= 0) return tv;
-  let next = tv;
-  if (attempt > next.attempt) {
-    if (!next.followLatest) {
-      return next.attempts.includes(attempt) ? next : { ...next, attempts: [...next.attempts, attempt] };
-    }
-    next = {
-      ...next,
-      view: import_core40.EMPTY_TASK_LOG,
-      attempt,
-      attempts: next.attempts.includes(attempt) ? next.attempts : [...next.attempts, attempt]
-    };
-  }
-  if (attempt < next.attempt) return next;
-  return clampQueueIndex({ ...next, view: events.reduce(import_core40.reduceTaskLog, next.view) });
-}
 function taskLogAbandoned(state) {
   const tv = state.taskView;
   if (!tv || tv.loaded) return state;
-  let next = { ...tv, pending: [], loaded: true };
-  for (const batch of tv.pending) next = applyLive(next, batch.attempt, batch.events);
-  return { ...state, taskView: clampQueueIndex(next) };
+  return { ...state, taskView: clampQueueIndex({ ...tv, ...(0, import_core40.followTaskLog)(tv, { type: "loaded", attempt: tv.attempt, events: [], abandoned: true }) }) };
 }
 function taskLogArrived(state, action) {
   const tv = state.taskView;
   if (!tv || tv.taskId !== action.taskId) return state;
-  if (!tv.loaded) {
-    return { ...state, taskView: { ...tv, pending: [...tv.pending, { attempt: action.attempt, events: action.events }] } };
-  }
-  return { ...state, taskView: applyLive(tv, action.attempt, action.events) };
+  const next = (0, import_core40.followTaskLog)(tv, { ...action, type: "live" });
+  return { ...state, taskView: next === tv ? tv : clampQueueIndex({ ...tv, ...next }) };
 }
 function announceApprovals(state, action) {
   if (state.taskView?.taskId === action.taskId) return state;
   const task = findTask(state.tasks, action.taskId);
-  const way = task ? `tab to the plan, select task ${task.order} and press enter (or /open ${task.order})` : "tab to the plan, select it and press enter";
-  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" && !event.decided ? say(s, "system", `Task ${task?.order ?? "?"} waits for approval: ${(0, import_core40.runnerToolSubject)(event.tool, event.args)}: ${way}, then ctrl-y allows or ctrl-g denies`) : s, state);
+  const way = task ? `tab to the plan, select task ${refFor(state, task)} and press enter (or /open ${refFor(state, task)})` : "tab to the plan, select it and press enter";
+  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" && !event.decided ? say(s, "system", `Task ${task ? refFor(state, task) : "?"} waits for approval: ${(0, import_core40.runnerToolSubject)(event.tool, event.args)}: ${way}, then ctrl-y allows or ctrl-g denies`) : s, state);
   return spoken !== state ? { ...spoken, scroll: state.scroll } : spoken;
 }
 function announceCheckpoint(state, action) {
   const task = findTask(state.tasks, action.taskId) ?? state.tasks.find((t) => t.title === action.title);
-  const label = task ? `Task ${task.order}` : action.title;
-  const where = task ? `tab to the plan, select task ${task.order} and press enter (or /open ${task.order}) to answer` : "tab to the plan, select it and press enter to answer";
+  const label = task ? `Task ${refFor(state, task)}` : action.title;
+  const where = task ? `tab to the plan, select task ${refFor(state, task)} and press enter (or /open ${refFor(state, task)}) to answer` : "tab to the plan, select it and press enter to answer";
   const spoken = say(state, "system", `${label} asks: ${(0, import_core40.truncateCheckpointSummary)(action.summary)}: ${where}`);
   return { ...spoken, scroll: state.scroll };
 }
 function taskLogLoaded(state, action) {
   const tv = state.taskView;
   if (!tv || tv.taskId !== action.taskId) return state;
-  const loaded = action.attempt >= 1 ? {
-    ...tv,
-    view: (0, import_core40.replayTaskLog)(action.events),
-    attempts: action.attempts ?? tv.attempts,
-    attempt: action.attempt
-  } : { ...tv, attempts: action.attempts ?? tv.attempts };
-  let next = { ...loaded, pending: [], loaded: true };
-  for (const batch of tv.pending) {
-    if (batch.attempt === action.attempt) continue;
-    next = applyLive(next, batch.attempt, batch.events);
-  }
-  return { ...state, taskView: clampQueueIndex(next) };
+  return { ...state, taskView: clampQueueIndex({ ...tv, ...(0, import_core40.followTaskLog)(tv, { ...action, type: "loaded" }) }) };
 }
 function answerApproval(state, tv, sessionId, decision) {
   const approval = waitingApproval(tv);
@@ -6776,7 +6739,7 @@ function handleTaskViewKey(state, key) {
   const tv = state.taskView;
   if (!tv || !state.sessionId) return null;
   if (key.name === "alt-left" || key.name === "alt-right") {
-    const index = tv.attempts.indexOf(tv.attempt);
+    const index = tv.attempts.indexOf(tv.loadingAttempt ?? tv.attempt);
     if (index < 0) return null;
     const target = key.name === "alt-left" ? index - 1 : index + 1;
     const attempt = tv.attempts[target];
@@ -6784,7 +6747,7 @@ function handleTaskViewKey(state, key) {
       return step(say(state, "system", target < 0 ? "This is the first attempt." : "This is the latest attempt."));
     }
     return step(
-      { ...state, taskView: { ...tv, followLatest: false } },
+      { ...state, taskView: { ...tv, ...(0, import_core40.followTaskLog)(tv, { type: "picked", attempt }) } },
       [{ type: "loadTaskAttempt", sessionId: state.sessionId, taskId: tv.taskId, attempt }]
     );
   }
@@ -6816,7 +6779,7 @@ function handleTaskViewKey(state, key) {
 
 // src/tui/reducers/taskEdits.ts
 var import_core41 = require("@ordewell/core");
-var import_plan_utils3 = require("@ordewell/core/plan-utils");
+var import_plan_utils5 = require("@ordewell/core/plan-utils");
 function openTaskRunnerPicker(state, task) {
   if (task.type !== "ai") return fail3(state, "Manual tasks do not run on an executor, so they have no runner.");
   const action = { kind: "set-task-runner", taskId: task.id };
@@ -6838,7 +6801,7 @@ function confirmRemoveTask(state, task) {
     overlay: {
       kind: "confirm",
       title: `Remove ${titledRefFor(state, task)}?`,
-      message: (0, import_plan_utils3.dependentsNotice)((0, import_plan_utils3.dependentsOf)(state.tasks, task.id)) ?? "This cannot be undone.",
+      message: (0, import_plan_utils5.dependentsNotice)((0, import_plan_utils5.dependentsOf)(state.tasks, task.id), state.tasks) ?? "This cannot be undone.",
       action: { kind: "remove-task", taskId: task.id }
     }
   });
@@ -6862,7 +6825,7 @@ function confirmForceStartPastGate(state, task) {
     overlay: {
       kind: "confirm",
       title: `Force start ${titledRefFor(state, task)}?`,
-      message: (0, import_plan_utils3.pastGateConfirmation)((0, import_plan_utils3.titledRefs)(task.mergeGate ?? [], state.tasks), "It"),
+      message: (0, import_plan_utils5.pastGateConfirmation)((0, import_plan_utils5.titledRefs)(task.mergeGate ?? [], state.tasks), "It"),
       action: { kind: "force-start-gated", taskId: task.id }
     }
   });
@@ -6870,16 +6833,16 @@ function confirmForceStartPastGate(state, task) {
 function openTaskDepsPicker(state, task) {
   const action = { kind: "set-task-deps", taskId: task.id };
   const items = pickerItemsFor(state, action);
-  if (items.length === 0) return fail3(state, `Nothing runs before ${refFor(state, task)}, so it has no possible dependencies.`);
+  if (items.length === 0) return fail3(state, `No earlier siblings to offer as dependencies for ${refFor(state, task)}.`);
   return step({
     ...state,
     overlay: {
       kind: "picker",
       picker: picker(`Depends on \xB7 ${titledRefFor(state, task)}`, items, action, {
-        hint: "Only tasks earlier in the plan can be dependencies.",
+        hint: "Offers earlier siblings; existing dependencies are kept.",
         multi: true,
         filterable: true,
-        chosen: task.dependencies.filter((id) => items.some((i) => i.id === id))
+        chosen: task.dependencies
       })
     }
   });
@@ -7097,14 +7060,7 @@ function taskCommand(state, token, run) {
   });
 }
 function resolveTaskId2(state, token) {
-  const byId = findTask(state.tasks, token);
-  if (byId) return byId.id;
-  const order = Number(token);
-  if (Number.isInteger(order)) {
-    const byOrder = state.tasks.find((t) => t.order === order);
-    if (byOrder) return byOrder.id;
-  }
-  return null;
+  return (0, import_plan_utils5.resolveUserTaskRef)(state.tasks, token)?.id ?? null;
 }
 
 // src/tui/reducers/planPane.ts
@@ -7349,28 +7305,6 @@ function foldRun(state, input) {
   const run = (0, import_core44.reduceRun)(state.run, input);
   return run === state.run ? state : withRun(state, run);
 }
-function mapRunTasks(tasks, map) {
-  return tasks.map((task) => ({ ...map(task), subtasks: mapRunTasks(task.subtasks, map) }));
-}
-function applyIsolationRecord(state, plan) {
-  const record = isolationOfPlan(plan);
-  if (!record) return state;
-  const { run } = state;
-  return withRun(state, {
-    ...run,
-    tasks: mapRunTasks(run.tasks, (task) => ({ ...task, isolation: record.tasks[task.id] ?? { state: "none" } })),
-    handoff: withDeferral(record.handoff, run.handoff)
-  });
-}
-function clearRunIsolation(run) {
-  return {
-    ...run,
-    handoff: null,
-    runMerge: null,
-    mergeResult: null,
-    tasks: mapRunTasks(run.tasks, ({ isolation: _dropped, ...task }) => task)
-  };
-}
 function applySettings(state, settings) {
   return {
     ...state,
@@ -8241,6 +8175,24 @@ function reduceAction(state, action) {
     // tasks — may carry over into this.
     case "sessionStarted":
       return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }, import_core49.EMPTY_RUN));
+    // A loaded session is a different one: the turn the old one had out, the
+    // prompts held behind it and a stop armed against it are not this one's.
+    // (`sessionStarted` cannot reset them: `startConversation` dispatches it
+    // as its own turn begins.)
+    case "sessionLoaded":
+      return step(withRun({
+        ...state,
+        sessionId: action.sessionId,
+        goal: action.goal,
+        taskView: null,
+        planner: "idle",
+        turnGate: import_core49.NO_TURN,
+        pendingApprovals: [],
+        queuedPrompts: import_core49.EMPTY_HOLD,
+        stopArmed: false,
+        forceSendPending: null,
+        overlay: state.overlay?.kind === "approval" ? null : state.overlay
+      }, import_core49.EMPTY_RUN));
     // The daemon registers a session only once planning succeeds; when it does
     // not, holding on to the id would send every next message to a session the
     // server never had.
@@ -8250,6 +8202,7 @@ function reduceAction(state, action) {
         sessionId: null,
         goal: "",
         taskView: null,
+        turnGate: import_core49.NO_TURN,
         pendingApprovals: [],
         queuedPrompts: import_core49.EMPTY_HOLD,
         stopArmed: false,
@@ -8263,6 +8216,9 @@ function reduceAction(state, action) {
     case "chatRestored":
       if (stale(state, action.sessionId)) return step(state);
       return step({ ...state, conversation: (0, import_core49.fromTranscript)(action.history, action.researchLog, action.plannerUsage, action.pendingTurns), scroll: 0 });
+    case "planRefreshed":
+      if (stale(state, action.sessionId)) return step(state);
+      return step(showPlan(state, action.plan));
     case "planUpdated": {
       if (stale(state, action.sessionId)) return step(state);
       const settled = { ...showPlan(state, action.plan), planner: "idle" };
@@ -8349,10 +8305,16 @@ function reduceAction(state, action) {
       if (stale(state, action.sessionId)) return step(state);
       return step(showDiff(state, action.diff));
     }
-    case "runCleared": {
+    // What Merge all did, folded the way the Session says it: a merge that
+    // leaves the run going keeps the marks (ADR-0020), and only `run_closed`
+    // takes them (below).
+    case "isolationMerged": {
       if (stale(state, action.sessionId)) return step(state);
-      const overlay = state.overlay?.kind === "handoff" ? null : state.overlay;
-      return step({ ...withRun(state, clearRunIsolation(state.run)), overlay });
+      return step(withoutHandoffOverlay(foldRun(state, { type: "isolation_merge", result: action.result })));
+    }
+    case "runClosed": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(withoutHandoffOverlay(foldRun(state, { type: "run_closed" })));
     }
     case "executionComplete": {
       if (stale(state, action.sessionId)) return step(state);
@@ -8412,9 +8374,9 @@ function reduceAction(state, action) {
       if (stale(state, action.sessionId)) return step(state);
       if (action.pick !== void 0) return pickRewindTarget({ ...state, rewindTargets: action.targets }, action.pick);
       return step(refillPicker({ ...state, rewindTargets: action.targets }, ["rewind"]));
-    // A fork holds no run, whatever the session it came from was doing — the
-    // original keeps its run, and its events are stale from here on. Its plan
-    // arrives next, onto an empty run view.
+    // A fork holds no run and no turn, whatever the session it came from was
+    // doing — the original keeps both, and its events are stale from here on.
+    // Its plan arrives next, onto an empty run view.
     case "sessionForked":
       return step(withRun({
         ...state,
@@ -8423,6 +8385,7 @@ function reduceAction(state, action) {
         taskView: null,
         status: "idle",
         planner: "idle",
+        turnGate: import_core49.NO_TURN,
         planApproved: false,
         pendingApprovals: [],
         queuedPrompts: import_core49.EMPTY_HOLD,
@@ -8488,8 +8451,11 @@ function reduceAction(state, action) {
       return step(disarmStop(state));
   }
 }
+function withoutHandoffOverlay(state) {
+  return state.handoff || state.overlay?.kind !== "handoff" ? state : { ...state, overlay: null };
+}
 function showPlan(state, plan) {
-  const folded = applyIsolationRecord(foldRun(state, planSnapshot(plan)), plan);
+  const folded = foldRun(state, planSnapshot(plan));
   const { tasks } = folded;
   const expandedTaskId = state.expandedTaskId && findTask(tasks, state.expandedTaskId) ? state.expandedTaskId : null;
   const next = {
@@ -8847,6 +8813,7 @@ function createInbound(dispatch, sessionId) {
   const delivered = new Delivered(256);
   const copies = new Copies(64);
   const shown = new WindowSet(64);
+  const shownTexts = new WindowSet(64);
   const pending = new WindowSet(16);
   const DELTA_DEBOUNCE_MS = 75;
   let held = null;
@@ -8875,7 +8842,8 @@ function createInbound(dispatch, sessionId) {
     timer = setTimeout(flush, DELTA_DEBOUNCE_MS);
   };
   const showReply = (message) => {
-    shown.add(message.content);
+    shown.add(replyKey(message.content, message.timestamp));
+    shownTexts.add(message.content);
     dispatch({ type: "sessionMessage", message, sessionId });
   };
   const fresh = (id, event) => {
@@ -8947,14 +8915,15 @@ function createInbound(dispatch, sessionId) {
       const id = `e${++subscription}`;
       return (event) => receive("execution", id, event);
     },
-    backfill: (content, timestamp) => {
-      if (shown.has(content)) return;
-      const message = { type: "planner_message", content, timestamp: timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+    backfill: (content, timestamp, runs) => {
+      if (timestamp ? shown.has(replyKey(content, timestamp)) : shownTexts.has(content)) return;
+      const message = { type: "planner_message", content, timestamp: timestamp ?? (/* @__PURE__ */ new Date()).toISOString(), ...runs ? { runs } : {} };
       showReply(message);
       if (timestamp) pending.add(replyKey(content, timestamp));
     },
     redrawn: (content, timestamp) => {
-      shown.add(content);
+      shown.add(replyKey(content, timestamp));
+      shownTexts.add(content);
       pending.add(replyKey(content, timestamp));
     },
     flush,
@@ -9026,7 +8995,7 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     // its only reader, and the reducer drops it unless that view is open on
     // this task. The run's watcher itself does nothing with it.
     case "task_log":
-      dispatch({ type: "taskLog", taskId: String(event.taskId), attempt: event.attempt, events: event.events, sessionId });
+      dispatch({ type: "taskLog", taskId: String(event.taskId), attempt: event.attempt, events: event.events, position: stampOf(event) ?? void 0, sessionId });
       return;
     case "task_updated":
       dispatch({ type: "taskUpdated", taskId: String(event.taskId), changes: event.changes, sessionId });
@@ -9036,10 +9005,13 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     // does with it.
     case "task_output":
       return;
-    // Its asker already has the words, from the merge request itself; a
-    // viewer that did not ask still has to drop a run that is gone.
+    // Its asker already has the words, from the merge request itself. Whether
+    // the merge ended the run is the Session's to say, in `run_closed`.
     case "isolation_merge":
-      if (event.result.outcome === "merged") dispatch({ type: "runCleared", sessionId });
+      dispatch({ type: "isolationMerged", result: event.result, sessionId });
+      return;
+    case "run_closed":
+      dispatch({ type: "runClosed", sessionId });
       return;
     default: {
       const unhandled = event;
@@ -9136,9 +9108,10 @@ async function perform(effect, deps) {
     case "execute":
       await withExecutionStream(deps, effect.sessionId, () => api.executePlan(effect.sessionId));
       return;
+    // The seam keeps its own line of a Stop in the timeline and the stream
+    // announces the run's end, so this adds none (ADR-0029).
     case "stopExecution":
       await api.stopExecution(effect.sessionId);
-      dispatch({ type: "notice", message: "Execution stopped." });
       return;
     case "cancelPlanning": {
       const { cancelled } = await api.cancelPlanning(effect.sessionId);
@@ -9156,8 +9129,7 @@ async function perform(effect, deps) {
     case "taskAction": {
       const { sessionId, taskId, action } = effect;
       if (action === "cancel-resume") {
-        const { cancelled } = await api.cancelResume(sessionId, taskId);
-        dispatch({ type: "notice", message: cancelled ? "Resume cancelled: retry the task once the limit resets." : "That task had no resume scheduled." });
+        await api.cancelResume(sessionId, taskId);
         await refreshPlan(deps, sessionId);
         return;
       }
@@ -9215,19 +9187,19 @@ async function perform(effect, deps) {
     // The saved log is read off disk (ADR-0018, P1) so the view opens with the
     // task's history; the live `task_log` stream then catches it up in place.
     case "openTaskLog": {
-      const attempts = await api.getTaskLogAttempts(effect.sessionId, effect.taskId, workspace);
+      const { attempts, position } = await api.getTaskLogAttempts(effect.sessionId, effect.taskId, workspace);
       if (attempts.length === 0) {
-        dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempts: [], attempt: 0, events: [], sessionId: effect.sessionId });
+        dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempts: [], attempt: 0, events: [], position, sessionId: effect.sessionId });
         return;
       }
       const attempt = attempts[attempts.length - 1];
-      const events = await api.getTaskLog(effect.sessionId, effect.taskId, attempt, workspace);
-      dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempts, attempt, events, sessionId: effect.sessionId });
+      const log = await api.getTaskLog(effect.sessionId, effect.taskId, attempt, workspace);
+      dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempts, ...log, sessionId: effect.sessionId });
       return;
     }
     case "loadTaskAttempt": {
-      const events = await api.getTaskLog(effect.sessionId, effect.taskId, effect.attempt, workspace);
-      dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempt: effect.attempt, events, sessionId: effect.sessionId });
+      const log = await api.getTaskLog(effect.sessionId, effect.taskId, effect.attempt, workspace);
+      dispatch({ type: "taskLogLoaded", taskId: effect.taskId, ...log, sessionId: effect.sessionId });
       return;
     }
     // The daemon queues the message (or delivers it to a waiting task) and
@@ -9247,24 +9219,20 @@ async function perform(effect, deps) {
       await refreshPlan(deps, sessionId);
       return;
     }
-    case "removeTaskMessage": {
-      const { removed } = await api.removeQueuedTaskMessage(effect.sessionId, effect.taskId, effect.messageId);
-      if (!removed) dispatch({ type: "notice", message: "That message was already delivered to the task." });
+    // One already delivered is refused in the daemon's words.
+    case "removeTaskMessage":
+      await api.removeQueuedTaskMessage(effect.sessionId, effect.taskId, effect.messageId);
       return;
-    }
     // The task log shows the forced message at the head of the queue, then
     // the interrupt, then the turn it opens; nothing to dispatch here.
     case "forceSendTaskMessage":
       await api.forceSendTaskMessage(effect.sessionId, effect.taskId, effect.text);
       return;
-    case "forceSendQueuedTaskMessage": {
-      const { sent } = await api.forceSendQueuedTaskMessage(effect.sessionId, effect.taskId, effect.messageId);
-      if (!sent) dispatch({ type: "notice", message: "That message has already reached the runner." });
+    case "forceSendQueuedTaskMessage":
+      await api.forceSendQueuedTaskMessage(effect.sessionId, effect.taskId, effect.messageId);
       return;
-    }
     case "interruptTask":
       await api.interruptTask(effect.sessionId, effect.taskId);
-      dispatch({ type: "notice", message: "Interrupting the task\u2026" });
       return;
     case "setModel": {
       const settled = await api.updateSettings({ orchestratorModel: effect.modelId });
@@ -9404,11 +9372,12 @@ async function perform(effect, deps) {
         else unfollow(deps, effect.sessionId);
         throw err;
       }
-      const { plan, goal } = adopted2;
-      dispatch({ type: "sessionStarted", sessionId: effect.sessionId, goal });
+      const { plan, goal, run } = adopted2;
+      dispatch({ type: "sessionLoaded", sessionId: effect.sessionId, goal });
       dispatch(restoredChat(plan, effect.sessionId));
       inbound.releaseSnapshot(true);
       dispatch({ type: "planUpdated", plan, sessionId: effect.sessionId });
+      if (run) dispatch({ type: "runSnapshot", view: run, sessionId: effect.sessionId });
       dispatch({ type: "notice", message: `Loaded "${goal || effect.sessionId}".` });
       return;
     }
@@ -9469,16 +9438,15 @@ async function perform(effect, deps) {
     // A conflict or a refusal is an answer, not a fault: either way the user's
     // tree is exactly as it was, and the words say what to do next. A full
     // merge of a settled run leaves nothing to hand over — the daemon has
-    // cleared the run up; one mid-run leaves the run going (ADR-0020).
+    // cleared the run up and says so on the stream (`run_closed`); one
+    // mid-run leaves the run going (ADR-0020).
     case "isolationMerge": {
       const { ok, message } = mergeOutcome(await api.mergeRun(effect.sessionId), effect.branch, effect.group === true, effect.repaired ?? []);
-      if (ok && !effect.midRun) dispatch({ type: "runCleared", sessionId: effect.sessionId });
       dispatch({ type: ok ? "notice" : "failed", message });
       return;
     }
     case "isolationDiscard":
       await api.discardRun(effect.sessionId);
-      dispatch({ type: "runCleared", sessionId: effect.sessionId });
       dispatch({ type: "notice", message: `Discarded the run and ${effect.branch}.` });
       return;
     case "isolationCleanup":
@@ -9626,8 +9594,7 @@ async function converse(deps, sessionId, call) {
     await Promise.all([stream.ready, follow(deps, sessionId)]);
     const plan = await call();
     inbound.flush();
-    const reply = lastAssistantMessage(plan);
-    if (reply) inbound.backfill(reply.content, reply.timestamp);
+    for (const reply of turnReplies(plan)) inbound.backfill(reply.content, reply.timestamp, reply.runs);
     deps.dispatch({ type: "planUpdated", plan, sessionId });
   } finally {
     inbound.flush();
@@ -9645,17 +9612,18 @@ function restoredChat(plan, sessionId) {
     sessionId
   };
 }
-function lastAssistantMessage(plan) {
+function turnReplies(plan) {
   const history = plan?.conversationHistory ?? [];
+  const replies = [];
   for (let i = history.length - 1; i >= 0; i--) {
     const entry = history[i];
-    if ((0, import_core50.isUserMessage)(entry)) return null;
+    if ((0, import_core50.isUserMessage)(entry)) break;
     if (entry.role === "assistant" && entry.kind === void 0) {
-      const { content, timestamp } = entry;
-      return { content, ...timestamp ? { timestamp } : {} };
+      const { content, timestamp, runs } = entry;
+      replies.unshift({ content, ...timestamp ? { timestamp } : {}, ...runs ? { runs } : {} });
     }
   }
-  return null;
+  return replies;
 }
 function compactionSummary(plan) {
   const history = plan?.conversationHistory ?? [];
@@ -9663,8 +9631,9 @@ function compactionSummary(plan) {
   return entry ? { content: entry.content, ...entry.timestamp ? { timestamp: entry.timestamp } : {} } : null;
 }
 async function refreshPlan(deps, sessionId) {
-  const { plan } = await deps.api.getSession(sessionId, deps.workspace);
-  deps.dispatch({ type: "planUpdated", plan, sessionId });
+  const { plan, run } = await deps.api.getSession(sessionId, deps.workspace);
+  deps.dispatch({ type: "planRefreshed", plan, sessionId });
+  if (run) deps.dispatch({ type: "runSnapshot", view: run, sessionId });
 }
 async function loadModels(deps) {
   deps.dispatch({ type: "modelsLoaded", ...normalizeCatalog(await deps.api.getModels()) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordewell/cli",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "description": "Ordewell CLI and TUI — plan, run and verify coding-agent tasks from the terminal.",
   "license": "Apache-2.0",
   "author": "Alessandro Costanzo Ciano",
@@ -51,8 +51,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ordewell/core": "^0.10.5",
-    "@ordewell/web": "^0.10.5",
+    "@ordewell/core": "^0.10.6",
+    "@ordewell/web": "^0.10.6",
     "string-width": "^7.2.0",
     "ws": "^8.18.0"
   },