@ordewell/cli 0.10.4 → 0.10.6

package/dist/main.js

@@ -145,6 +145,7 @@ Planning:
   ordewell fork                   Continue in a copy of the conversation and its tasks
   ordewell compact                Condense the conversation into a summary (tasks are kept)
   ordewell rewind [<n>]           Fork the conversation from before message <n> (no <n>: list them)
+  ordewell resend cancel          Keep a planner turn waiting on its usage limit from going at the reset
   ordewell handoff [action]       Review, merge, discard or clean up an isolated run
 
 Tasks (<id> is an order number or a task ID):
@@ -153,7 +154,7 @@ Tasks (<id> is an order number or a task ID):
   ordewell complete <id>          Mark a task complete (alias: mark-complete)
   ordewell uncomplete <id>        Mark a completed task not done
   ordewell skip <id>              Skip a task: nothing it did lands, dependents go ahead
-  ordewell force-start <id>       Start a task now, ignoring dependencies (asks past a merge gate)
+  ordewell force-start <id>       Approve a task and start it now, or once its dependencies finish (asks past a merge gate)
   ordewell run-task <id>          Run only one task
   ordewell retry <id>             Re-run a failed task
   ordewell continue <id> <msg>    Continue a finished task in its saved runner session
@@ -548,8 +549,7 @@ var ApiClient = class _ApiClient {
           ...body ? { "Content-Type": "application/json" } : {},
           ...token ? { Authorization: (0, import_core4.bearerHeaderValue)(token) } : {}
         },
-        // Planner research on a real repository regularly exceeds two minutes.
-        // The benchmark harness uses the same 15-minute default explicitly;
+        // Planner research on a real repository regularly exceeds two minutes;
         // keep the env override for callers that need a tighter/looser bound.
         timeout: Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : DEFAULT_HTTP_TIMEOUT_MS
       };
@@ -631,70 +631,74 @@ 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) {
+    return this.call("POST", `/api/plans/${sessionId}/converse/resend/cancel`, "Cancel resend failed");
   }
   /** 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;
@@ -704,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)}` : "";
@@ -735,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) {
@@ -765,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) {
@@ -794,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
@@ -1041,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
@@ -1610,10 +1609,21 @@ var STATE_OF = {
 function reposOf(run) {
   if (Array.isArray(run.repos)) {
     const repos = run.repos.filter((r) => r && typeof r.path === "string" && typeof r.integrationBranch === "string" && typeof r.baseRef === "string");
-    return repos.length > 0 ? repos.map((r) => ({ path: String(r.path), integrationBranch: String(r.integrationBranch), baseRef: String(r.baseRef) })) : null;
+    return repos.length > 0 ? repos.map((r) => ({
+      path: String(r.path),
+      integrationBranch: String(r.integrationBranch),
+      baseRef: String(r.baseRef),
+      ...typeof r.baseBranch === "string" && r.baseBranch ? { baseBranch: r.baseBranch } : {},
+      ...r.startedDetached === true ? { startedDetached: true } : {}
+    })) : null;
   }
   if (typeof run.integrationBranch === "string" && typeof run.baseRef === "string") {
-    return [{ path: ".", integrationBranch: run.integrationBranch, baseRef: run.baseRef }];
+    return [{
+      path: ".",
+      integrationBranch: run.integrationBranch,
+      baseRef: run.baseRef,
+      ...typeof run.baseBranch === "string" && run.baseBranch ? { baseBranch: run.baseBranch } : {}
+    }];
   }
   return null;
 }
@@ -1664,15 +1674,11 @@ function handoffBranch(handoff) {
   return [...new Set(handoff.repos.map((r) => r.integrationBranch))].join(", ");
 }
 function handoffBase(handoff, length) {
-  const group = isRepoGroup(handoff);
-  return handoff.repos.map((r) => `${group ? `${r.path} ` : ""}${r.baseRef.slice(0, length)}`).join(", ");
-}
-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);
+  const group = (0, import_core10.isRepoGroup)(handoff);
+  return handoff.repos.map((r) => {
+    const ref = r.baseRef.slice(0, length);
+    return `${group ? `${r.path}: ` : ""}${r.baseBranch ? `${r.baseBranch} @ ${ref}` : `${r.startedDetached ? "detached at" : "base"} ${ref}`}`;
+  }).join(", ");
 }
 function repairedLanded(handoff) {
   return handoff.landed.filter((t) => t.repairedFiles?.length);
@@ -1750,7 +1756,7 @@ async function followExecution(api, sessionId, start, onBlocked) {
     for (const t of entries) {
       const icon = iconFor(t.status);
       const verdict = t.verdict ? `: ${t.verdict.outcome.toUpperCase()}: ${t.verdict.reason.slice(0, 60)}` : "";
-      const waits = t.waitsForApproval ? `: ${inLine(import_core12.WAITS_FOR_APPROVAL_LABEL)}: \`ordewell run-task <id>\` starts it` : "";
+      const waits = t.waitsForApproval ? `: ${inLine(import_core12.WAITS_FOR_APPROVAL_LABEL)}: \`ordewell force-start <id>\` approves it, \`ordewell run\` approves all` : "";
       lines.push(`  ${icon} #${t.id.slice(-4)} ${t.status}${verdict}${waits}`);
     }
     const output = lines.join("\n");
@@ -1812,10 +1818,10 @@ Done. ${summary.completed || 0} completed, ${summary.failed || 0} failed, ${summ
     }
     if (event.type === "isolation_handoff") {
       const n = event.landed.length;
-      const where = isRepoGroup(event) ? ` in ${event.repos.map((r) => r.path).join(", ")}` : "";
+      const where = (0, import_core10.isRepoGroup)(event) ? ` in ${event.repos.map((r) => r.path).join(", ")}` : "";
       console.log(`
 Run finished on ${handoffBranch(event)}${where}: ${n} task${n === 1 ? "" : "s"} landed.`);
-      if (isRepoGroup(event)) for (const line of repoResultLines(event)) console.log(`  ${line}`);
+      if ((0, import_core10.isRepoGroup)(event)) for (const line of repoResultLines(event)) console.log(`  ${line}`);
       if (event.deferredTo === "supervisor") console.log("  The supervisor may merge it.");
       console.log("  `ordewell handoff review|merge|discard|cleanup` to land it.");
     }
@@ -1852,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);
@@ -2656,27 +2663,28 @@ function formatCost(currency, amount) {
 function tokenLine(blocks2, cols) {
   const usage = blocks2[blocks2.length - 1];
   if (usage?.type !== "usage") return null;
-  const parts = usageMeasures(usage.totals, false);
+  const parts = usageMeasures(usage.totals);
   if (usage.model && !usage.contextFill) parts.push("ctx unknown");
   if (usage.contextFill) parts.splice(2, 0, `${Math.round(usage.contextFill.usedTokens / usage.contextFill.windowTokens * 100)}% ctx`);
   return parts.length > 0 ? style.grey(truncate(parts.join(" \xB7 "), cols)) : null;
 }
-function usageMeasures(totals, unknown) {
+function usageMeasures(totals) {
   return [
-    ...totals.inputTokens !== void 0 ? [`${compactCount(totals.inputTokens)} in`] : unknown ? ["unknown in"] : [],
-    ...totals.outputTokens !== void 0 ? [`${compactCount(totals.outputTokens)} out`] : unknown ? ["unknown out"] : [],
+    ...totals.inputTokens !== void 0 ? [`${compactCount(totals.inputTokens)} in`] : [],
+    ...totals.outputTokens !== void 0 ? [`${compactCount(totals.outputTokens)} out`] : [],
     ...totals.cachedInputTokens !== void 0 ? [`${compactCount(totals.cachedInputTokens)} cached`] : [],
-    ...Object.entries(totals.reportedCost ?? {}).map(([currency, amount]) => formatCost(currency, amount)),
-    ...unknown && !Object.keys(totals.reportedCost ?? {}).length ? ["cost unknown"] : []
+    ...Object.entries(totals.reportedCost ?? {}).map(([currency, amount]) => formatCost(currency, amount))
   ];
 }
 function taskUsageText(usage) {
   return [
-    ...usageMeasures(usage.totals, true),
-    ...usage.attempt !== void 0 ? [usage.contextFill ? `${Math.round(usage.contextFill.usedTokens / usage.contextFill.windowTokens * 100)}% ctx` : "ctx unknown"] : [],
-    usage.wallTimeMs !== void 0 ? `${Math.floor(usage.wallTimeMs / 1e3)}s` : "time unknown"
+    ...usageMeasures(usage.totals),
+    ...usage.attempt !== void 0 ? [usage.contextFill ? `ctx ${Math.round(usage.contextFill.usedTokens / usage.contextFill.windowTokens * 100)}%` : "ctx unknown"] : []
   ].join(" \xB7 ");
 }
+function assignmentFlagText(row) {
+  return `${row.assignmentFlag} \u2014 ${row.assignmentConsequence}`;
+}
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
@@ -2694,7 +2702,7 @@ async function handleStatus(subArgs, injectedApi) {
       emitJson(session, outputPath);
       return;
     }
-    printOneSession(sessionId, session.meta, session.plan);
+    printOneSession(sessionId, session.meta, session.plan, await assignmentScope(api));
   } else {
     const sessions = await api.getSessions(workspace);
     if (asJson) {
@@ -2733,7 +2741,20 @@ function emitJson(payload, outputPath) {
     process.exit(1);
   }
 }
-function printOneSession(sessionId, meta, plan) {
+async function assignmentScope(api) {
+  try {
+    const [runners2, settings, models] = await Promise.all([api.getRunners(), api.getSettings(), api.getModels()]);
+    if (!Array.isArray(runners2.runners) || runners2.runners.length === 0) return void 0;
+    return {
+      enabledRunners: runners2.runners.filter((r) => r.enabled).map((r) => r.id),
+      allowlist: settings.modelAllowlist ?? {},
+      models: models.modelsByRunner ?? {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function printOneSession(sessionId, meta, plan, runnerScope) {
   const allTasks = allTasksOf(plan);
   const everyTask = (0, import_core15.flattenTasks)(allTasks);
   const blocked = (0, import_core15.blockingFailures)(everyTask.map((t) => ({ ...t, subtasks: [], dependencies: t.dependencies ?? [] })));
@@ -2742,20 +2763,23 @@ function printOneSession(sessionId, meta, plan) {
   console.log(`Goal:     ${meta.goal}`);
   console.log(`Runner:   ${(meta.runners || []).join(", ")}  |  Status: ${meta.status}`);
   console.log(`Phase:    ${plan?.phase || "unknown"}  |  Created: ${meta.createdAt}`);
+  const isolation = isolationOfPlan(plan);
+  if (isolation) console.log(`Base:     ${handoffBase(isolation.handoff, 8)}`);
   console.log(`Tasks:    ${everyTask.length} total  |  ${count("completed")} done  |  ${count("failed")} failed  |  ${count("in_progress")} running  |  ${count("blocked")} blocked  |  ${count("skipped")} skipped
 `);
   const usage = (0, import_core15.planUsage)(allTasks);
   if (usage.attempts) console.log(`Tasks total: ${taskUsageText(usage)}`);
   const record = servedApprovalRecord(plan);
-  const approval = (row, ref) => row.waitsForApproval ? `${row.waitsForApproval}: \`ordewell run-task ${ref}\` starts it, or \`ordewell run\` runs the plan` : null;
+  const approval = (row, ref) => row.waitsForApproval ? `${row.waitsForApproval}: \`ordewell force-start ${ref}\` approves it, \`ordewell run\` approves all` : null;
   for (const t of allTasks) {
     const icon = iconFor(blocked.has(t.id) ? "blocked" : t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
     console.log(`  ${(0, import_core15.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
-    const row = (0, import_core15.taskRowView)({ ...t, dependencies: t.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(t, record) }, { tasks: allTasks });
+    const row = (0, import_core15.taskRowView)({ ...t, dependencies: t.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(t, record) }, { tasks: allTasks, runnerScope });
     const waiting = approval(row, (0, import_core15.taskOrderLabel)(t));
     if (waiting) console.log(`      ${waiting}`);
+    if (row.assignmentFlag) console.log(`      \u26A0 ${assignmentFlagText(row)}`);
     if (row.blockedBy) console.log(`      ${(0, import_core15.blockedByLabel)(row.blockedBy)}`);
     if (row.status === "skipped") console.log(`      ${(0, import_core15.skippedLabel)(row.skipReason)}`);
     if (row.usage) console.log(`      ${taskUsageText(row.usage)}`);
@@ -2764,9 +2788,10 @@ function printOneSession(sessionId, meta, plan) {
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
       console.log(`    ${(0, import_core15.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
-      const subRow = (0, import_core15.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(sub, record) }, { parent: t, tasks: allTasks });
+      const subRow = (0, import_core15.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(sub, record) }, { parent: t, tasks: allTasks, runnerScope });
       const subWaiting = approval(subRow, (0, import_core15.taskOrderLabel)(sub, t));
       if (subWaiting) console.log(`        ${subWaiting}`);
+      if (subRow.assignmentFlag) console.log(`        \u26A0 ${assignmentFlagText(subRow)}`);
       if (subRow.blockedBy) console.log(`        ${(0, import_core15.blockedByLabel)(subRow.blockedBy)}`);
       if (subRow.status === "skipped") console.log(`        ${(0, import_core15.skippedLabel)(subRow.skipReason)}`);
       if (subRow.usage) console.log(`        ${taskUsageText(subRow.usage)}`);
@@ -2779,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);
@@ -2796,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
@@ -3214,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) {
@@ -3225,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;
@@ -3238,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 {
-          await api.taskControl(sessionId, taskId, action);
-          console.log(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);
         }
       }
@@ -3280,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);
@@ -3303,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);
@@ -3321,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);
@@ -3337,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);
@@ -3353,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);
@@ -3561,6 +3594,17 @@ async function handleRewind(subArgs, injectedApi) {
   console.log("\nThe message you rewound to, to resend or edit:\n");
   console.log(fork.rewoundMessage);
 }
+async function handleResend(subArgs, injectedApi) {
+  if (positionals(subArgs)[0] !== "cancel") fail("Usage: ordewell resend cancel [--session-id <id>] [--workspace /path]");
+  const { api, sessionId } = await adopted(subArgs, injectedApi);
+  let cancelled;
+  try {
+    ({ cancelled } = await api.cancelPlannerResend(sessionId));
+  } catch (err) {
+    fail(`Failed to cancel the resend: ${err.message}`);
+  }
+  console.log(cancelled ? "Resend cancelled: what waits goes with your next message." : "Nothing waits on the planner's usage limit to be sent at a reset.");
+}
 
 // src/tui/transcript.ts
 var import_core22 = require("@ordewell/core");
@@ -3594,7 +3638,7 @@ var HANDOFF_ACTIONS = [
   { id: "cleanup", label: "Clean up", hint: "remove worktrees and task branches, keep this branch" }
 ];
 function handoffActions(handoff) {
-  if (!isRepoGroup(handoff)) return HANDOFF_ACTIONS;
+  if (!(0, import_core10.isRepoGroup)(handoff)) return HANDOFF_ACTIONS;
   return [
     { id: "review", label: "Review diff", hint: "each repository's branch against the commit it forked from" },
     { id: "merge", label: "Merge all", hint: "every repository's branch into what you have checked out there (asks first)" },
@@ -3619,7 +3663,7 @@ function handoffCommand(state, arg) {
 }
 function handoffArrived(state, handoff) {
   const landed = handoff.landed.length;
-  const where = isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : "";
+  const where = (0, import_core10.isRepoGroup)(handoff) ? ` in ${reposOf2(handoff)}` : "";
   const branch = handoffBranch(handoff);
   const tasks = `${landed} task${landed === 1 ? "" : "s"} landed`;
   const received = { ...state, handoff };
@@ -3634,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);
@@ -3654,8 +3695,8 @@ function runHandoffAction(state, id) {
             ...state,
             overlay: {
               kind: "confirm",
-              title: isRepoGroup(handoff) ? "Merge what has landed into your branches?" : "Merge what has landed into your branch?",
-              message: `Merge ${handoffBranch(handoff)} as it stands now into whatever ${isRepoGroup(handoff) ? `each of ${reposWithWork(handoff).join(", ")} has` : "you have"} checked out. The run goes on: tasks waiting for Merge all start once it has merged, and later tasks land on the same branch for the next Merge all. A merge that conflicts is aborted, and your ${isRepoGroup(handoff) ? "trees stay" : "tree stays"} as ${isRepoGroup(handoff) ? "they were" : "it was"}.${repairedNotice(handoff)}`,
+              title: (0, import_core10.isRepoGroup)(handoff) ? "Merge what has landed into your branches?" : "Merge what has landed into your branch?",
+              message: `Merge ${handoffBranch(handoff)} as it stands now into ${(0, import_core10.mergeTarget)(handoff)}.${(0, import_core10.checkoutRule)(handoff)} The run goes on: tasks waiting for Merge all start once it has merged, and later tasks land on the same branch for the next Merge all. A merge that conflicts is aborted, and your ${(0, import_core10.isRepoGroup)(handoff) ? "trees stay" : "tree stays"} as ${(0, import_core10.isRepoGroup)(handoff) ? "they were" : "it was"}.${repairedNotice(handoff)}`,
               action: { kind: "merge-run" }
             }
           },
@@ -3665,15 +3706,15 @@ function runHandoffAction(state, id) {
       return {
         state: {
           ...state,
-          overlay: isRepoGroup(handoff) ? {
+          overlay: (0, import_core10.isRepoGroup)(handoff) ? {
             kind: "confirm",
             title: "Merge all into your branches?",
-            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. It checks every repository first and merges none unless every repository can take it; on git older than 2.38 it goes repository by repository and stops at the first that fails. A merge that conflicts is aborted, and your trees stay as they were. Once every repository has merged, the run's worktrees and branches are removed unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into ${(0, import_core10.mergeTarget)(handoff)}.${(0, import_core10.checkoutRule)(handoff)} It checks every repository first and merges none unless every repository can take it; on git older than 2.38 it goes repository by repository and stops at the first that fails. A merge that conflicts is aborted, and your trees stay as they were. Once every repository has merged, the run's worktrees and branches are removed unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           } : {
             kind: "confirm",
             title: "Merge into your branch?",
-            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. If it conflicts the merge is aborted and your tree stays as it was. Once it has merged, the run's worktrees and branches are removed unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into ${(0, import_core10.mergeTarget)(handoff)}.${(0, import_core10.checkoutRule)(handoff)} If it conflicts the merge is aborted and your tree stays as it was. Once it has merged, the run's worktrees and branches are removed unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           }
         },
@@ -3686,7 +3727,7 @@ function runHandoffAction(state, id) {
           overlay: {
             kind: "confirm",
             title: "Discard this run?",
-            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status: mark one not done if you did not keep its work.`,
+            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${(0, import_core10.isRepoGroup)(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status: mark one not done if you did not keep its work.`,
             action: { kind: "discard-run" }
           }
         },
@@ -3704,9 +3745,8 @@ function confirmedHandoff(state, kind) {
     type: "isolationMerge",
     sessionId,
     branch: handoffBranch(handoff),
-    ...isRepoGroup(handoff) ? { group: true } : {},
-    ...repaired.length > 0 ? { repaired } : {},
-    ...midRun(state) ? { midRun: true } : {}
+    ...(0, import_core10.isRepoGroup)(handoff) ? { group: true } : {},
+    ...repaired.length > 0 ? { repaired } : {}
   } : { type: "isolationDiscard", sessionId, branch: handoffBranch(handoff) };
   return { state: closed, effects: [effect] };
 }
@@ -3789,7 +3829,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
   const handoff = isolationOfPlan(plan)?.handoff;
   if (!handoff) fail("This session has no isolated run to hand off.");
   const branch = handoffBranch(handoff);
-  const group = isRepoGroup(handoff);
+  const group = (0, import_core10.isRepoGroup)(handoff);
   if (group) for (const line of repoResultLines(handoff)) console.error(line);
   const asked = hasFlag(subArgs, "--yes");
   const confirmed = async (question) => {
@@ -3810,7 +3850,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
       return;
     }
     case "merge": {
-      await confirmed((group ? `Merge ${branch} into the branch checked out in each of ${reposWithWork(handoff).join(", ")}? Nothing is merged unless every repository can take it; once a finished run has merged everything, its worktrees and branches are removed.` : `Merge ${branch} into the branch you have checked out? Once a finished run has merged everything, its worktrees and branches are removed.`) + repairedNotice(handoff));
+      await confirmed((group ? `Merge ${branch} into ${(0, import_core10.mergeTarget)(handoff)}? Nothing is merged unless every repository can take it${(0, import_core10.checkoutRule)(handoff) ? " and is on that branch" : ""}; once a finished run has merged everything, its worktrees and branches are removed.` : `Merge ${branch} into ${(0, import_core10.mergeTarget)(handoff)}?${(0, import_core10.checkoutRule)(handoff)} Once a finished run has merged everything, its worktrees and branches are removed.`) + repairedNotice(handoff));
       const { ok, message } = mergeOutcome(await attempt(() => api.mergeRun(sessionId)), branch, group, repairedLanded(handoff));
       if (ok) console.log(message);
       else fail(message);
@@ -4107,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);
 }
@@ -4144,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,
@@ -4158,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
@@ -4354,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);
@@ -4426,6 +4464,7 @@ function initialState(overrides = {}) {
     workspace: process.cwd(),
     handoff: null,
     runMerge: null,
+    plannerResend: null,
     overlay: null,
     pendingApprovals: [],
     queuedPrompts: import_core28.EMPTY_HOLD,
@@ -4444,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);
@@ -4507,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"}.`);
     }
   });
 }
@@ -4584,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)" : ""}`);
       }
@@ -4600,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.`);
@@ -4666,6 +4707,7 @@ var SLASH_COMMANDS = [
   { name: "approve", usage: "/approve", description: "Approve the drafted plan", category: "planning" },
   { name: "run", usage: "/run", description: "Execute the approved plan", category: "planning" },
   { name: "stop", usage: "/stop", description: "Stop the planner or the running execution, whichever is active", category: "planning" },
+  { name: "resend", usage: "/resend cancel", description: "Keep what waits on the planner's usage limit from being sent at the reset: it goes with your next message", category: "planning" },
   { name: "handoff", usage: "/handoff [review|merge|discard|cleanup]", description: "Land an isolated run's branch: review it, merge it into yours, or discard it", category: "planning" },
   // Tasks
   { name: "add-task", usage: "/add-task <title>", description: "Add a task to the current plan", category: "tasks" },
@@ -4675,7 +4717,7 @@ var SLASH_COMMANDS = [
   { name: "skip", usage: "/skip <id>", description: "Skip a task", category: "tasks" },
   { name: "retry", usage: "/retry <id>", description: "Re-run a failed task", category: "tasks" },
   { name: "cancel", usage: "/cancel <id>", description: "Kill a running task", category: "tasks" },
-  { name: "force-start", usage: "/force-start <id>", description: "Start a task now, ignoring dependencies", category: "tasks" },
+  { name: "force-start", usage: "/force-start <id>", description: "Approve a task and start it now, or once its dependencies finish", category: "tasks" },
   { name: "continue", usage: "/continue <id> <message>", description: "Continue a finished task in its saved runner session, with your message", category: "tasks" },
   { name: "open", usage: "/open <id>", description: "Open a task's view: its log, and the keys that answer its checkpoint or tool request", category: "tasks" },
   { name: "checkpoint", usage: "/checkpoint <id> approve|reject [reason]", description: "Answer the checkpoint a task waits at: approve lets it go on, reject tells it why not", category: "tasks" },
@@ -4829,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 };
@@ -4841,6 +4883,15 @@ function refillPicker(state, kinds) {
   const hint = overlay.picker.action.kind === "set-model" ? providerErrorHint(state) : overlay.picker.hint;
   return { ...state, overlay: { kind: "picker", picker: { ...overlay.picker, items, hint, index: 0 } } };
 }
+function reseedRunnerChoice(before, after) {
+  const overlay = after.overlay;
+  if (overlay?.kind !== "picker" || overlay.picker.action.kind !== "set-runners") return after;
+  const enabledIds = (state) => state.runners.filter((r) => r.enabled).map((r) => r.id);
+  const shown = enabledIds(before);
+  const untouched = overlay.picker.chosen.length === shown.length && shown.every((id) => overlay.picker.chosen.includes(id));
+  const picker2 = { ...overlay.picker, items: pickerItemsFor(after, overlay.picker.action) };
+  return { ...after, overlay: { kind: "picker", picker: untouched ? { ...picker2, chosen: enabledIds(after) } : picker2 } };
+}
 function modelDetail(m) {
   return [m.provider, m.pricing].filter(Boolean).join(" \xB7 ") || void 0;
 }
@@ -4929,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
@@ -5039,7 +5090,13 @@ var PLAN_KEYS = {
   deps: { keys: "D", meaning: "pick the tasks it depends on", group: "Assign" },
   skills: { keys: "K", meaning: "pick the skills it loads", group: "Assign" },
   ops: { keys: "O", meaning: "switch between a change and an ops task", group: "Assign" },
-  start: { keys: "f", meaning: "start the task now", group: "Run", hint: "f start" },
+  start: {
+    keys: "f",
+    meaning: "start the task, approving it if it waits for you; it starts once its dependencies finish",
+    group: "Run",
+    // Added after the plan was approved, it waits for this key; the row says the same.
+    hint: (task) => task && (0, import_core32.taskRowView)(task).waitsForApproval ? "f approve" : "f start"
+  },
   runPlan: { keys: "E", meaning: "run the whole plan", group: "Run", hint: "E run plan" },
   stop: { keys: "S", meaning: "stop the run", group: "Run", hint: "S stop" },
   cancel: {
@@ -5295,11 +5352,18 @@ function chatLayout(state, rows, cols) {
   const bubbles = tv ? taskQueuedRows(state, cols) : queuedPromptRows(state, cols);
   const content = [...transcript, ...bubbles.length > 0 ? ["", ...bubbles] : []];
   const taskHeader = tv ? taskHeaderLines(state, tv, cols) : [];
-  const usage = rows <= 1 ? [] : tv ? taskUsageFooter(state, tv, blocks2, cols) : tokenRow(blocks2, cols);
+  const usage = rows <= 1 ? [] : tv ? taskUsageFooter(state, tv, blocks2, cols) : [...plannerResendRow(state, cols), ...tokenRow(blocks2, cols)];
   const footer = usage.slice(0, Math.max(1, rows - taskHeader.length - 1));
   const space = Math.max(0, rows - taskHeader.length - footer.length);
   return { lines: content, header: taskHeader, footer, anchor: content.length > space ? "bottom" : "top", maxScroll: Math.max(0, content.length - space) };
 }
+function plannerResendRow(state, cols) {
+  const { plannerResend } = state;
+  const at = plannerResend ? new Date(plannerResend.at) : null;
+  if (!plannerResend || !at || Number.isNaN(at.getTime())) return [];
+  const whose = plannerResend.runner ? `${plannerResend.runner}'s` : "the planner's";
+  return [style.yellow(truncate(`\u23F8 Resending at ${(0, import_core34.resumeTime)(at)}, once ${whose} usage limit resets \xB7 /resend cancel keeps it for your next message`, cols))];
+}
 var tokenRow = (blocks2, cols) => {
   const line = tokenLine(blocks2, cols);
   return line ? [line] : [];
@@ -5307,15 +5371,13 @@ var tokenRow = (blocks2, cols) => {
 function taskUsageFooter(state, tv, blocks2, cols) {
   const task = findTask(state.tasks, tv.taskId);
   const reported = task?.attemptUsage ?? [];
+  if (!task || reported.length === 0) return tokenRow(blocks2, cols);
   const onScreen = tv.attempt > 0 ? reported.find((a) => a.attempt === tv.attempt) : reported.at(-1);
-  if (!task || !onScreen) return tokenRow(blocks2, cols);
-  const usage = (0, import_core34.taskRowView)({ ...task, attemptUsage: [onScreen] }).usage;
-  if (!usage) return tokenRow(blocks2, cols);
-  const models = usage.byModel ?? [];
-  return [
-    style.grey(truncate(taskUsageText(usage), cols)),
-    ...models.length > 1 ? models.map((m) => style.grey(truncate(`${sanitize(m.model ?? "unattributed")}: ${usageMeasures(m.totals, true).join(" \xB7 ")}`, cols))) : []
-  ];
+  const spend = (0, import_core34.taskUsageSummary)(task);
+  const total = taskUsageText({ ...spend, attempt: reported.at(-1)?.attempt ?? 0 });
+  if (onScreen === reported.at(-1)) return [style.grey(truncate(total, cols))];
+  const own = onScreen ? [style.grey(truncate(`attempt ${onScreen.attempt}: ${taskUsageText({ totals: onScreen.totals, contextFill: (0, import_core34.plannerContextFill)(onScreen), attempt: onScreen.attempt })}`, cols))] : tokenRow(blocks2, cols);
+  return [...own, style.grey(truncate(`task total: ${total}`, cols))];
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
@@ -5558,9 +5620,17 @@ function planScrollExtent(state) {
   }
   return planLayout(state, bodyRows(state), cols);
 }
+function modelsByRunnerOf(models) {
+  const out = {};
+  for (const m of models) {
+    for (const runner of m.runners ?? []) (out[runner] ??= []).push({ modelId: m.id, modelLabel: m.label, variants: [] });
+  }
+  return out;
+}
 function taskLines(state, planRow, index, cols) {
   const { task, parent } = planRow;
-  const row = (0, import_core34.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task) });
+  const runnerScope = state.runners.length > 0 ? { enabledRunners: state.runners.filter((r) => r.enabled).map((r) => r.id), allowlist: state.allowlist, models: modelsByRunnerOf(state.models) } : void 0;
+  const row = (0, import_core34.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task), runnerScope });
   const selected = state.focus === "plan" && index === state.selectedTask;
   const expanded = state.expandedTaskId === task.id;
   const rawIcon = row.status === "running" ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[row.status];
@@ -5582,8 +5652,7 @@ function taskLines(state, planRow, index, cols) {
     const prefix = lineIndex === 0 ? head : continuation;
     return prefix + (selected ? style.bold(line) : line);
   });
-  const reported = [...new Set((row.usage?.byModel ?? []).flatMap((m) => m.model ? [sanitize(m.model)] : []))];
-  const model = reported.length ? reported.join(", ") : task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
+  const model = task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
   const effort = task.type === "ai" ? `effort: ${task.assignedModel?.thinkingEffort ?? "default"}` : "";
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${row.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
@@ -5599,36 +5668,39 @@ function taskLines(state, planRow, index, cols) {
   if (row.conflict) {
     const where = row.conflict.repo ? ` in ${row.conflict.repo}` : "";
     const files = row.conflict.files ? ` (${row.conflict.files})` : "";
-    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files}: its work is kept on its own branch`, cols)));
+    lines.push(...statusLines(style.red, "\u26A0", `merge conflict${where}${files}: its work is kept on its own branch`, cols, bodyPad));
   }
   if (row.repairing) {
     const files = row.repairing.files ? ` in ${row.repairing.files}` : "";
     const attempt = row.repairing.attempt ? ` (attempt ${row.repairing.attempt.attempt}/${row.repairing.attempt.limit})` : "";
-    lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
+    lines.push(...statusLines(style.yellow, "\u21BB", `repairing conflict${files}${attempt}`, cols, bodyPad));
   }
   if (row.mergeGate) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all: ${row.mergeGate.join(", ")} not merged into your branch yet`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", `waits for Merge all: ${row.mergeGate.join(", ")} not merged into your branch yet`, cols, bodyPad));
+  }
+  if (row.assignmentFlag) {
+    lines.push(...statusLines(style.yellow, "\u26A0", assignmentFlagText(row), cols, bodyPad));
   }
   if (row.waitsForApproval) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.waitsForApproval)}: added after you approved the plan; f starts it, or /run runs the plan`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", `${inRow(row.waitsForApproval)} \xB7 f approves it \xB7 /run approves all`, cols, bodyPad));
   }
   if (row.blockedBy) {
-    lines.push(style.red(truncate(`${bodyPad}\u2298 ${inRow((0, import_core34.blockedByLabel)(row.blockedBy))}: runs once ${row.blockedBy.length === 1 ? "it is retried and passes" : "they are retried and pass"}`, cols)));
+    lines.push(...statusLines(style.red, "\u2298", `${inRow((0, import_core34.blockedByLabel)(row.blockedBy))}: runs once ${row.blockedBy.length === 1 ? "it is retried and passes" : "they are retried and pass"}`, cols, bodyPad));
   }
   if (row.status === "skipped") {
-    lines.push(style.grey(truncate(`${bodyPad}\xBB ${inRow((0, import_core34.skippedLabel)(row.skipReason))}: nothing of it landed; m done lands its kept work`, cols)));
+    lines.push(...statusLines(style.grey, "\xBB", `${inRow((0, import_core34.skippedLabel)(row.skipReason))}: nothing of it landed; m done lands its kept work`, cols, bodyPad));
   }
   const resumable = row.actions.includes("resume-now");
   if (row.resumes) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.resumes)}, once the usage limit resets: ${resumable ? "r resume now \xB7 " : ""}c don't resume`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", `${inRow(row.resumes)}, once the usage limit resets: ${resumable ? "r resume now \xB7 " : ""}c don't resume`, cols, bodyPad));
   } else if (resumable) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for the usage limit to reset: r resume now`, cols)));
+    lines.push(...statusLines(style.yellow, "\u23F8", "waits for the usage limit to reset: r resume now", cols, bodyPad));
   }
   if (row.opsChangedFiles) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u26A0 an ops task changed tracked files: check them, then m done or /retry`, cols)));
+    lines.push(...statusLines(style.yellow, "\u26A0", "an ops task changed tracked files: check them, then m done or /retry", cols, bodyPad));
   }
   if (row.repaired?.landed) {
-    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${row.repaired.files}`, cols)));
+    lines.push(...statusLines(style.grey, "\u21BB", `landed after repairing conflict in ${row.repaired.files}`, cols, bodyPad));
   }
   let editorLine;
   if (expanded) {
@@ -5670,6 +5742,11 @@ function taskLines(state, planRow, index, cols) {
   }
   return { lines, editorLine };
 }
+function statusLines(paint, glyph, text, cols, pad2) {
+  const lead = `${pad2}${glyph} `;
+  const room = Math.max(1, cols - width(lead));
+  return wrap(text, room).map((line, i) => paint(`${i === 0 ? lead : " ".repeat(width(lead))}${line}`));
+}
 function taskText(label, text, cols, pad2 = "    ") {
   const room = Math.max(1, cols - width(pad2));
   return [
@@ -6057,7 +6134,7 @@ function renderHandoff(state, overlay, rows, cols) {
     const caret = active ? style.brand("\u276F") : " ";
     return `${caret} ${active ? style.bold(action.label) : action.label}${style.grey(`: ${action.hint}`)}`;
   });
-  const perRepo = isRepoGroup(handoff) ? ["Per repository:", ...handoff.repos.map((repo, i) => `  ${repo.landed.length > 0 ? style.green("\u2713") : style.grey("\xB7")} ${repoResultLines(handoff)[i]}`), ""] : [];
+  const perRepo = (0, import_core10.isRepoGroup)(handoff) ? ["Per repository:", ...handoff.repos.map((repo, i) => `  ${repo.landed.length > 0 ? style.green("\u2713") : style.grey("\xB7")} ${repoResultLines(handoff)[i]}`), ""] : [];
   return frame(
     "Run handoff",
     [
@@ -6574,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 }]);
@@ -6595,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);
@@ -6699,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];
@@ -6707,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 }]
     );
   }
@@ -6739,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 };
@@ -6761,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 }
     }
   });
@@ -6785,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 }
     }
   });
@@ -6793,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
       })
     }
   });
@@ -7020,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
@@ -7272,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,
@@ -7593,6 +7604,8 @@ function runCommand(state, { name, args }) {
       return withIdlePlanner(state, (sessionId) => step(state, [{ type: "forkConversation", sessionId }]));
     case "rewind":
       return rewind(state, args[0]);
+    case "resend":
+      return args[0] === "cancel" ? withSession(state, (sessionId) => step(state, [{ type: "cancelPlannerResend", sessionId }])) : step(say(state, "system", "A planner turn that hits the planner's usage limit is sent again at the reset: /resend cancel keeps it for your next message instead."));
     case "compact":
       return withIdlePlanner(
         state,
@@ -7866,7 +7879,7 @@ function runners(state, args) {
       multi: true,
       chosen: state.runners.filter((r) => r.enabled).map((r) => r.id)
     })
-  } });
+  } }, [{ type: "loadRunners" }]);
 }
 function setMaxParallel(state, arg) {
   if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once: /parallel <n> changes it.`));
@@ -8162,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.
@@ -8171,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,
@@ -8184,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" };
@@ -8270,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);
@@ -8333,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,
@@ -8344,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,
@@ -8360,13 +8402,15 @@ function reduceAction(state, action) {
         focus: "chat",
         editor: { ...state.editor, text: action.text, cursor: action.text.length, historyIndex: state.editor.history.length, draft: "" }
       });
+    case "sharedSettingsChanged":
+      return step(state, [{ type: "loadScope" }]);
     case "runnersLoaded":
-      return step(refreshStepper(refillPicker({
+      return step(refreshStepper(reseedRunnerChoice(state, refillPicker({
         ...state,
         runners: action.runners,
         runnersKnown: true,
         orchestratorModel: action.orchestratorModel ?? state.orchestratorModel
-      }, ["set-task-runner"])));
+      }, ["set-task-runner"]))));
     case "failed": {
       if (!action.turn) return step(say(taskLogAbandoned(state), "error", action.message));
       if (state.forceSendPending) {
@@ -8407,12 +8451,16 @@ 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 = {
     ...folded,
+    plannerResend: plannerResendOf(plan),
     expandedTaskId,
     taskEditor: expandedTaskId !== null ? state.taskEditor : null
   };
@@ -8422,6 +8470,11 @@ function showPlan(state, plan) {
     focus: tasks.length === 0 ? "chat" : state.focus
   });
 }
+function plannerResendOf(plan) {
+  const saved = plan?.plannerResend;
+  if (typeof saved?.at !== "string") return null;
+  return { ...typeof saved.runner === "string" ? { runner: saved.runner } : {}, at: saved.at };
+}
 function runStatus(state, tasks) {
   if (tasks.some(import_core28.isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user") || state.runMerge?.paused) return "executing";
@@ -8760,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;
@@ -8788,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) => {
@@ -8860,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,
@@ -8939,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 });
@@ -8949,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;
@@ -9049,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);
@@ -9069,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;
       }
@@ -9128,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
@@ -9160,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 });
@@ -9317,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;
     }
@@ -9361,6 +9417,12 @@ async function perform(effect, deps) {
     // user gets to read — no separate notice to repeat it. The daemon also
     // broadcast that summary; `redrawn` keeps a late socket copy of it from
     // landing as a second, spoken turn.
+    case "cancelPlannerResend": {
+      const { cancelled } = await api.cancelPlannerResend(effect.sessionId);
+      dispatch({ type: "notice", message: cancelled ? "Resend cancelled: what waits goes with your next message." : "Nothing waits on the planner's usage limit to be sent at a reset." });
+      await refreshPlan(deps, effect.sessionId);
+      return;
+    }
     case "compactConversation": {
       const { plan } = await api.compactConversation(effect.sessionId);
       const inbound = inboundFor(deps.api, deps.dispatch, effect.sessionId);
@@ -9376,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":
@@ -9423,6 +9484,12 @@ async function perform(effect, deps) {
       } catch {
       }
       return;
+    case "loadRunners":
+      await loadRunners(deps);
+      return;
+    case "loadScope":
+      await Promise.all([loadRunners(deps), loadSettings(deps)]);
+      return;
     case "refresh":
       await Promise.all([loadRunners(deps), loadSettings(deps), loadModels(deps)]);
       if (effect.announce) dispatch({ type: "notice", message: "Refreshed runners, settings and models." });
@@ -9527,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();
@@ -9546,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 ?? [];
@@ -9564,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()) });
@@ -9986,10 +10054,12 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       if (terminal) app.dispatch({ type: "resize", ...terminal.size() });
     }
   });
+  const watchingSettings = settings.watch(() => app.dispatch({ type: "sharedSettingsChanged" }));
   const { rows, cols } = terminal.size();
   app.dispatch({ type: "resize", rows, cols });
   app.start();
   function shutdown(code) {
+    watchingSettings.dispose();
     terminal?.close();
     if (owned) stopDaemon(port).catch(() => {
     });
@@ -10059,6 +10129,7 @@ var COMMANDS = {
   fork: handleFork,
   compact: handleCompact,
   rewind: handleRewind,
+  resend: handleResend,
   handoff: handleHandoff,
   tui: handleTui
 };