@ordewell/cli 0.7.0 → 0.7.2

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core34 = require("@ordewell/core");
+var import_core38 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -121,6 +121,7 @@ Tasks (<id> is an order number or a task ID):
   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
+  ordewell checkpoint <id> approve|reject [reason]  Answer the checkpoint a task waits at
   ordewell cancel <id>            Kill a running task
   ordewell terminal <id>          Open a real terminal attached to a task's runner
 
@@ -160,6 +161,12 @@ TUI options:
   --workspace /path   Workspace directory (default: cwd)
   --port N            Target a daemon on port N
 
+TUI task view keys (t on a structured task; /help in the TUI lists them all):
+  ctrl-s              Send now: interrupt the running step and deliver the composer text next
+                      (with the composer empty, the selected queued message)
+  ctrl-n / ctrl-p     Select a queued message; ctrl-r removes it
+  ctrl-x              Interrupt the running turn
+
 Plan options:
   --goal "text"       Task description (required)
   --runner <id>       Runner to use (repeatable; default: all enabled runners)
@@ -399,15 +406,30 @@ var import_http2 = __toESM(require("http"));
 var import_ws = __toESM(require("ws"));
 var import_core3 = require("@ordewell/core");
 var DEFAULT_HTTP_TIMEOUT_MS = 15 * 60 * 1e3;
-var WorkspaceInitNeededError = class extends Error {
-  constructor(message, workspace) {
+var DaemonError = class extends Error {
+  constructor(message, status, code) {
     super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "DaemonError";
+  }
+  status;
+  code;
+};
+var WorkspaceInitNeededError = class extends DaemonError {
+  constructor(message, workspace) {
+    super(message, 400, "workspace_not_a_project");
     this.workspace = workspace;
     this.name = "WorkspaceInitNeededError";
   }
   workspace;
 };
 var SESSION_PATH = /^\/api\/(?:plans|sessions)\/([^/?]+)/;
+function daemonError(status, data, fallback) {
+  const { error, code, workspace } = typeof data === "object" && data !== null ? data : {};
+  if (code === "workspace_not_a_project") return new WorkspaceInitNeededError(error || "Not a project directory", workspace ?? "");
+  return new DaemonError(error || fallback, status, code);
+}
 var ApiClient = class _ApiClient {
   /** Where a CLI invocation's sessions live, when a client is built without one: `--workspace`, else the cwd. */
   static defaultWorkspace;
@@ -415,6 +437,7 @@ var ApiClient = class _ApiClient {
   workspace;
   /** A session's open execution stream, so a new one can end it: one run is reported once. */
   executionStreams = /* @__PURE__ */ new Map();
+  executionStreamEnds = /* @__PURE__ */ new WeakMap();
   constructor(port, workspace) {
     this.port = port || DEFAULT_PORT;
     this.workspace = workspace ?? _ApiClient.defaultWorkspace ?? process.cwd();
@@ -429,7 +452,7 @@ var ApiClient = class _ApiClient {
   }
   /**
    * A daemon holds only the sessions adopted since it started, so after a
-   * restart every session-scoped call answered "Session not found" until the
+   * restart every session-scoped call answered "session not found" until the
    * user ran `ordewell sessions load`. The saved session is adopted here
    * instead — idempotent for one the daemon still holds — and the call made
    * once more; a 404 means the first attempt never ran, so the retry cannot
@@ -438,11 +461,17 @@ var ApiClient = class _ApiClient {
   async httpRequest(method, urlPath, body) {
     const res = await this.rawRequest(method, urlPath, body);
     const sessionId = urlPath.match(SESSION_PATH)?.[1];
-    const missing = res.status === 404 && res.data?.error === "Session not found";
+    const missing = res.status === 404 && res.data?.code === "session_not_found";
     if (!missing || !sessionId || urlPath.split("?")[0].endsWith("/load")) return res;
     const adopted2 = await this.rawRequest("POST", `/api/sessions/${sessionId}/load?workspace=${encodeURIComponent(this.workspace)}`);
     return adopted2.status === 200 ? this.rawRequest(method, urlPath, body) : res;
   }
+  /** One request whose only good answer is a 200: anything else becomes a {@link DaemonError} carrying the daemon's code. */
+  async call(method, urlPath, fallback, body) {
+    const res = await this.httpRequest(method, urlPath, body);
+    if (res.status !== 200) throw daemonError(res.status, res.data, fallback);
+    return res.data;
+  }
   rawRequest(method, urlPath, body) {
     return new Promise((resolve3, reject) => {
       const url = new URL(urlPath, `http://127.0.0.1:${this.port}`);
@@ -485,15 +514,12 @@ var ApiClient = class _ApiClient {
     });
   }
   async generatePlan(goal, runners2, workspace, sessionId = (0, import_core3.mintSessionId)()) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/generate`, {
+    const { plan, models, modelsByRunner } = await this.call("POST", `/api/plans/${sessionId}/generate`, "Plan generation failed", {
       goal,
       runners: runners2 || void 0,
       workspace
     });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Plan generation failed");
-    }
-    return { sessionId, plan: res.data.plan, models: res.data.models, modelsByRunner: res.data.modelsByRunner };
+    return { sessionId, plan, models, modelsByRunner };
   }
   /**
    * Open the ADR-0002 planner dialogue. Unlike `generatePlan`, this path honours
@@ -501,58 +527,30 @@ var ApiClient = class _ApiClient {
    * (empty `tasks`, last word in `conversationHistory`) rather than a committed plan.
    */
   async startConversation(sessionId, goal, runners2, workspace, allowInit) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/converse/start`, {
+    const res = await this.call("POST", `/api/plans/${sessionId}/converse/start`, "Planning failed", {
       goal,
       runners: runners2 || void 0,
       workspace,
       allowInit
     });
-    if (res.status !== 200) {
-      if (res.data?.code === "workspace_not_a_project") {
-        throw new WorkspaceInitNeededError(res.data.error || "Not a project directory", res.data.workspace || workspace || "");
-      }
-      throw new Error(res.data?.error || "Planning failed");
-    }
-    return res.data.plan;
+    return res.plan;
   }
   async sendConversationMessage(sessionId, message) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/converse/message`, { message });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Planner message failed");
-    }
-    return res.data.plan;
+    const res = await this.call("POST", `/api/plans/${sessionId}/converse/message`, "Planner message failed", { message });
+    return res.plan;
   }
-  async getRunners() {
-    const res = await this.httpRequest("GET", "/api/runners");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch runners");
-    }
-    return res.data;
+  getRunners() {
+    return this.call("GET", "/api/runners", "Failed to fetch runners");
   }
   /** The full provider catalog the daemon has discovered (used by the TUI model picker). */
-  async getModels() {
-    const res = await this.httpRequest("GET", "/api/models");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch models");
-    }
-    return res.data;
+  getModels() {
+    return this.call("GET", "/api/models", "Failed to fetch models");
   }
-  async setRunnerEnabled(runner, enabled) {
-    const res = await this.httpRequest("PUT", `/api/runners/${runner}`, { enabled });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || `Failed to ${enabled ? "enable" : "disable"} ${runner}`);
-    }
-    return res.data;
+  setRunnerEnabled(runner, enabled) {
+    return this.call("PUT", `/api/runners/${runner}`, `Failed to ${enabled ? "enable" : "disable"} ${runner}`, { enabled });
   }
-  async executePlan(sessionId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/execute`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Execute failed");
-    }
-    return res.data;
+  executePlan(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/execute`, "Execute failed");
   }
   /**
    * Sign off a plan waiting on `review_needed` and let it continue.
@@ -561,189 +559,111 @@ var ApiClient = class _ApiClient {
    * `resetForRun`) before approving, which is right for starting a plan and
    * wrong for releasing one that is already part-way through a review pause.
    */
-  async approveReview(sessionId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/review/approve`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Approve failed");
-    }
-    return res.data;
+  approveReview(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/review/approve`, "Approve failed");
   }
-  async markTaskComplete(sessionId, taskId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/complete`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Mark complete failed");
-    }
-    return res.data;
+  markTaskComplete(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/complete`, "Mark complete failed");
   }
-  async markTaskIncomplete(sessionId, taskId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/uncomplete`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Mark not done failed");
-    }
-    return res.data;
+  markTaskIncomplete(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/uncomplete`, "Mark not done failed");
   }
   /** run | force-start | retry | cancel — real orchestrator work, not a status patch. */
-  async taskControl(sessionId, taskId, action) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/${action}`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || `${action} failed`);
-    }
-    return res.data;
+  taskControl(sessionId, taskId, action) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/${action}`, `${action} failed`);
   }
   /** A user message to a structured task: delivered now if it waits for input, else queued behind its turn. */
-  async sendTaskMessage(sessionId, taskId, text) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages`, { text });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Send message failed");
-    }
-    return res.data;
+  sendTaskMessage(sessionId, taskId, text) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${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 });
+  }
+  /** Force send a message still queued; `sent` is false once the runner already has it. */
+  forceSendQueuedTaskMessage(sessionId, taskId, messageId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}/now`, "Send now failed");
   }
   /** Continue a finished structured task in its saved session, with `text` as its next turn. */
-  async continueTask(sessionId, taskId, text) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/continue`, { text });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Continue failed");
-    }
-    return res.data;
+  continueTask(sessionId, taskId, text) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/continue`, "Continue failed", { text });
   }
   /** `removed` is false once the message was already delivered. */
-  async removeQueuedTaskMessage(sessionId, taskId, messageId) {
-    const res = await this.httpRequest(
-      "DELETE",
-      `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Remove message failed");
-    }
-    return res.data;
+  removeQueuedTaskMessage(sessionId, taskId, messageId) {
+    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}`, "Remove message failed");
   }
-  async interruptTask(sessionId, taskId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/interrupt`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Interrupt failed");
-    }
-    return res.data;
+  interruptTask(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/interrupt`, "Interrupt failed");
   }
-  async addTask(sessionId, task) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks`, task);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Add task failed");
-    }
-    return res.data;
+  /** 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");
   }
-  async updateTask(sessionId, taskId, changes) {
-    const res = await this.httpRequest("PUT", `/api/plans/${sessionId}/tasks/${taskId}`, changes);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Update task failed");
-    }
-    return res.data;
+  /** 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 } : {});
   }
-  async removeTask(sessionId, taskId) {
-    const res = await this.httpRequest("DELETE", `/api/plans/${sessionId}/tasks/${taskId}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Remove task failed");
-    }
-    return res.data;
+  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);
+  }
+  removeTask(sessionId, taskId) {
+    return this.call("DELETE", `/api/plans/${sessionId}/tasks/${taskId}`, "Remove task failed");
   }
   /**
    * Make a saved session live on the server. `getSession` only reads the file;
    * until the session is adopted there is no orchestrator behind it, so
-   * execute/retry/cancel answer "Session not found".
+   * execute/retry/cancel answer `session_not_found`.
    */
   async adoptSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("POST", `/api/sessions/${sessionId}/load${qs}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to load session");
-    }
-    return { plan: res.data.plan, goal: res.data.goal ?? "" };
+    const res = await this.call("POST", `/api/sessions/${sessionId}/load${qs}`, "Failed to load session");
+    return { plan: res.plan, goal: res.goal ?? "" };
   }
-  async deleteSession(sessionId, workspace) {
+  deleteSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("DELETE", `/api/sessions/${sessionId}${qs}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Delete session failed");
-    }
-    return res.data;
+    return this.call("DELETE", `/api/sessions/${sessionId}${qs}`, "Delete session failed");
   }
   /** Copy the conversation and its tasks into a new session the daemon has already adopted. */
-  async forkConversation(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/fork`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Fork failed");
-    }
-    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan };
+  forkConversation(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/conversation/fork`, "Fork failed");
   }
   async rewindTargets(sessionId) {
-    const res = await this.httpRequest("GET", `/api/plans/${sessionId}/conversation/rewind-targets`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to list rewind targets");
-    }
-    return res.data.targets;
+    const res = await this.call("GET", `/api/plans/${sessionId}/conversation/rewind-targets`, "Failed to list rewind targets");
+    return res.targets;
   }
   /**
    * Fork the conversation from just before the user message at `index` (a
    * transcript position) into a session the daemon has already adopted. The
    * original is left as it was; `rewoundMessage` is that message in full.
    */
-  async rewindConversation(sessionId, index) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/rewind`, { index });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Rewind failed");
-    }
-    return { sessionId: res.data.sessionId, goal: res.data.goal, plan: res.data.plan, rewoundMessage: res.data.rewoundMessage };
+  rewindConversation(sessionId, index) {
+    return this.call("POST", `/api/plans/${sessionId}/conversation/rewind`, "Rewind failed", { index });
   }
   /**
    * Condense the conversation into a summary. One planner call, so it can take
    * as long as a reply; a refusal or failure leaves the conversation as it was.
    */
-  async compactConversation(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/conversation/compact`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Compaction failed");
-    }
-    return { plan: res.data.plan, summary: res.data.summary, keptMessages: res.data.keptMessages };
+  compactConversation(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/conversation/compact`, "Compaction failed");
   }
   /** The dependencies a task waits on at its merge gate (ADR-0020); empty when nothing gates it. */
   async getMergeGate(sessionId, taskId) {
-    const res = await this.httpRequest(
-      "GET",
-      `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Could not read the merge gate");
-    }
-    return res.data.mergeGate ?? [];
+    const res = await this.call("GET", `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`, "Could not read the merge gate");
+    return res.mergeGate ?? [];
   }
   async reviewRunDiff(sessionId) {
-    const res = await this.httpRequest("GET", `/api/plans/${sessionId}/isolation/diff`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Could not read the diff");
-    }
-    return res.data.diff;
+    const res = await this.call("GET", `/api/plans/${sessionId}/isolation/diff`, "Could not read the diff");
+    return res.diff;
   }
   /**
    * A conflict or a block is an outcome, not an error. Passed on whole: which
    * repos blocked the merge, or landed before it stopped, is the answer.
    */
-  async mergeRun(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/isolation/merge`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Merge failed");
-    }
-    return res.data;
+  mergeRun(sessionId) {
+    return this.call("POST", `/api/plans/${sessionId}/isolation/merge`, "Merge failed");
   }
   discardRun(sessionId) {
     return this.isolationAction(sessionId, "discard", "Discard failed");
@@ -758,17 +678,11 @@ var ApiClient = class _ApiClient {
     return this.isolationAction(sessionId, "run-without", "Could not continue without isolation");
   }
   async isolationAction(sessionId, segment, failure) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/isolation/${segment}`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || failure);
-    }
+    await this.call("POST", `/api/plans/${sessionId}/isolation/${segment}`, failure);
   }
   async resolveConflictAsTask(sessionId, taskId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/resolve-conflict`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Could not add a resolver task");
-    }
-    return res.data.plan;
+    const res = await this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/resolve-conflict`, "Could not add a resolver task");
+    return res.plan;
   }
   async closeSession(sessionId) {
     const res = await this.httpRequest("POST", `/api/sessions/${sessionId}/close`);
@@ -783,42 +697,26 @@ var ApiClient = class _ApiClient {
     const res = await this.httpRequest("POST", `/api/plans/${sessionId}/planning/stop`);
     return res.data;
   }
-  async processQueued(sessionId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/process-queued`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Process queued failed");
-    }
-    return res.data;
-  }
   async getSessions(workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
     const res = await this.httpRequest("GET", `/api/sessions${qs}`);
     return res.data || [];
   }
-  async getSession(sessionId, workspace) {
+  getSession(sessionId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest(
-      "GET",
-      `/api/sessions/${sessionId}${qs}`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Session not found");
-    }
-    return res.data;
+    return this.call("GET", `/api/sessions/${sessionId}${qs}`, "Session not found");
   }
   /** The attempts of a structured task that have a saved log, oldest first. */
   async getTaskLogAttempts(sessionId, taskId, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log${qs}`);
-    if (res.status !== 200) throw new Error(res.data?.error || "Could not read the task log");
-    return res.data.attempts;
+    const res = await this.call("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log${qs}`, "Could not read the task log");
+    return res.attempts;
   }
   /** One attempt's saved log, for `replayTaskLog`. */
   async getTaskLog(sessionId, taskId, attempt, workspace) {
     const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
-    const res = await this.httpRequest("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log/${attempt}${qs}`);
-    if (res.status !== 200) throw new Error(res.data?.error || "Could not read the task log");
-    return res.data.events;
+    const res = await this.call("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log/${attempt}${qs}`, "Could not read the task log");
+    return res.events;
   }
   /**
    * The one place a session socket is built, so the token travels on both
@@ -849,8 +747,14 @@ var ApiClient = class _ApiClient {
     });
     return socket;
   }
+  /** Ends one stream `streamExecution` returned, leaving any newer stream the session has opened since alone. */
+  closeExecutionStream(stream) {
+    this.executionStreamEnds.get(stream)?.();
+  }
   streamExecution(sessionId, onEvent, onReady) {
-    return new Promise((resolve3, reject) => {
+    let endStream = () => {
+    };
+    const stream = new Promise((resolve3, reject) => {
       this.executionStreams.get(sessionId)?.();
       const socket = this.openSessionSocket(sessionId);
       let resolved = false;
@@ -866,6 +770,7 @@ var ApiClient = class _ApiClient {
         resolve3();
       };
       this.executionStreams.set(sessionId, end);
+      endStream = end;
       socket.on("open", () => {
         opened = true;
         onReady?.();
@@ -882,8 +787,12 @@ var ApiClient = class _ApiClient {
       socket.on("error", (err) => {
         forget();
         if (!opened) onReady?.(err);
-        if (!resolved) {
-          resolved = true;
+        if (resolved) return;
+        resolved = true;
+        if (opened) {
+          socket.close();
+          resolve3("lost");
+        } else {
           reject(err);
         }
       });
@@ -892,10 +801,12 @@ var ApiClient = class _ApiClient {
         if (!opened) onReady?.(new Error("Execution stream closed before connecting"));
         if (!resolved) {
           resolved = true;
-          resolve3();
+          resolve3("lost");
         }
       });
     });
+    this.executionStreamEnds.set(stream, endStream);
+    return stream;
   }
   /**
    * Answer an approval prompt: the planner's with a yes/no, a task runner's
@@ -908,7 +819,7 @@ var ApiClient = class _ApiClient {
       `/api/approvals/${encodeURIComponent(sessionId)}/${encodeURIComponent(approvalId)}`,
       typeof answer === "boolean" ? { granted: answer } : answer
     );
-    if (status !== 200) throw new Error(`Failed to answer approval ${approvalId} (HTTP ${status})`);
+    if (status !== 200) throw new DaemonError(`Failed to answer approval ${approvalId} (HTTP ${status})`, status, data.code);
     return data;
   }
   /**
@@ -933,33 +844,17 @@ var ApiClient = class _ApiClient {
     });
     return { ready, close: () => socket.close() };
   }
-  async getCommands() {
-    const res = await this.httpRequest("GET", "/api/commands");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch commands");
-    }
-    return res.data;
+  getCommands() {
+    return this.call("GET", "/api/commands", "Failed to fetch commands");
   }
-  async sendCommand(name, args = {}) {
-    const res = await this.httpRequest("POST", `/api/commands/${name}`, { args });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || `Command ${name} failed`);
-    }
-    return res.data;
+  sendCommand(name, args = {}) {
+    return this.call("POST", `/api/commands/${name}`, `Command ${name} failed`, { args });
   }
-  async getSettings() {
-    const res = await this.httpRequest("GET", "/api/settings");
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to fetch settings");
-    }
-    return res.data;
+  getSettings() {
+    return this.call("GET", "/api/settings", "Failed to fetch settings");
   }
-  async updateSettings(changes) {
-    const res = await this.httpRequest("PATCH", "/api/settings", changes);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Failed to update settings");
-    }
-    return res.data;
+  updateSettings(changes) {
+    return this.call("PATCH", "/api/settings", "Failed to update settings", changes);
   }
 };
 
@@ -1207,11 +1102,14 @@ var import_core7 = require("@ordewell/core");
 function planTasks(plan) {
   return plan ? allTasksOf(plan) : [];
 }
+function runnersOf(plan, requested) {
+  return "runners" in plan && plan.runners || requested;
+}
 function hasCommittedPlan(plan) {
   return planTasks(plan).length > 0;
 }
 function lastPlannerMessage(plan) {
-  const history = plan?.conversationHistory || [];
+  const history = "conversationHistory" in plan && plan.conversationHistory || [];
   for (let i = history.length - 1; i >= 0; i--) {
     if (history[i].role === "assistant") return history[i].content;
   }
@@ -1273,7 +1171,7 @@ function printPlan(plan, sessionId, runners2, models) {
     return rp ? ` (${task.assignedModel.modelLabel} \xB7 ${label})` : ` (${task.assignedModel.modelLabel})`;
   };
   console.log(`
-Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${manCount} Manual) \u2014 ${(plan.runners || runners2).join(", ")}`);
+Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${manCount} Manual) \u2014 ${runnersOf(plan, runners2).join(", ")}`);
   console.log(`Session: ${sessionId}
 `);
   for (const t of tasks) {
@@ -1420,7 +1318,7 @@ ${lastPlannerMessage(plan)}
     if (isTty && lastLineLength > 0) process.stderr.write("\r\x1B[2K");
     process.stderr.write("\n");
     printPlan(plan, sessionId, runners2, models);
-    saveLastSession(sessionId, goal, plan.runners || runners2, workspace);
+    saveLastSession(sessionId, goal, runnersOf(plan, runners2), workspace);
     console.log(`
   Run 'ordewell run' to execute, 'ordewell status' to inspect, or 'ordewell tui' for the full UI.`);
   } catch (err) {
@@ -1528,9 +1426,6 @@ function repoResultLines(handoff) {
     return `${path}: ${n === 0 ? "nothing to merge" : `${n} task${n === 1 ? "" : "s"} landed`}`;
   });
 }
-function taskRepoNames(isolation) {
-  return (isolation?.repos ?? []).filter((r) => r !== ".");
-}
 function mergeOutcome(result, branch, group, repaired = []) {
   const ok = result.outcome === "merged";
   if (!group && result.outcome === "conflict") {
@@ -1541,23 +1436,27 @@ function mergeOutcome(result, branch, group, repaired = []) {
 }
 
 // src/utils/output.ts
+var import_core9 = require("@ordewell/core");
 function iconFor(status) {
-  switch (status) {
-    case "completed":
+  switch ((0, import_core9.taskStatusKind)({ status })) {
+    case "done":
       return "\x1B[32m\u2713\x1B[0m";
-    case "in_progress":
+    case "running":
+    case "quiet":
       return "\x1B[34m\u27F3\x1B[0m";
     case "failed":
       return "\x1B[31m\u2717\x1B[0m";
     case "blocked":
       return "\x1B[33m\u2298\x1B[0m";
-    default:
+    case "awaiting":
+      return "\x1B[33m?\x1B[0m";
+    case "todo":
       return "\x1B[90m\u25CB\x1B[0m";
   }
 }
 
 // src/commands/run.ts
-var import_core9 = require("@ordewell/core");
+var import_core10 = require("@ordewell/core");
 
 // src/commands/shared.ts
 var import_readline2 = require("readline");
@@ -1713,11 +1612,11 @@ async function followExecution(api, sessionId, start, onBlocked) {
   });
   const stream = api.streamExecution(sessionId, (event) => {
     if (event.type === "task_started") {
-      process.stderr.write(`\xB7 ${(0, import_core9.taskStartedNotice)(event.title, event.runner)}
+      process.stderr.write(`\xB7 ${(0, import_core10.taskStartedNotice)(event.title, event.runner)}
 `);
     }
     if (event.type === "checkpoint") {
-      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core9.truncateCheckpointSummary)(event.summary)}
+      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core10.truncateCheckpointSummary)(event.summary)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
 `);
     }
     if (event.type === "status_update" && event.tasks) {
@@ -1762,7 +1661,11 @@ Run finished on ${handoffBranch(event)}${where} \u2014 ${n} task${n === 1 ? "" :
   void stream.catch(settleReady);
   await streamReady.catch(streamFailed);
   await start();
-  await Promise.race([stream, blockedSeen]).catch(streamFailed);
+  const outcome = await Promise.race([stream, blockedSeen]).catch(streamFailed);
+  if (outcome === "lost") {
+    console.error("Lost the connection to the daemon \u2014 the run is no longer being followed, but the daemon may still be running it. `ordewell status` shows where it stands.");
+    process.exit(1);
+  }
   if (blocked === null) return;
   if (!onBlocked) {
     await api.stopExecution(sessionId);
@@ -1790,7 +1693,7 @@ async function handleRun(subArgs, injectedApi) {
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
-var import_core10 = require("@ordewell/core");
+var import_core11 = require("@ordewell/core");
 async function handleStatus(subArgs, injectedApi) {
   const sessionId = flag(subArgs, "--session-id");
   const workspace = flag(subArgs, "--workspace") || process.cwd();
@@ -1861,12 +1764,12 @@ function printOneSession(sessionId, meta, plan) {
     const icon = iconFor(t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
-    console.log(`  ${(0, import_core10.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
+    console.log(`  ${(0, import_core11.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
     for (const sub of t.subtasks || []) {
       const subIcon = iconFor(sub.status);
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
-      console.log(`    ${(0, import_core10.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
+      console.log(`    ${(0, import_core11.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
     }
   }
 }
@@ -1918,10 +1821,10 @@ async function handleWeb(subArgs) {
 }
 
 // src/commands/models.ts
-var import_core12 = require("@ordewell/core");
+var import_core13 = require("@ordewell/core");
 
 // src/commands/model.ts
-var import_core11 = require("@ordewell/core");
+var import_core12 = require("@ordewell/core");
 var USAGE = "Usage: ordewell model [show | set <model-id>]";
 async function handleModel(subArgs, injectedApi) {
   const [action, modelId] = positionals(subArgs);
@@ -1936,7 +1839,7 @@ async function handleModel(subArgs, injectedApi) {
   if (!modelId) fail(USAGE);
   const settings = await api.getSettings();
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  const runner = (0, import_core11.runnerForProvider)(provider);
+  const runner = (0, import_core12.runnerForProvider)(provider);
   if (runner) {
     const known = (await fetchCatalog(api)).models.filter((m) => m.runners?.includes(runner));
     if (known.length > 0 && !known.some((m) => m.id === modelId)) {
@@ -1955,7 +1858,7 @@ async function showModels(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const current = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const runner = (0, import_core11.runnerForProvider)(provider);
+  const runner = (0, import_core12.runnerForProvider)(provider);
   const options = runner ? catalog.models.filter((m) => m.runners?.includes(runner)) : catalog.orchestratorModels;
   console.log(`
 Planner model: ${current || "(backend default)"}`);
@@ -1989,8 +1892,8 @@ async function handleModels(subArgs) {
     const rest = subArgs.filter((_, i) => i !== setIdx && i !== setIdx + 1);
     return handleModel(["set", subArgs[setIdx + 1], ...rest]);
   }
-  const config = new import_core12.EnvConfig();
-  const providers = (0, import_core12.configuredProviders)(config);
+  const config = new import_core13.EnvConfig();
+  const providers = (0, import_core13.configuredProviders)(config);
   if (providers.length === 0) {
     console.error("No providers configured. Set an API key for a provider, e.g.:");
     console.error("  OPENROUTER_API_KEY=...   (OpenRouter)");
@@ -1999,19 +1902,19 @@ async function handleModels(subArgs) {
     console.error("  OPENAI_COMPATIBLE_BASE_URL=...  (self-hosted / OpenAI-compatible)");
     process.exit(1);
   }
-  const { apiKeys, baseUrls } = (0, import_core12.collectProviderCredentials)(config);
+  const { apiKeys, baseUrls } = (0, import_core13.collectProviderCredentials)(config);
   let models;
   let errors;
   try {
-    const result = await (0, import_core12.fetchAllProviderModels)({ apiKeys, baseUrls });
-    models = (0, import_core12.toOrchestratorOptions)(result.models, import_core12.ORCHESTRATOR_SHORTCUTS);
+    const result = await (0, import_core13.fetchAllProviderModels)({ apiKeys, baseUrls });
+    models = (0, import_core13.toOrchestratorOptions)(result.models, import_core13.ORCHESTRATOR_SHORTCUTS);
     errors = result.errors;
   } catch (err) {
     console.error(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
     return;
   }
-  const providerLabel = (p) => (0, import_core12.getProviderMeta)(p)?.label ?? p;
+  const providerLabel = (p) => (0, import_core13.getProviderMeta)(p)?.label ?? p;
   console.log(
     `
 Available models (${models.length}) across ${providers.length} configured provider(s):`
@@ -2051,7 +1954,7 @@ ${providerLabel(provider)}`);
 
 // src/commands/setup.ts
 var import_fs6 = require("fs");
-var import_core13 = require("@ordewell/core");
+var import_core14 = require("@ordewell/core");
 function handleSetup(subArgs) {
   const modelIdx = subArgs.indexOf("--model");
   const chosenModel = modelIdx !== -1 ? subArgs[modelIdx + 1] : null;
@@ -2123,15 +2026,15 @@ function handleSetup(subArgs) {
 # STEPFUN_API_KEY=...
 # SILICONFLOW_API_KEY=...
 `;
-  (0, import_core13.writePrivateFile)(envFile, content);
+  (0, import_core14.writePrivateFile)(envFile, content);
   console.log(`Wrote: ${envFile}`);
   console.log("Review and edit the file, then run: ordewell tui");
 }
 
 // src/commands/plugins.ts
-var import_core14 = require("@ordewell/core");
+var import_core15 = require("@ordewell/core");
 function handlePlugins(subArgs) {
-  const registry = new import_core14.RunnerRegistry();
+  const registry = new import_core15.RunnerRegistry();
   registry.loadUserPlugins();
   const sub = subArgs[0];
   if (sub === "list" || !sub) {
@@ -2167,7 +2070,7 @@ ${plugins.length} plugin(s):
       process.exit(1);
     }
     try {
-      const resolved = (0, import_core14.classifyPluginSource)(source);
+      const resolved = (0, import_core15.classifyPluginSource)(source);
       const manifest = resolved.kind === "git" ? registry.installFromGit(resolved.url) : registry.installFromPath(resolved.path);
       console.log(`Installed plugin: ${manifest.name} v${manifest.version}`);
     } catch (err) {
@@ -2345,6 +2248,7 @@ async function handleTransport(subArgs, api) {
 }
 
 // src/commands/task-control.ts
+var import_core16 = require("@ordewell/core");
 var PAST_TENSE = {
   run: "Task started.",
   "force-start": "Task force-started.",
@@ -2387,7 +2291,7 @@ async function confirmPastGate(subArgs, api, sessionId, taskId, confirm) {
   if (hasFlag(subArgs, "--yes")) return;
   const unmerged = await api.getMergeGate(sessionId, taskId).catch(() => []);
   if (unmerged.length === 0) return;
-  const question = `This task waits for Merge all: the work of ${unmerged.map((d) => `#${d.order} ${d.title}`).join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task. Start it anyway?`;
+  const question = `${(0, import_core16.pastGateConfirmation)(unmerged.map((d) => (0, import_core16.titledTaskRef)(d)))} Start it anyway?`;
   if (!await confirm(question)) fail("Not started \u2014 nothing was changed. Pass --yes to start it without a prompt.");
 }
 function makeHandler(action, command = action) {
@@ -2427,6 +2331,30 @@ async function handleContinue(subArgs, injectedApi) {
     }
   });
 }
+async function handleCheckpoint(subArgs, injectedApi) {
+  const usage = "Usage: ordewell checkpoint <task-id-or-order> approve|reject [reason] [--session-id <id>] [--workspace /path]";
+  const [, answer, ...words] = positionals(subArgs);
+  const reason = words.join(" ").trim();
+  if (answer !== "approve" && answer !== "reject") {
+    console.error(usage);
+    process.exit(1);
+  }
+  if (answer === "approve" && reason) {
+    console.error(`Approving takes no note \u2014 reject with a reason to tell the task something.
+${usage}`);
+    process.exit(1);
+  }
+  await withResolvedTask(subArgs, usage, injectedApi, async (api, sessionId, taskId) => {
+    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.");
+    } catch (err) {
+      console.error(`Failed to ${answer} checkpoint: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
 var handleRunTask = makeHandler("run", "run-task");
 var handleForceStart = makeHandler("force-start");
 var handleRetry = makeHandler("retry");
@@ -2676,24 +2604,24 @@ async function handleRewind(subArgs, injectedApi) {
 }
 
 // src/tui/transcript.ts
-var import_core15 = require("@ordewell/core");
+var import_core17 = require("@ordewell/core");
 function show(state, { view: conversation, gate: turnGate }) {
   const gated = turnGate === state.turnGate ? state : { ...state, turnGate };
   if (conversation === state.conversation) return gated;
   return { ...gated, conversation };
 }
 function fold(state, input) {
-  return show(state, { view: (0, import_core15.reduceConversation)(state.conversation, input), gate: state.turnGate });
+  return show(state, { view: (0, import_core17.reduceConversation)(state.conversation, input), gate: state.turnGate });
 }
 function say(state, role, text) {
   const said = fold(state, { type: "local_entry", role, text });
   return said.conversation.nextId > state.conversation.nextId ? { ...said, scroll: 0 } : said;
 }
 function hear(state, message) {
-  return show(state, (0, import_core15.followTurn)(state.conversation, state.turnGate, message));
+  return show(state, (0, import_core17.followTurn)(state.conversation, state.turnGate, message));
 }
 function cutTurn(state) {
-  return show(state, (0, import_core15.stopTurn)(state.conversation, state.turnGate));
+  return show(state, (0, import_core17.stopTurn)(state.conversation, state.turnGate));
 }
 function wiped(view) {
   return { ...view, blocks: view.blocks.filter((b) => b.type === "usage") };
@@ -2919,12 +2847,12 @@ function runHandoffAction(state, id) {
           overlay: isRepoGroup(handoff) ? {
             kind: "confirm",
             title: "Merge all into your branches?",
-            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. Ordewell never does this on its own. 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.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. Ordewell never does this on its own. 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 \u2014 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. Ordewell never does this on its own. 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.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. Ordewell never does this on its own. 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 \u2014 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" }
           }
         },
@@ -3107,26 +3035,17 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core16 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 
 // src/plannerModelSwitch.ts
-function describePlannerSwitch(settings, provider) {
-  const model = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const effort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  if (!model) return { model: "", effort: "", source: "none" };
-  return rememberedModelFor(settings, provider) === model ? { model, effort, source: "remembered" } : { model, effort, source: "catalog-default" };
-}
-function rememberedModelFor(settings, provider) {
-  const map = settings.plannerModels;
-  if (!map || typeof map !== "object") return void 0;
-  const entry = map[provider];
-  if (!entry || typeof entry !== "object") return void 0;
-  const { model } = entry;
-  return typeof model === "string" ? model : void 0;
+function plannerSwitchRecall(settings) {
+  if (settings.switchRecall) return settings.switchRecall;
+  const model = settings.orchestratorModel;
+  return model ? { model, effort: settings.plannerThinkingEffort, source: "remembered" } : { model: "", effort: "", source: "none" };
 }
 
 // src/commands/planner.ts
-var KNOWN_PROVIDERS = Object.keys(import_core16.ALL_PROVIDERS);
+var isAiProvider = (id) => Object.hasOwn(import_core18.ALL_PROVIDERS, id);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -3135,19 +3054,19 @@ async function handlePlanner(subArgs, injectedApi) {
     return;
   }
   const provider = wanted.toLowerCase();
-  if (!KNOWN_PROVIDERS.includes(provider)) {
+  if (!isAiProvider(provider)) {
     fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
   }
   const settings = await persistEnv(api, { AI_PROVIDER: provider });
-  const recall2 = describePlannerSwitch(settings, provider);
+  const recall2 = plannerSwitchRecall(settings);
   writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
-  const meta = import_core16.ALL_PROVIDERS[provider];
+  const meta = import_core18.ALL_PROVIDERS[provider];
   const catalog = await fetchCatalog(api);
   console.log(
-    (0, import_core16.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
+    (0, import_core18.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
   console.log(plannerModelLine(recall2));
-  if (!(0, import_core16.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+  if (!(0, import_core18.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
     console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
@@ -3165,15 +3084,15 @@ async function showPlanners(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
-  for (const id of import_core16.CLI_PROVIDERS) {
-    const runner = (0, import_core16.runnerForProvider)(id);
+  for (const id of import_core18.CLI_PROVIDERS) {
+    const runner = (0, import_core18.runnerForProvider)(id);
     const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core16.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core18.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
   }
   console.log("\nAPI providers");
-  for (const id of import_core16.PROVIDER_PRIORITY) {
+  for (const id of import_core18.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core16.ALL_PROVIDERS[id];
+    const meta = import_core18.ALL_PROVIDERS[id];
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -3190,7 +3109,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
   const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  const runner = (0, import_core16.runnerForProvider)(provider);
+  const runner = isAiProvider(provider) ? (0, import_core18.runnerForProvider)(provider) : null;
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -3230,7 +3149,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core17 = require("@ordewell/core");
+var import_core19 = require("@ordewell/core");
 var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
 async function handleParallel(subArgs, injectedApi) {
   const [wanted] = positionals(subArgs);
@@ -3240,14 +3159,14 @@ async function handleParallel(subArgs, injectedApi) {
     console.log(`Up to ${String(settings.maxParallel ?? "?")} AI tasks run at once. Change with: ordewell parallel <n>`);
     return;
   }
-  const limit = (0, import_core17.parseMaxParallel)(wanted);
+  const limit = (0, import_core19.parseMaxParallel)(wanted);
   if (limit === null) fail(`"${wanted}" is not a number of tasks (1 or more).`, USAGE5);
   await persistEnv(api, { ORDEWELL_MAX_PARALLEL: String(limit) });
   console.log(`Up to ${limit} AI task${limit === 1 ? "" : "s"} now run at once.`);
 }
 
 // src/commands/key.ts
-var import_core18 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 var USAGE6 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
@@ -3258,8 +3177,8 @@ async function handleKey(subArgs, injectedApi) {
   if (action !== "set") {
     const catalog = await fetchCatalog(api);
     console.log("\nAPI provider keys\n");
-    for (const id2 of import_core18.PROVIDER_PRIORITY) {
-      const meta2 = import_core18.ALL_PROVIDERS[id2];
+    for (const id2 of import_core20.PROVIDER_PRIORITY) {
+      const meta2 = import_core20.ALL_PROVIDERS[id2];
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
@@ -3269,7 +3188,7 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core18.ALL_PROVIDERS[id];
+  const meta = import_core20.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -3280,7 +3199,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var import_core19 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 var USAGE7 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
@@ -3311,15 +3230,15 @@ function handleAuto(subArgs) {
   const currentRaw = process.env.ORDEWELL_AUTONOMOUS_MODE;
   const current = currentRaw !== "false" && currentRaw !== "0";
   if (!arg) {
-    console.log(`Autonomy level: ${(0, import_core19.autonomyLevelLabel)(current)}`);
+    console.log(`Autonomy level: ${(0, import_core21.autonomyLevelLabel)(current)}`);
     console.log(`  ${AUTO_USAGE}`);
     return;
   }
-  const enabled = (0, import_core19.parseAutonomyLevel)(arg);
+  const enabled = (0, import_core21.parseAutonomyLevel)(arg);
   if (enabled === null) fail(AUTO_USAGE);
   writeEnvVar(findEnvFile(), "ORDEWELL_AUTONOMOUS_MODE", String(enabled));
   process.env.ORDEWELL_AUTONOMOUS_MODE = String(enabled);
-  console.log(`Autonomy level: ${(0, import_core19.autonomyLevelLabel)(enabled)} for new sessions.`);
+  console.log(`Autonomy level: ${(0, import_core21.autonomyLevelLabel)(enabled)} for new sessions.`);
 }
 async function handleRefresh(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
@@ -3351,7 +3270,7 @@ async function handleApprove(subArgs, injectedApi) {
 // src/tui/terminalLauncher.ts
 var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core20 = require("@ordewell/core");
+var import_core22 = require("@ordewell/core");
 var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
 var defaultExecFile = async (command, args) => {
   const { stdout, stderr } = await execFileAsync(command, args);
@@ -3371,16 +3290,16 @@ var defaultWhich = (bin) => {
 async function openTaskTerminal(port, planSessionId, taskId, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
-  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core20.hasTmux;
+  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core22.hasTmux;
   const execFileImpl = deps.execFileImpl ?? defaultExecFile;
   const spawnImpl = deps.spawnImpl ?? defaultSpawn;
   const which = deps.which ?? defaultWhich;
   if (!hasTmuxImpl()) {
     return { ok: false, message: "No terminal window for this task: tmux is not installed. Install tmux to get one for terminal-transport tasks; a structured task has its log view instead." };
   }
-  const session = (0, import_core20.tmuxSessionName)(port);
-  const socket = (0, import_core20.tmuxSocketName)(port);
-  const base = (0, import_core20.tmuxWindowName)(taskId, planSessionId);
+  const session = (0, import_core22.tmuxSessionName)(port);
+  const socket = (0, import_core22.tmuxSocketName)(port);
+  const base = (0, import_core22.tmuxWindowName)(taskId, planSessionId);
   let windows;
   try {
     const { stdout } = await execFileImpl("tmux", ["-L", socket, "list-windows", "-t", session, "-F", "#{window_name}"]);
@@ -3529,7 +3448,7 @@ async function handleTaskRunner(subArgs, injectedApi) {
     const state = await api.getRunners();
     if (!runner) {
       console.log(`
-Runner \xB7 #${task.order} ${task.title}
+Runner \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}
 `);
       for (const r of state.runners) {
         console.log(`  ${r.id === task.assignedRunner ? "*" : " "} ${r.id.padEnd(14)} ${r.name}${r.enabled ? "" : "  (not enabled for planning)"}`);
@@ -3542,7 +3461,7 @@ Runner \xB7 #${task.order} ${task.title}
       fail(`Unknown runner: ${runner}`, `This daemon knows: ${state.runners.map((r) => r.id).join(", ")}`);
     }
     await api.updateTask(sessionId, task.id, { assignedRunner: runner });
-    console.log(`Task #${task.order} runner set to ${runner} \u2014 its model, effort and mode were re-picked for it.`);
+    console.log(`Task ${(0, import_plan_utils.taskRef)(task)} runner set to ${runner} \u2014 its model, effort and mode were re-picked for it.`);
   });
 }
 var MODEL_USAGE = "Usage: ordewell task-model <task-id-or-order> [<model-id>] [--session-id <id>]";
@@ -3552,7 +3471,7 @@ async function handleTaskModel(subArgs, injectedApi) {
     const options = modelsForTask(catalog.models, task);
     if (!modelId) {
       console.log(`
-Model \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
+Model \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
 `);
       if (options.length === 0) console.log("  No models discovered for this runner \u2014 try `ordewell refresh`.");
       for (const m of options) {
@@ -3575,7 +3494,7 @@ Model \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assigne
       assignedModel,
       thinkingEffort: assignedModel.thinkingEffort ?? null
     });
-    console.log(`Task #${task.order} model set to ${model.label}.`);
+    console.log(`Task ${(0, import_plan_utils.taskRef)(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.`);
     }
@@ -3589,7 +3508,7 @@ async function handleTaskEffort(subArgs, injectedApi) {
     const current = task.assignedModel?.thinkingEffort;
     if (!level) {
       console.log(`
-Thinking effort \xB7 #${task.order} ${task.title}
+Thinking effort \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}
 `);
       console.log(`  ${current ? " " : "*"} default        Let the executor choose`);
       for (const v of variants) {
@@ -3614,7 +3533,7 @@ Thinking effort \xB7 #${task.order} ${task.title}
       assignedModel: task.assignedModel ? { ...task.assignedModel, thinkingEffort } : void 0,
       thinkingEffort: thinkingEffort ?? null
     });
-    console.log(`Task #${task.order} thinking effort set to ${thinkingEffort ?? "runner default"}.`);
+    console.log(`Task ${(0, import_plan_utils.taskRef)(task)} thinking effort set to ${thinkingEffort ?? "runner default"}.`);
   });
 }
 var MODE_USAGE = "Usage: ordewell task-mode <task-id-or-order> [<mode>] [--session-id <id>]";
@@ -3624,7 +3543,7 @@ async function handleTaskMode(subArgs, injectedApi) {
     const modes = modesForTask(catalog.modesByRunner, task);
     if (!mode) {
       console.log(`
-Mode \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
+Mode \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
 `);
       if (modes.length === 0) {
         console.log("  This task has no runner, or its runner declares no modes.");
@@ -3643,7 +3562,7 @@ Mode \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assigned
       );
     }
     await api.updateTask(sessionId, task.id, { taskMode: chosen.id });
-    console.log(`Task #${task.order} mode set to ${chosen.label}.`);
+    console.log(`Task ${(0, import_plan_utils.taskRef)(task)} mode set to ${chosen.label}.`);
   });
 }
 var DEPS_USAGE = "Usage: ordewell task-deps <task-id-or-order> [<id,id,\u2026>|none] [--session-id <id>]";
@@ -3652,14 +3571,14 @@ async function handleTaskDeps(subArgs, injectedApi) {
     const candidates = (0, import_plan_utils.dependencyCandidates)(tasks, task.id);
     if (!value) {
       console.log(`
-Dependencies \xB7 #${task.order} ${task.title}
+Dependencies \xB7 ${(0, import_plan_utils.titledTaskRef)(task)}
 `);
       if (candidates.length === 0) {
-        console.log(`  Nothing runs before #${task.order}, so it has no possible dependencies.`);
+        console.log(`  Nothing runs before ${(0, import_plan_utils.taskRef)(task)}, so it has no possible dependencies.`);
       }
       for (const c of candidates) {
         const chosen = task.dependencies.includes(c.id);
-        console.log(`  ${chosen ? "*" : " "} ${c.id}  #${c.order} ${c.title}${c.status === "completed" ? "  (already completed)" : ""}`);
+        console.log(`  ${chosen ? "*" : " "} ${c.id}  ${(0, import_plan_utils.titledTaskRef)(c)}${c.status === "completed" ? "  (already completed)" : ""}`);
       }
       console.log(`
   * = current. ${DEPS_USAGE}`);
@@ -3669,7 +3588,7 @@ Dependencies \xB7 #${task.order} ${task.title}
     const check = (0, import_plan_utils.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 #${task.order} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`);
+    console.log(dependencies.length > 0 ? `Task ${(0, import_plan_utils.taskRef)(task)} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task ${(0, import_plan_utils.taskRef)(task)} no longer depends on anything.`);
   });
 }
 var OPS_USAGE = "Usage: ordewell task-ops <task-id-or-order> [on|off] [--session-id <id>]";
@@ -3677,7 +3596,7 @@ async function handleTaskOps(subArgs, injectedApi) {
   await withTask(subArgs, OPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
     if (!value) {
       console.log(`
-#${task.order} ${task.title} is ${task.ops ? "an ops task: it runs in your checkout once the work it depends on is merged" : "a change task: it runs in its own worktree"}.`);
+${(0, import_plan_utils.titledTaskRef)(task)} is ${task.ops ? "an ops task: it runs in your checkout once the work it depends on is merged" : "a change task: it runs in its own worktree"}.`);
       console.log(`
   ${OPS_USAGE}`);
       return;
@@ -3687,12 +3606,12 @@ async function handleTaskOps(subArgs, injectedApi) {
     if (task.type !== "ai") fail("Only an AI task can be an ops task \u2014 a manual task already runs outside any worktree.");
     if (!tasks.some((t) => t.id === task.id)) fail("A subtask runs with its parent; make the parent an ops task instead.");
     await api.updateTask(sessionId, task.id, { ops: to === "on" });
-    console.log(to === "on" ? `Task #${task.order} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task #${task.order} is a change task: it runs in its own worktree.`);
+    console.log(to === "on" ? `Task ${(0, import_plan_utils.taskRef)(task)} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task ${(0, import_plan_utils.taskRef)(task)} is a change task: it runs in its own worktree.`);
   });
 }
 
 // src/tui/index.ts
-var import_core33 = require("@ordewell/core");
+var import_core37 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3841,6 +3760,7 @@ var SLASH_COMMANDS = [
   { 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: "continue", usage: "/continue <id> <message>", description: "Continue a finished task in its saved runner session, with your message", 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" },
   { name: "terminal", usage: "/terminal <id>", description: "Open a task: its OS terminal, or a structured task's live log", category: "tasks" },
   { name: "task-runner", usage: "/task-runner <id> [runner]", description: "Choose or set a task's executor (re-picks its model and mode)", category: "tasks" },
   { name: "task-model", usage: "/task-model <id> [model]", description: "Choose or set a task's executor model", category: "tasks" },
@@ -3941,7 +3861,7 @@ function tokenCompletions(token) {
 }
 
 // src/tui/blocks.ts
-var import_core21 = require("@ordewell/core");
+var import_core23 = require("@ordewell/core");
 
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
@@ -4161,16 +4081,16 @@ function resultLines(block, room, detailAll) {
   const fit2 = (line) => detailAll ? wrap(line, room) : [truncate(line, room)];
   const outcome = unsettledOutcome(block);
   if (outcome) {
-    const [reason, ...rest] = (0, import_core21.outputLines)(block.output).map(sanitize);
+    const [reason, ...rest] = (0, import_core23.outputLines)(block.output).map(sanitize);
     const status = fit2(reason ? `${outcome.label}: ${reason}` : outcome.label).map(outcome.paint);
     return detailAll ? [...status, ...rest.flatMap(fit2).map(style.grey)] : status;
   }
   if (detailAll) {
-    const lines2 = (0, import_core21.outputLines)(block.output).map(sanitize);
+    const lines2 = (0, import_core23.outputLines)(block.output).map(sanitize);
     const note = lines2.length > PREVIEW_LINES ? ["\u2026 (ctrl+o to collapse)"] : [];
     return lines2.length > 0 ? [...lines2.flatMap(fit2), ...note].map(style.grey) : [style.grey("(no output)")];
   }
-  const { lines, hiddenLineCount } = (0, import_core21.outputPreview)(block.output, PREVIEW_LINES);
+  const { lines, hiddenLineCount } = (0, import_core23.outputPreview)(block.output, PREVIEW_LINES);
   if (lines.length === 0) return [style.grey("(no output)")];
   const more = hiddenLineCount > 0 ? [`\u2026 +${countOf(hiddenLineCount, "line")} (ctrl+o to expand)`] : [];
   return [...lines.map(sanitize), ...more].map((line) => style.grey(truncate(line, room)));
@@ -4184,7 +4104,7 @@ var DIFF_PAINT = {
 };
 var DIFF_SIGN = { added: "+", removed: "-", context: " ", gap: "" };
 function diffLines(block, diff, room, detailAll) {
-  const rows = (0, import_core21.diffRows)(block.output);
+  const rows = (0, import_core23.diffRows)(block.output);
   const gutter = Math.max(0, ...rows.map((row) => String(row.line ?? "").length));
   const draw = (row) => {
     const text = row.kind === "gap" ? `${" ".repeat(gutter)} \u22EE` : `${String(row.line ?? "").padStart(gutter)} ${DIFF_SIGN[row.kind]} ${sanitize(row.text)}`;
@@ -4193,7 +4113,7 @@ function diffLines(block, diff, room, detailAll) {
   const shown = detailAll ? rows : rows.slice(0, DIFF_PREVIEW_ROWS);
   const hidden = rows.length - shown.length;
   const more = hidden > 0 ? [style.grey(`\u2026 +${countOf(hidden, "line")} (ctrl+o to expand)`)] : [];
-  return [(0, import_core21.diffSummary)(diff), ...shown.flatMap(draw), ...more];
+  return [(0, import_core23.diffSummary)(diff), ...shown.flatMap(draw), ...more];
 }
 function toolLines(block, cols, detailAll) {
   const room = Math.max(1, cols - OUTPUT_INDENT.length);
@@ -4249,6 +4169,19 @@ function approvalLine(block, cols) {
   const line = `${mark} ${status} \xB7 ${APPROVAL_KIND[block.kind]}: ${firstLine(block.subject)}${note}`;
   return `${paint(mark)}${truncate(line, cols).slice(mark.length)}`;
 }
+function approvalKeysLine(block, cols) {
+  const keys = ["ctrl-y allow", ...block.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"];
+  return style.grey(truncate(`  ${keys.join(" \xB7 ")}`, cols));
+}
+function checkpointCardLines(order, question, cols, approvalFirst) {
+  const room = Math.max(1, cols - 2);
+  const keys = approvalFirst ? "answer the tool request above first (ctrl-y / ctrl-g), then ctrl-y approves \xB7 ctrl-g rejects (composer text is the reason)" : "ctrl-y approve \xB7 ctrl-g reject (composer text is the reason)";
+  return [
+    truncate(`${style.accent("\u25C6")} ${style.bold(`Task ${order} asks`)}`, cols),
+    ...wrap(sanitize(question).trim(), room).map((line) => `  ${line}`),
+    ...wrap(keys, room).map((line) => style.grey(`  ${line}`))
+  ];
+}
 function planLine(block, cols) {
   const count = block.taskCount === void 0 ? "" : ` (${countOf(block.taskCount, "task")})`;
   const text = block.status === "building" ? "Building plan\u2026" : `Plan ${block.status}${count}`;
@@ -4281,11 +4214,13 @@ function drawn(block, cols, detailAll) {
   drawnBlocks.set(block, { cols, detailAll, lines });
   return lines;
 }
-function conversationLines(blocks, cols, detailAll) {
+function conversationLines(blocks, cols, detailAll, answering) {
   const lines = [];
   for (const block of blocks) {
     if (block.type === "usage") continue;
-    lines.push(...drawn(block, cols, detailAll), "");
+    lines.push(...drawn(block, cols, detailAll));
+    if (block === answering) lines.push(approvalKeysLine(block, cols));
+    lines.push("");
   }
   return lines;
 }
@@ -4313,7 +4248,7 @@ function tokenLine(blocks, cols) {
 }
 
 // src/tui/state.ts
-var import_core22 = require("@ordewell/core");
+var import_core24 = require("@ordewell/core");
 var SKILL_IDS = ["tdd", "verify"];
 function noSkills() {
   return { tdd: false, verify: false };
@@ -4325,8 +4260,7 @@ function visibleItems(picker2) {
     (i) => i.id.toLowerCase().includes(filter) || i.label.toLowerCase().includes(filter) || (i.detail ?? "").toLowerCase().includes(filter)
   );
 }
-var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
-var anyTaskRunning = (state) => state.tasks.some(isTaskRunning);
+var anyTaskRunning = (state) => state.tasks.some(import_core24.isTaskRunning);
 var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
 function planRows(state) {
   const rows = [];
@@ -4346,6 +4280,9 @@ function selectedPlanRow(state) {
 function waitingApproval(tv) {
   return tv.view.blocks.find((b) => b.type === "approval" && b.status === "pending" && b.approvalId !== void 0);
 }
+function waitingCheckpoint(task) {
+  return task?.status === "awaiting_user" && task.awaitingReason === "checkpoint" ? task.checkpoint : void 0;
+}
 function continuesTask(task) {
   return task?.continuable === true && (task.status === "completed" || task.status === "failed");
 }
@@ -4360,9 +4297,9 @@ function findTask(tasks, id) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core22.EMPTY_CONVERSATION,
+    conversation: import_core24.EMPTY_CONVERSATION,
     taskView: null,
-    turnGate: import_core22.NO_TURN,
+    turnGate: import_core24.NO_TURN,
     detailAll: false,
     status: "idle",
     busyLabel: "",
@@ -4387,7 +4324,7 @@ function initialState(overrides = {}) {
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
-    maxParallel: import_core22.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core24.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
@@ -4399,7 +4336,7 @@ function initialState(overrides = {}) {
     gate: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core22.EMPTY_HOLD,
+    queuedPrompts: import_core24.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4447,7 +4384,7 @@ function chatEditorRoomFor(state, active) {
 }
 
 // src/tui/layout.ts
-var import_core23 = require("@ordewell/core");
+var import_core25 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -4456,7 +4393,7 @@ function chatInputWrap(state) {
 }
 function footerHints(state) {
   const selected = selectedPlanRow(state)?.task;
-  const markHint = selected?.status === "completed" ? "m undone" : "m done";
+  const markHint = selected && (0, import_core25.markAction)(selected) === "uncomplete" ? "m undone" : "m done";
   const resolveHint = selected?.isolation?.state === "conflict" ? ["x resolve conflict"] : [];
   const planning = plannerInFlight(state) && !state.taskView;
   const escHint = !planning ? null : state.queuedPrompts.length > 0 ? "esc unsend" : "esc \xD72 stop planning";
@@ -4487,7 +4424,7 @@ function footerHints(state) {
       "tab chat"
     ];
   }
-  const detailHint = (0, import_core23.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
+  const detailHint = (0, import_core25.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
   return [
     "/help",
     "tab plan",
@@ -4508,20 +4445,25 @@ function queuedBubble(text, cols) {
 function taskQueuedRows(state, cols) {
   const tv = state.taskView;
   if (!tv) return [];
-  return tv.view.queued.flatMap((message, i) => queuedTaskBubble(message.text, i === tv.queuedIndex, cols));
+  return tv.view.queued.flatMap((message, i) => queuedTaskBubble(message, i === tv.queuedIndex, cols));
+}
+function queuedTaskTag({ handedOver, forced }, selected) {
+  if (forced) return " \xB7 sending now";
+  if (handedOver) return " \xB7 handed over";
+  return selected ? " \xB7 queued \xB7 ctrl-r removes" : " \xB7 queued";
 }
-function queuedTaskBubble(text, selected, cols) {
+function queuedTaskBubble(message, selected, cols) {
+  const { text } = message;
   const marker2 = selected ? style.accent("\u276F") : style.grey("\u25C7");
-  const tag = selected ? " \xB7 queued \xB7 ctrl-r removes" : " \xB7 queued";
+  const tag = queuedTaskTag(message, selected);
   const room = Math.max(1, cols - width(`\u276F \u25C7  ${tag}`));
   return wrap(text, room).map((line, i) => i === 0 ? truncate(`${marker2} ${selected ? style.bold(line) : line}${style.grey(tag)}`, cols) : truncate(`  ${line}`, cols));
 }
 function taskActivity(task, working) {
-  if (task?.awaitingApproval) return approvalLabel(task.awaitingApproval);
+  const approvals = (0, import_core25.approvalLabel)(task?.awaitingApproval);
+  if (approvals) return inRow(approvals);
   if (working) return "working";
-  if (task?.status === "awaiting_user") {
-    return task.awaitingReason ? AWAITING_LABEL[task.awaitingReason] : "waiting for your input";
-  }
+  if (task?.status === "awaiting_user") return inRow((0, import_core25.awaitingLabel)(task) ?? "Waiting for your input");
   return task?.status ?? "";
 }
 function taskHeaderLines(state, tv, cols) {
@@ -4533,7 +4475,8 @@ function taskHeaderLines(state, tv, cols) {
     taskActivity(task, tv.view.working)
   ].filter(Boolean);
   const approval = waitingApproval(tv);
-  const hint = approval ? ["ctrl-y allow", ...approval.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"] : ["ctrl-r remove queued", "ctrl-x interrupt"];
+  const hint = approval ? ["ctrl-y allow", ...approval.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"] : waitingCheckpoint(task) ? ["ctrl-y approve", "ctrl-g reject (composer text is the reason)", "ctrl-x interrupt"] : ["ctrl-r remove queued", "ctrl-x interrupt", "ctrl-s send now"];
+  if (approval && waitingCheckpoint(task)) hint.push("then the checkpoint");
   const index = tv.attempts.indexOf(tv.attempt);
   if (tv.attempts.length > 1) hint.push(`alt\u2190/\u2192 attempt ${index >= 0 ? index + 1 : 1}/${tv.attempts.length}`);
   hint.push("esc back");
@@ -4566,10 +4509,10 @@ function bodyRows(state) {
   return Math.max(0, state.rows - CHROME_ROWS - input - footer + 2);
 }
 var chatBodyMemo = null;
-function chatBodyLines(blocks, cols, detailAll) {
+function chatBodyLines(blocks, cols, detailAll, answering) {
   const memo = chatBodyMemo;
   if (memo && memo.blocks === blocks && memo.cols === cols && memo.detailAll === detailAll) return memo.lines;
-  const lines = conversationLines(blocks, cols, detailAll);
+  const lines = conversationLines(blocks, cols, detailAll, answering);
   chatBodyMemo = { blocks, cols, detailAll, lines };
   return lines;
 }
@@ -4577,7 +4520,10 @@ function chatLayout(state, rows, cols) {
   const tv = state.taskView;
   const blocks = tv ? tv.view.blocks : state.conversation.blocks;
   const welcome = !tv && state.tasks.length === 0;
-  const body = chatBodyLines(blocks, cols, state.detailAll);
+  const checkpoint = tv ? waitingCheckpoint(findTask(state.tasks, tv.taskId)) : void 0;
+  const card = tv && checkpoint ? checkpointCardLines(findTask(state.tasks, tv.taskId)?.order ?? 0, checkpoint, cols, waitingApproval(tv) !== void 0) : [];
+  const answering = chatBodyLines(blocks, cols, state.detailAll, tv ? waitingApproval(tv) : void 0);
+  const body = card.length > 0 ? [...answering, ...card] : answering;
   const transcript = !welcome ? body : body.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
   const bubbles = tv ? taskQueuedRows(state, cols) : queuedPromptRows(state, cols);
   const lines = [...transcript, ...bubbles.length > 0 ? ["", ...bubbles] : []];
@@ -4592,9 +4538,9 @@ function chatScrollMax(state) {
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core23.ALL_PROVIDERS[provider];
+  const registration = import_core25.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core23.runnerForProvider)(provider);
+  const runner = (0, import_core25.runnerForProvider)(provider);
   const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
@@ -4681,45 +4627,34 @@ function welcomeLines(state, cols) {
   return lines;
 }
 var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var STATUS_MARK = {
-  completed: style.green,
+var STATUS_PAINT = {
+  done: style.green,
   running: style.yellow,
-  in_progress: style.yellow,
+  quiet: style.cyan,
   failed: style.red,
   blocked: style.red,
-  awaiting_user: style.yellow,
-  cancelled: style.grey,
-  skipped: style.grey
+  awaiting: style.yellow,
+  todo: (text) => text
 };
 var STATUS_ICON = {
-  completed: "\u2713",
+  done: "\u2713",
   failed: "\u2717",
   blocked: "!",
-  awaiting_user: "?",
-  cancelled: "\u2212",
-  skipped: "\u2212",
-  approved: "\xB7",
-  pending: "\xB7"
-};
-var AWAITING_LABEL = {
-  input: "waiting for your input",
-  checkpoint: "checkpoint",
-  conflict: "merge conflict",
-  "files-changed": "changed tracked files"
+  awaiting: "?",
+  quiet: "~",
+  todo: "\xB7"
 };
-function approvalLabel(count) {
-  return count > 1 ? `waiting for approval (${count})` : "waiting for approval";
-}
-var IDLE_ICON = "~";
+var inRow = (label) => label.charAt(0).toLowerCase() + label.slice(1);
 var FIRST_ROW_LINE = 2;
 function planLayout(state, rows, cols) {
   const done = state.tasks.filter((t) => t.status === "completed").length;
   const lines = [style.bold(`Plan ${done}/${state.tasks.length}`), ""];
   const rowSpans = [];
+  const orderOf = new Map(state.tasks.map((task) => [task.id, task.order]));
   let editorLine;
   planRows(state).forEach((row, i) => {
     const taskStart = lines.length;
-    const renderedTask = taskLines(state, row, i, cols);
+    const renderedTask = taskLines(state, row, i, cols, orderOf);
     if (row.task.id === state.expandedTaskId && renderedTask.editorLine !== void 0) {
       editorLine = taskStart + renderedTask.editorLine;
     }
@@ -4775,18 +4710,16 @@ function planScrollExtent(state) {
   }
   return planLayout(state, bodyRows(state), cols);
 }
-function taskLines(state, row, index, cols) {
-  const { task, parent } = row;
+function taskLines(state, planRow, index, cols, orderOf) {
+  const { task, parent } = planRow;
+  const row = (0, import_core25.taskRowView)(task, { parent, orderOf, modes: modesForTask(state.modesByRunner, task) });
   const selected = state.focus === "plan" && index === state.selectedTask;
   const expanded = state.expandedTaskId === task.id;
-  const running = isTaskRunning(task);
-  const idle = running && task.status === "in_progress" && task.idleSince != null;
-  const paint = idle ? style.cyan : STATUS_MARK[task.status] ?? ((t) => t);
-  const rawIcon = idle ? IDLE_ICON : running ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[task.status] ?? "\xB7";
-  const icon = paint(rawIcon);
-  const kind = running ? style.yellow("RUN") : task.type === "user" ? style.yellow("MAN") : task.ops ? style.magenta("OPS") : style.grey(" AI");
+  const rawIcon = row.status === "running" ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[row.status];
+  const icon = STATUS_PAINT[row.status](rawIcon);
+  const kind = row.running ? style.yellow("RUN") : row.kind === "user" ? style.yellow("MAN") : row.kind === "ops" ? style.magenta("OPS") : style.grey(" AI");
   const caret = selected ? style.cyan("\u276F") : " ";
-  const orderLabel = parent ? (0, import_core23.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
+  const orderLabel = parent ? row.orderLabel : row.orderLabel.padStart(2);
   const indent = parent ? "  " : "";
   const head = `${indent}${caret} ${icon} ${orderLabel} ${kind} `;
   const titleRoom = Math.max(1, cols - width(head));
@@ -4803,58 +4736,51 @@ function taskLines(state, row, index, cols) {
   });
   const model = task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
   const effort = task.type === "ai" ? `effort: ${task.assignedModel?.thinkingEffort ?? "default"}` : "";
-  const modeInfo = task.type === "ai" ? modesForTask(state.modesByRunner, task).find((m) => m.id === task.taskMode) : void 0;
-  const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${modeInfo?.autonomous ? style.yellow(" \u26A1") : ""}` : "";
+  const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${row.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
   const bodyPad = parent ? "      " : "    ";
   const structured = task.transport?.kind === "structured";
-  const waiting = task.status === "awaiting_user" && task.awaitingReason ? AWAITING_LABEL[task.awaitingReason] : "";
-  const activity = task.awaitingApproval ? `${approvalLabel(task.awaitingApproval)} \u2014 t opens it` : idle ? structured ? "quiet" : "quiet \u2014 t opens its terminal" : running ? "working" : waiting;
+  const activity = row.approvals ? `${inRow(row.approvals)} \u2014 t opens it` : row.status === "quiet" ? structured ? "quiet" : "quiet \u2014 t opens its terminal" : row.running ? "working" : row.awaiting ? inRow(row.awaiting) : "";
   const meta = [activity, runner, structured ? "structured" : "", model].filter(Boolean).join(" \xB7 ");
   if (meta) lines.push(style.grey(truncate(`${bodyPad}${meta}`, cols)));
   if (task.transport?.fallback) lines.push(style.yellow(truncate(`${bodyPad}terminal: ${task.transport.fallback}`, cols)));
   if (effort || mode) lines.push(style.grey(truncate(`${bodyPad}${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
-  if (task.isolation?.state === "conflict") {
-    const where = task.isolation.conflictRepo && task.isolation.conflictRepo !== "." ? ` in ${task.isolation.conflictRepo}` : "";
-    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core23.capConflictFiles)(task.isolation.conflictFiles)})` : "";
+  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} \u2014 its work is kept on its own branch`, cols)));
   }
-  if (task.isolation?.state === "repairing") {
-    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core23.capConflictFiles)(task.isolation.conflictFiles)}` : "";
-    const attempt = task.isolation.repair ? ` (attempt ${task.isolation.repair.attempt}/${task.isolation.repair.limit})` : "";
+  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)));
   }
-  if (task.mergeGate?.length) {
-    const deps = task.mergeGate.map((id) => {
-      const dep = state.tasks.find((t) => t.id === id);
-      return dep ? `#${dep.order}` : id;
-    });
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all \u2014 ${deps.join(", ")} not merged into your branch yet`, cols)));
+  if (row.mergeGate) {
+    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all \u2014 ${row.mergeGate.join(", ")} not merged into your branch yet`, cols)));
   }
-  if (task.status === "awaiting_user" && task.awaitingReason === "files-changed") {
+  if (row.opsChangedFiles) {
     lines.push(style.yellow(truncate(`${bodyPad}\u26A0 an ops task changed tracked files \u2014 check them, then m done or /retry`, cols)));
   }
-  if (task.isolation?.state === "integrated" && task.isolation.repairedFiles?.length) {
-    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core23.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
+  if (row.repaired?.landed) {
+    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${row.repaired.files}`, cols)));
   }
   let editorLine;
   if (expanded) {
     lines.push(style.grey(`${bodyPad}${task.status.replace(/_/g, " ")}`));
     if (task.isolation && task.isolation.state !== "none" && task.isolation.branch) {
       lines.push(...taskText("Branch", task.isolation.branch, cols, bodyPad));
-      const repos = taskRepoNames(task.isolation);
-      if (repos.length > 0) lines.push(...taskText("Repos", repos.join(", "), cols, bodyPad));
+      if (row.repos.length > 0) lines.push(...taskText("Repos", row.repos.join(", "), cols, bodyPad));
       if (task.isolation.state !== "integrated" && task.isolation.worktree) {
         lines.push(...taskText("Worktree", task.isolation.worktree, cols, bodyPad));
       }
     }
-    if (task.ops) {
+    if (row.kind === "ops") {
       lines.push(...taskText("Ops", "Runs in your checkout, not a worktree, once the work it depends on is merged. O makes it a change task.", cols, bodyPad));
     }
-    if (task.forcedPastGate?.length) {
-      lines.push(...taskText("Forced", `Started before the work of ${task.forcedPastGate.join(", ")} was merged into your branch.`, cols, bodyPad));
+    if (row.forcedPastGate) {
+      lines.push(...taskText("Forced", `Started before the work of ${row.forcedPastGate.join(", ")} was merged into your branch.`, cols, bodyPad));
     }
-    if (modeInfo?.autonomous) {
+    if (row.autonomous) {
       lines.push(...taskText("Autonomy", "Runs without permission prompts (Full). Change the level with /auto.", cols, bodyPad));
     }
     const editableSeed = task.prompt ?? task.description ?? task.title;
@@ -4868,10 +4794,8 @@ function taskLines(state, row, index, cols) {
       editorLine = lines.length + 1 + cp.line;
       lines.push(...taskPromptLines(wrapped, cp, bodyPad));
     }
-    if (task.dependencies.length > 0) {
-      const orderById = new Map(state.tasks.map((candidate) => [candidate.id, candidate.order]));
-      const dependencies = task.dependencies.map((id) => orderById.has(id) ? `#${orderById.get(id)}` : id).join(", ");
-      lines.push(...taskText("Depends on", dependencies, cols, bodyPad));
+    if (row.dependencies.length > 0) {
+      lines.push(...taskText("Depends on", row.dependencies.join(", "), cols, bodyPad));
     }
     lines.push(style.grey(`${bodyPad}enter save \xB7 esc cancel`));
     lines.push(style.grey(truncate(`${bodyPad}then R runner \xB7 o model \xB7 e effort \xB7 M mode \xB7 D deps`, cols)));
@@ -4918,7 +4842,13 @@ function helpLayout(rows, cols) {
     style.grey("tab switches panes \xB7 pgup/pgdn scroll \xB7 ctrl-o toggles full detail \xB7 esc takes back a queued prompt, otherwise esc twice stops \xB7 ctrl-l clears \xB7 ctrl-c quits")
   );
   body.push(
-    style.grey("in a task view (t or /terminal on a structured task): ctrl-r removes the selected queued message \xB7 ctrl-x interrupts \xB7 ctrl-y allows a tool request \xB7 ctrl-t allows it for the task \xB7 ctrl-g denies it, with the composer text as the note \xB7 alt\u2190/\u2192 changes attempt \xB7 esc returns")
+    "",
+    style.bold("In a task view (t or /terminal on a structured task)"),
+    style.grey("  ctrl-s sends now: interrupts the running step, then delivers the composer text \u2014 or, with it empty, the selected queued message"),
+    style.grey("  ctrl-n/ctrl-p select a queued message \xB7 ctrl-r removes it \xB7 ctrl-x interrupts"),
+    style.grey("  ctrl-y allows a tool request (its keys sit under it) \xB7 ctrl-t allows it for the task \xB7 ctrl-g denies it, with the composer text as the note"),
+    style.grey("  at a checkpoint, ctrl-y approves and ctrl-g rejects, with the composer text as the reason \xB7 /checkpoint <id> approve|reject [reason] from anywhere"),
+    style.grey("  alt\u2190/\u2192 changes attempt \xB7 esc returns")
   );
   const lines = body.map((line) => truncate(line, Math.max(1, cols - 2)));
   const room = Math.max(1, rows - 2);
@@ -4929,7 +4859,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core24 = require("@ordewell/core");
+var import_core26 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -5194,8 +5124,8 @@ function renderHandoff(state, overlay, rows, cols) {
     return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
   }
   const landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
-    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core24.capConflictFiles)(task.repairedFiles)})`) : "";
-    return `  ${style.green("\u2713")} #${task.order} ${task.title}${repaired}`;
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core26.capConflictFiles)(task.repairedFiles)})`) : "";
+    return `  ${style.green("\u2713")} ${(0, import_core26.titledTaskRef)(task)}${repaired}`;
   });
   const actions = handoffActions(handoff).map((action, index) => {
     const active = index === overlay.index;
@@ -5284,7 +5214,10 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core30 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
+
+// src/tui/reducers/overlays.ts
+var import_core32 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -5333,10 +5266,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core28 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core25 = require("@ordewell/core");
+var import_core27 = require("@ordewell/core");
 var import_plan_utils2 = require("@ordewell/core/plan-utils");
 var DEFAULT_EFFORT = "__runner_default__";
 function picker(title, items, action, extra = {}) {
@@ -5355,11 +5288,11 @@ function modelDetail(m) {
 function providerErrorHint(state) {
   const failed = Object.keys(state.providerErrors ?? {});
   if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core25.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => import_core27.ALL_PROVIDERS[p]?.label ?? p);
   return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
 }
 function plannerModelItems(state) {
-  const runner = (0, import_core25.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core27.runnerForProvider)(state.plannerProvider);
   if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
   const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
     id: m.id,
@@ -5373,7 +5306,7 @@ function plannerModelItems(state) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerEffortItems(state) {
-  const runner = (0, import_core25.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core27.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -5437,7 +5370,7 @@ function pickerItemsFor(state, action) {
   if (action.kind === "set-task-deps") {
     return (0, import_plan_utils2.dependencyCandidates)(state.tasks, action.taskId).map((candidate) => ({
       id: candidate.id,
-      label: `#${candidate.order} ${candidate.title}`,
+      label: (0, import_core27.titledTaskRef)(candidate),
       detail: candidate.status === "completed" ? "already completed" : void 0
     }));
   }
@@ -5482,26 +5415,25 @@ function pickerItemsFor(state, action) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core25.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core25.runnerForProvider)(id);
-    const ready = installed.has(runner);
-    return {
-      id,
-      label: import_core25.ALL_PROVIDERS[id].label,
-      detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
-      selected: state.plannerProvider === id,
-      disabled: !ready
-    };
-  });
-  const vendors = import_core25.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
-    id,
-    label: import_core25.ALL_PROVIDERS[id].label,
-    detail: import_core25.ALL_PROVIDERS[id].apiKeyEnvVar,
-    selected: state.plannerProvider === id
+  const usability = {};
+  for (const id of import_core27.CLI_PROVIDERS) {
+    const runner = (0, import_core27.runnerForProvider)(id);
+    usability[runner] = installed.has(runner) ? { usable: true } : { usable: false, reason: "CLI not installed or not on PATH" };
+  }
+  const entries = (0, import_core27.plannerBackendEntries)(usability, state.configuredProviders);
+  const items = entries.map((entry) => ({
+    id: entry.id,
+    label: entry.label,
+    detail: entry.reason,
+    selected: state.plannerProvider === entry.id,
+    disabled: !entry.usable
   }));
-  return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
+  return entries.some((entry) => entry.kind === "vendor") ? items : [...items, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
 }
 
+// src/tui/reducers/planPane.ts
+var import_core29 = require("@ordewell/core");
+
 // src/tui/reducers/pointer.ts
 var WHEEL_NOTCH = 3;
 function pageNotch(viewport) {
@@ -5578,13 +5510,13 @@ function handleMouseSelect(state, key) {
 }
 
 // src/tui/reducers/taskView.ts
-var import_core26 = require("@ordewell/core");
+var import_core28 = require("@ordewell/core");
 function openTaskView(state, sessionId, taskId) {
   const task = findTask(state.tasks, taskId);
   if (!task) return step(say(state, "system", `No task ${taskId} in this plan.`));
   const taskView = {
     taskId,
-    view: import_core26.EMPTY_TASK_LOG,
+    view: import_core28.EMPTY_TASK_LOG,
     attempts: [],
     attempt: 0,
     pending: [],
@@ -5617,13 +5549,13 @@ function applyLive(tv, attempt, events) {
     }
     next = {
       ...next,
-      view: import_core26.EMPTY_TASK_LOG,
+      view: import_core28.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_core26.reduceTaskLog, next.view) });
+  return clampQueueIndex({ ...next, view: events.reduce(import_core28.reduceTaskLog, next.view) });
 }
 function taskLogAbandoned(state) {
   const tv = state.taskView;
@@ -5643,15 +5575,22 @@ function taskLogArrived(state, action) {
 function announceApprovals(state, action) {
   if (state.taskView?.taskId === action.taskId) return state;
   const task = findTask(state.tasks, action.taskId);
-  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" ? say(s, "system", `\xB7 Task ${task?.order ?? "?"} waits for approval: ${(0, import_core26.runnerToolSubject)(event.tool, event.args)} \u2014 t on it to answer`) : s, state);
+  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" ? say(s, "system", `\xB7 Task ${task?.order ?? "?"} waits for approval: ${(0, import_core28.runnerToolSubject)(event.tool, event.args)} \u2014 t on it, then ctrl-y to allow or ctrl-g to deny`) : 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?.transport?.kind === "structured" ? "t on it to answer" : `/checkpoint ${task?.order ?? "<id>"} approve|reject to answer`;
+  const spoken = say(state, "system", `\xB7 ${label} asks: ${(0, import_core28.truncateCheckpointSummary)(action.summary)} \u2014 ${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_core26.replayTaskLog)(action.events),
+    view: (0, import_core28.replayTaskLog)(action.events),
     attempts: action.attempts ?? tv.attempts,
     attempt: action.attempt
   } : { ...tv, attempts: action.attempts ?? tv.attempts };
@@ -5673,6 +5612,29 @@ function answerApproval(state, tv, sessionId, decision) {
   const next = note ? { ...state, editor: { ...state.editor, text: "", cursor: 0 } } : state;
   return step(next, [{ type: "answerTaskApproval", sessionId, approvalId: approval.approvalId, answer }]);
 }
+function answerCheckpoint(state, sessionId, taskId, answer, reason = "") {
+  const task = findTask(state.tasks, taskId);
+  if (!waitingCheckpoint(task)) return step(say(state, "system", `Task ${task?.order ?? taskId} is not waiting at a checkpoint.`));
+  const note = answer === "reject" ? reason.trim() : "";
+  return step(state, [{ type: "answerTaskCheckpoint", sessionId, taskId, answer, ...note ? { reason: note } : {} }]);
+}
+function answerWaiting(state, tv, sessionId, decision) {
+  if (waitingApproval(tv) || !waitingCheckpoint(findTask(state.tasks, tv.taskId))) return answerApproval(state, tv, sessionId, decision);
+  if (decision === "allow") return answerCheckpoint(state, sessionId, tv.taskId, "approve");
+  const answered = answerCheckpoint(state, sessionId, tv.taskId, "reject", state.editor.text);
+  return state.editor.text.trim() ? { ...answered, state: { ...answered.state, editor: { ...answered.state.editor, text: "", cursor: 0 } } } : answered;
+}
+function sendNow(state, tv, sessionId) {
+  const text = state.editor.text.trim();
+  if (text) {
+    if (continuesTask(findTask(state.tasks, tv.taskId))) return step(say(state, "system", "The task has finished, so there is no turn to interrupt \u2014 enter continues it."));
+    return step({ ...state, editor: commit(state.editor) }, [{ type: "forceSendTaskMessage", sessionId, taskId: tv.taskId, text }]);
+  }
+  const queued = tv.view.queued[tv.queuedIndex];
+  if (!queued) return step(say(state, "system", "Nothing to send now: type a message, or pick a queued one with ctrl-n/ctrl-p."));
+  if (queued.handedOver) return step(say(state, "system", "The runner already has that message; it reads it after its current step."));
+  return step(state, [{ type: "forceSendQueuedTaskMessage", sessionId, taskId: tv.taskId, messageId: queued.id }]);
+}
 function handleTaskViewKey(state, key) {
   const tv = state.taskView;
   if (!tv || !state.sessionId) return null;
@@ -5692,14 +5654,16 @@ function handleTaskViewKey(state, key) {
   if (key.name === "ctrl-r") {
     const queued = tv.view.queued[tv.queuedIndex];
     if (!queued) return step(say(state, "system", "No queued message to remove."));
+    if (queued.handedOver) return step(say(state, "system", "The runner already has that message; it can no longer be taken back."));
     return step(state, [{ type: "removeTaskMessage", sessionId: state.sessionId, taskId: tv.taskId, messageId: queued.id }]);
   }
+  if (key.name === "ctrl-s") return sendNow(state, tv, state.sessionId);
   if (key.name === "ctrl-x") {
     return step(state, [{ type: "interruptTask", sessionId: state.sessionId, taskId: tv.taskId }]);
   }
-  if (key.name === "ctrl-y") return answerApproval(state, tv, state.sessionId, "allow");
+  if (key.name === "ctrl-y") return answerWaiting(state, tv, state.sessionId, "allow");
   if (key.name === "ctrl-t") return answerApproval(state, tv, state.sessionId, "allowForTask");
-  if (key.name === "ctrl-g") return answerApproval(state, tv, state.sessionId, "deny");
+  if (key.name === "ctrl-g") return answerWaiting(state, tv, state.sessionId, "deny");
   if (key.name === "ctrl-n" || key.name === "ctrl-p") {
     const count = tv.view.queued.length;
     if (count === 0) return null;
@@ -5720,7 +5684,7 @@ function openTaskRunnerPicker(state, task) {
       ...state,
       overlay: {
         kind: "picker",
-        picker: picker(`Runner \xB7 #${task.order} ${task.title}`, pickerItemsFor(state, action), action, {
+        picker: picker(`Runner \xB7 ${(0, import_plan_utils3.titledTaskRef)(task)}`, pickerItemsFor(state, action), action, {
           hint: "Changing the runner re-picks this task model, effort and mode for it."
         })
       }
@@ -5728,14 +5692,12 @@ function openTaskRunnerPicker(state, task) {
   );
 }
 function confirmRemoveTask(state, task) {
-  const dependents = (0, import_plan_utils3.dependentsOf)(state.tasks, task.id);
-  const named = dependents.map((t) => `#${t.order} ${t.title}`).join(", ");
   return step({
     ...state,
     overlay: {
       kind: "confirm",
-      title: `Remove #${task.order} ${task.title}?`,
-      message: dependents.length > 0 ? `${dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`} on it and will lose that dependency: ${named}.` : "This cannot be undone.",
+      title: `Remove ${(0, import_plan_utils3.titledTaskRef)(task)}?`,
+      message: (0, import_plan_utils3.dependentsNotice)((0, import_plan_utils3.dependentsOf)(state.tasks, task.id)) ?? "This cannot be undone.",
       action: { kind: "remove-task", taskId: task.id }
     }
   });
@@ -5744,26 +5706,22 @@ function toggleTaskOps(state, task, subtask, to = !task.ops) {
   if (!state.sessionId) return fail3(state, "No active plan.");
   if (task.type !== "ai") return fail3(state, "Only an AI task can be an ops task \u2014 a manual task already runs outside any worktree.");
   if (subtask) return fail3(state, "A subtask runs with its parent; make the parent an ops task instead.");
-  if (!!task.ops === to) return fail3(state, `#${task.order} is already ${to ? "an ops" : "a change"} task.`);
+  if (!!task.ops === to) return fail3(state, `${(0, import_plan_utils3.taskRef)(task)} is already ${to ? "an ops" : "a change"} task.`);
   return step(state, [{
     type: "updateTask",
     sessionId: state.sessionId,
     taskId: task.id,
     changes: { ops: to },
-    message: to ? `Task #${task.order} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task #${task.order} is a change task: it runs in its own worktree.`
+    message: to ? `Task ${(0, import_plan_utils3.taskRef)(task)} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task ${(0, import_plan_utils3.taskRef)(task)} is a change task: it runs in its own worktree.`
   }]);
 }
 function confirmForceStartPastGate(state, task) {
-  const named = (task.mergeGate ?? []).map((id) => {
-    const dep = findTask(state.tasks, id);
-    return dep ? `#${dep.order} ${dep.title}` : id;
-  });
   return step({
     ...state,
     overlay: {
       kind: "confirm",
-      title: `Force start #${task.order} ${task.title}?`,
-      message: `It waits for Merge all: the work of ${named.join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task.`,
+      title: `Force start ${(0, import_plan_utils3.titledTaskRef)(task)}?`,
+      message: (0, import_plan_utils3.pastGateConfirmation)((0, import_plan_utils3.titledRefs)(task.mergeGate ?? [], state.tasks), "It"),
       action: { kind: "force-start-gated", taskId: task.id }
     }
   });
@@ -5771,12 +5729,12 @@ 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 #${task.order}, so it has no possible dependencies.`);
+  if (items.length === 0) return fail3(state, `Nothing runs before ${(0, import_plan_utils3.taskRef)(task)}, so it has no possible dependencies.`);
   return step({
     ...state,
     overlay: {
       kind: "picker",
-      picker: picker(`Depends on \xB7 #${task.order} ${task.title}`, items, action, {
+      picker: picker(`Depends on \xB7 ${(0, import_plan_utils3.titledTaskRef)(task)}`, items, action, {
         hint: "Only tasks earlier in the plan can be dependencies.",
         multi: true,
         chosen: task.dependencies.filter((id) => items.some((i) => i.id === id))
@@ -5796,7 +5754,7 @@ function openTaskModePicker(state, task) {
       ...state,
       overlay: {
         kind: "picker",
-        picker: picker(`Mode \xB7 #${task.order}`, pickerItemsFor(state, action), action, {
+        picker: picker(`Mode \xB7 ${(0, import_plan_utils3.taskRef)(task)}`, pickerItemsFor(state, action), action, {
           hint: `Modes declared by ${task.assignedRunner}.`
         })
       }
@@ -5811,7 +5769,7 @@ function openTaskModelPicker(state, task) {
       ...state,
       overlay: {
         kind: "picker",
-        picker: picker(`Model \xB7 #${task.order} ${task.title}`, pickerItemsFor(state, action), action, {
+        picker: picker(`Model \xB7 ${(0, import_plan_utils3.titledTaskRef)(task)}`, pickerItemsFor(state, action), action, {
           hint: task.assignedRunner ? `Showing models discovered for ${task.assignedRunner}.` : "Choose the model this task will run with."
         })
       }
@@ -5828,7 +5786,7 @@ function openTaskEffortPicker(state, task) {
       ...state,
       overlay: {
         kind: "picker",
-        picker: picker(`Thinking effort \xB7 #${task.order}`, pickerItemsFor(state, action), action, {
+        picker: picker(`Thinking effort \xB7 ${(0, import_plan_utils3.taskRef)(task)}`, pickerItemsFor(state, action), action, {
           hint: `${task.assignedModel.modelLabel} \xB7 choose runner default or a supported effort`
         })
       }
@@ -5845,7 +5803,7 @@ function assignTaskModel(state, sessionId, task, model) {
     // JSON drops `undefined`; null is intentional here so changing models can
     // also clear a stale legacy top-level effort on the persisted task.
     changes: { assignedModel, thinkingEffort: assignedModel.thinkingEffort ?? null },
-    message: `Task #${task.order} model set to ${model.label}.`
+    message: `Task ${(0, import_plan_utils3.taskRef)(task)} model set to ${model.label}.`
   }]);
 }
 function assignTaskRunner(state, sessionId, task, runner, runnerLabel) {
@@ -5854,7 +5812,7 @@ function assignTaskRunner(state, sessionId, task, runner, runnerLabel) {
     sessionId,
     taskId: task.id,
     changes: { assignedRunner: runner },
-    message: `Task #${task.order} runner set to ${runnerLabel}.`
+    message: `Task ${(0, import_plan_utils3.taskRef)(task)} runner set to ${runnerLabel}.`
   }]);
 }
 function assignTaskMode(state, sessionId, task, mode, modeLabel) {
@@ -5863,7 +5821,7 @@ function assignTaskMode(state, sessionId, task, mode, modeLabel) {
     sessionId,
     taskId: task.id,
     changes: { taskMode: mode },
-    message: `Task #${task.order} mode set to ${modeLabel}.`
+    message: `Task ${(0, import_plan_utils3.taskRef)(task)} mode set to ${modeLabel}.`
   }]);
 }
 function assignTaskEffort(state, sessionId, task, thinkingEffort) {
@@ -5873,7 +5831,7 @@ function assignTaskEffort(state, sessionId, task, thinkingEffort) {
     sessionId,
     taskId: task.id,
     changes: { assignedModel, thinkingEffort: thinkingEffort ?? null },
-    message: `Task #${task.order} thinking effort set to ${thinkingEffort ?? "runner default"}.`
+    message: `Task ${(0, import_plan_utils3.taskRef)(task)} thinking effort set to ${thinkingEffort ?? "runner default"}.`
   }]);
 }
 function taskModelCommand(state, args) {
@@ -5975,9 +5933,6 @@ function taskActionEffect(state, sessionId, taskId, action) {
   const watch = SPAWNS_RUNNER.includes(action) && state.status !== "executing";
   return watch ? { type: "taskAction", sessionId, taskId, action, watch: true } : { type: "taskAction", sessionId, taskId, action };
 }
-function markAction(task) {
-  return task.status === "completed" ? "uncomplete" : "complete";
-}
 function handlePlanKey(state, key) {
   const editingTask = state.expandedTaskId ? findTask(state.tasks, state.expandedTaskId) : void 0;
   if (editingTask && state.taskEditor) return handleTaskEditKey(state, editingTask, state.taskEditor, key);
@@ -6012,7 +5967,7 @@ function handlePlanKey(state, key) {
   if (!state.sessionId || key.name !== "char") return step(state);
   if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
   if (key.char === "S") return step(state, [{ type: "stopExecution", sessionId: state.sessionId }]);
-  const action = key.char === "m" ? markAction(task) : PLAN_SHORTCUTS[key.char ?? ""];
+  const action = key.char === "m" ? (0, import_core29.markAction)(task) : PLAN_SHORTCUTS[key.char ?? ""];
   if (action === "force-start" && task.mergeGate?.length) return confirmForceStartPastGate(state, task);
   if (action) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
@@ -6047,14 +6002,14 @@ function commitTaskEdit(state, task, editor) {
     sessionId: state.sessionId,
     taskId: task.id,
     changes: { prompt },
-    message: `Task #${task.order} prompt updated.`
+    message: `Task ${(0, import_core29.taskRef)(task)} prompt updated.`
   }]);
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core27 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core27.drainNext)(state.queuedPrompts);
+  const next = (0, import_core30.drainNext)(state.queuedPrompts);
   const ended = disarmStop({ ...settled, stopRequested: false });
   if (!next) return step(ended);
   const spoken = say(ended, "user", next.text);
@@ -6073,14 +6028,14 @@ function stopPlanning(state, sessionId) {
   return step(queueToEditor(cutTurn({ ...dismissed, stopArmed: false, stopRequested: true })), [{ type: "cancelPlanning", sessionId }]);
 }
 function queueToEditor(state) {
-  const all = (0, import_core27.unsendAll)(state.queuedPrompts);
+  const all = (0, import_core30.unsendAll)(state.queuedPrompts);
   if (!all) return state;
   return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text: all.text, cursor: all.text.length } };
 }
 function unsendLatest(state) {
-  const latest = (0, import_core27.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core30.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core27.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core30.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -6097,7 +6052,7 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/commands.ts
-var KNOWN_PROVIDERS2 = Object.keys(import_core28.ALL_PROVIDERS);
+var KNOWN_PROVIDERS = Object.keys(import_core31.ALL_PROVIDERS);
 function runCommand(state, { name, args }) {
   if (!findCommand(name)) {
     return fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
@@ -6184,6 +6139,14 @@ function runCommand(state, { name, args }) {
         if (!text) return fail3(state, "Usage: /continue <id> <message>");
         return continueTaskStep(state, sessionId, taskId, text);
       });
+    case "checkpoint":
+      return taskCommand(state, args[0], (sessionId, taskId) => {
+        const answer = args[1]?.toLowerCase();
+        const reason = args.slice(2).join(" ").trim();
+        if (answer !== "approve" && answer !== "reject") return fail3(state, "Usage: /checkpoint <id> approve|reject [reason]");
+        if (answer === "approve" && reason) return fail3(state, "Approving takes no note \u2014 reject with a reason to tell the task something.");
+        return answerCheckpoint(state, sessionId, taskId, answer, reason);
+      });
     case "task-runner":
       return taskRunnerCommand(state, args);
     case "task-model":
@@ -6255,8 +6218,8 @@ function newSession(state) {
     taskView: null,
     tasks: [],
     planApproved: false,
-    conversation: import_core28.EMPTY_CONVERSATION,
-    turnGate: import_core28.NO_TURN,
+    conversation: import_core31.EMPTY_CONVERSATION,
+    turnGate: import_core31.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -6267,14 +6230,14 @@ function newSession(state) {
     // Prompts belong to the session that raised them; the old planner is gone
     // and its pending requests deny on their own timeout.
     pendingApprovals: [],
-    queuedPrompts: import_core28.EMPTY_HOLD,
+    queuedPrompts: import_core31.EMPTY_HOLD,
     stopArmed: false,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
   }, closeEffects);
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core28.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core31.runnerForProvider)(state.plannerProvider);
     const known = runner ? modelsForRunner(state.models, runner) : [];
     if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
       return fail3(state, `${args[1]} was not discovered for ${runner}.`);
@@ -6297,7 +6260,7 @@ function setModel(state, args) {
 function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
-    if (!KNOWN_PROVIDERS2.includes(id)) {
+    if (!KNOWN_PROVIDERS.includes(id)) {
       return fail3(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
     }
     return step(state, [{ type: "setPlanner", provider: id }]);
@@ -6336,7 +6299,7 @@ function setPlannerEffort(state, args) {
 function setKey(state, args) {
   if (args[0] === "set" && args[1]) {
     const provider = args[1].toLowerCase();
-    if (!KNOWN_PROVIDERS2.includes(provider)) {
+    if (!KNOWN_PROVIDERS.includes(provider)) {
       return fail3(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
     }
     if (!args[2]) {
@@ -6347,16 +6310,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core28.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core31.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core28.ALL_PROVIDERS[id].label,
-    detail: import_core28.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core31.ALL_PROVIDERS[id].label,
+    detail: import_core31.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.configuredProviders.includes(id)
   }));
   return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
 function keyPrompt(provider) {
-  const meta = import_core28.ALL_PROVIDERS[provider];
+  const meta = import_core31.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -6433,19 +6396,19 @@ function runners(state, args) {
 }
 function setMaxParallel(state, arg) {
   if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once \u2014 /parallel <n> changes it.`));
-  const limit = (0, import_core28.parseMaxParallel)(arg);
+  const limit = (0, import_core31.parseMaxParallel)(arg);
   if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
   return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
 }
 function setAutonomous(state, arg) {
-  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core28.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
-  const enabled = (0, import_core28.parseAutonomyLevel)(arg);
+  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core31.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
+  const enabled = (0, import_core31.parseAutonomyLevel)(arg);
   if (enabled === null) return fail3(state, "Usage: /auto [full|guarded]");
   return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
 function setTransport(state, arg) {
   const value = arg?.toLowerCase() ?? (state.runnerTransport === "structured" ? "terminal" : "structured");
-  if (!(0, import_core28.isRunnerTransport)(value)) return fail3(state, "Usage: /transport [terminal|structured]");
+  if (!(0, import_core31.isRunnerTransport)(value)) return fail3(state, "Usage: /transport [terminal|structured]");
   return step(state, [{ type: "setTransport", transport: value }]);
 }
 function setMouseCapture(state, arg) {
@@ -6622,7 +6585,7 @@ function choose(state, picker2, item) {
       sessionId: state.sessionId,
       taskId: task.id,
       changes: { dependencies: picker2.chosen },
-      message: picker2.chosen.length > 0 ? `Task #${task.order} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`
+      message: picker2.chosen.length > 0 ? `Task ${(0, import_core32.taskRef)(task)} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task ${(0, import_core32.taskRef)(task)} no longer depends on anything.`
     }]);
   }
   if (!item) return step(state);
@@ -6699,7 +6662,7 @@ function choose(state, picker2, item) {
 }
 
 // src/tui/reducers/incoming.ts
-var import_core29 = require("@ordewell/core");
+var import_core33 = require("@ordewell/core");
 var planText = (value, fallback = "") => sanitize(String(value ?? fallback));
 var planLabel = (value, fallback = "") => planText(value, fallback).replace(/\n+/g, " ");
 var asRecord = (value) => typeof value === "object" && value !== null ? value : {};
@@ -6730,7 +6693,7 @@ function toTaskView2(t, index) {
     prompt: typeof t.prompt === "string" ? sanitize(t.prompt) : void 0,
     type: t.type === "user" ? "user" : "ai",
     status: planLabel(t.status, "pending"),
-    awaitingReason: t.status === "awaiting_user" && (0, import_core29.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
+    awaitingReason: t.status === "awaiting_user" && (0, import_core33.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
     dependencies: Array.isArray(t.dependencies) ? t.dependencies.map((id) => planLabel(id)) : [],
     assignedRunner: typeof t.assignedRunner === "string" ? planLabel(t.assignedRunner) : void 0,
     taskMode: typeof t.taskMode === "string" ? planLabel(t.taskMode) : void 0,
@@ -6763,12 +6726,12 @@ function applySettings(state, settings) {
     plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
     plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
     maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
-    runnerTransport: (0, import_core29.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
+    runnerTransport: (0, import_core33.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
   };
 }
 function runLabel(tasks, gate = null) {
-  const running = tasks.filter(isTaskRunning);
+  const running = tasks.filter(import_core24.isTaskRunning);
   if (running.length > 0) {
     const [first] = running;
     const name = first.assignedRunner ? `${first.title} \xB7 ${first.assignedRunner}` : first.title;
@@ -6834,13 +6797,13 @@ function reduceAction(state, action) {
         goal: "",
         taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core30.EMPTY_HOLD,
+        queuedPrompts: import_core34.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
     case "chatRestored":
       if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, conversation: (0, import_core30.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
+      return step({ ...state, conversation: (0, import_core34.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
     case "planUpdated": {
       if (stale(state, action.sessionId)) return step(state);
       const isolation = isolationOfPlan(action.plan);
@@ -6887,14 +6850,17 @@ function reduceAction(state, action) {
     case "taskStarted": {
       if (stale(state, action.sessionId)) return step(state);
       const existing = findTask(state.tasks, action.taskId);
-      if (existing && isTaskRunning(existing)) return step(state);
-      const tasks = state.tasks.map((t) => t.id === action.taskId && !isTaskRunning(t) ? { ...t, status: "in_progress" } : t);
-      const spoken = say(state, "system", (0, import_core30.taskStartedNotice)(action.title, action.runner));
+      if (existing && (0, import_core24.isTaskRunning)(existing)) return step(state);
+      const tasks = state.tasks.map((t) => t.id === action.taskId && !(0, import_core24.isTaskRunning)(t) ? { ...t, status: "in_progress" } : t);
+      const spoken = say(state, "system", (0, import_core34.taskStartedNotice)(action.title, action.runner));
       return step({ ...spoken, tasks, status: "executing", busyLabel: runLabel(tasks) });
     }
+    case "taskCheckpoint":
+      if (stale(state, action.sessionId)) return step(state);
+      return step(announceCheckpoint(state, action));
     case "taskStatus": {
       if (stale(state, action.sessionId) || !state.tasks.some((t) => t.id === action.taskId)) return step(state);
-      const tasks = state.tasks.map((t) => t.id === action.taskId ? { ...t, status: action.status, awaitingReason: void 0 } : t);
+      const tasks = state.tasks.map((t) => t.id === action.taskId ? { ...t, status: action.status, awaitingReason: void 0, checkpoint: void 0 } : t);
       const status = runStatus(state, tasks);
       return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks, state.gate) : state.busyLabel });
     }
@@ -6909,13 +6875,14 @@ function reduceAction(state, action) {
         const isolation = update.isolation ?? t.isolation;
         const transport = update.transport;
         const awaitingReason = update.awaitingReason;
+        const checkpoint = update.checkpoint;
         const continuable = update.continuable === true;
         const awaitingApproval = update.awaitingApproval;
         const mergeGate = update.mergeGate;
         const forcedPastGate = update.forcedPastGate;
-        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation) || !sameTransport(transport, t.transport) || awaitingReason !== t.awaitingReason || continuable !== (t.continuable ?? false) || awaitingApproval !== t.awaitingApproval || !sameList(mergeGate, t.mergeGate) || !sameList(forcedPastGate, t.forcedPastGate)) {
+        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation) || !sameTransport(transport, t.transport) || awaitingReason !== t.awaitingReason || checkpoint !== t.checkpoint || continuable !== (t.continuable ?? false) || awaitingApproval !== t.awaitingApproval || !sameList(mergeGate, t.mergeGate) || !sameList(forcedPastGate, t.forcedPastGate)) {
           changed = true;
-          return { ...t, status: update.status, idleSince, isolation, transport, awaitingReason, continuable, awaitingApproval, mergeGate, forcedPastGate };
+          return { ...t, status: update.status, idleSince, isolation, transport, awaitingReason, checkpoint, continuable, awaitingApproval, mergeGate, forcedPastGate };
         }
         return t;
       });
@@ -6926,12 +6893,6 @@ function reduceAction(state, action) {
       const status = runStatus(next, tasks);
       return step({ ...next, status, busyLabel: status === "executing" ? runLabel(tasks, gate) : state.busyLabel });
     }
-    case "queueReady": {
-      if (stale(state, action.sessionId)) return step(state);
-      const sessionId = action.sessionId ?? state.sessionId;
-      if (sessionId === null) return step(state);
-      return step(state, [{ type: "processQueued", sessionId }]);
-    }
     case "isolationBlocked": {
       if (stale(state, action.sessionId)) return step(state);
       return step(blockedPicker(state, action.message, action.repos));
@@ -6964,6 +6925,14 @@ function reduceAction(state, action) {
         busyLabel: ""
       });
     }
+    case "executionLost": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step({
+        ...say(state, "error", "Lost the connection to the daemon \u2014 this view is no longer following the run, but the daemon may still be running it. /load this session again to see where it stands."),
+        status: "idle",
+        busyLabel: ""
+      });
+    }
     case "settingsLoaded":
       return step(applySettings(state, action.settings));
     case "modelsLoaded":
@@ -6998,7 +6967,7 @@ function reduceAction(state, action) {
         busyLabel: "",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core30.EMPTY_HOLD,
+        queuedPrompts: import_core34.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
@@ -7065,7 +7034,7 @@ function sameGate(a, b) {
   return a.paused === b.paused && JSON.stringify(a.handoff) === JSON.stringify(b.handoff);
 }
 function runStatus(state, tasks) {
-  if (tasks.some(isTaskRunning)) return "executing";
+  if (tasks.some(import_core24.isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user") || state.gate?.paused) return "executing";
   return plannerInFlight(state) ? state.status : "idle";
 }
@@ -7134,7 +7103,7 @@ function submit(state) {
     return step(cleared, [{ type: "sendTaskMessage", sessionId: state.sessionId, taskId, text }]);
   }
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core30.holdPrompt)(state.queuedPrompts, text) });
+    return step({ ...cleared, queuedPrompts: (0, import_core34.holdPrompt)(state.queuedPrompts, text) });
   }
   const spoken = say(cleared, "user", text);
   const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: text } : { type: "startConversation", goal: text };
@@ -7194,10 +7163,10 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core32 = require("@ordewell/core");
+var import_core36 = require("@ordewell/core");
 
 // src/tui/inbound.ts
-var import_core31 = require("@ordewell/core");
+var import_core35 = require("@ordewell/core");
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
   "planner_message",
   "planner_turn_started",
@@ -7412,7 +7381,8 @@ function dispatchLifecycle(dispatch, event, sessionId) {
           idleSince: task.idleSince ?? null,
           isolation: task.isolation,
           transport: task.transport,
-          awaitingReason: (0, import_core31.isAwaitingReason)(task.awaitingReason) ? task.awaitingReason : void 0,
+          awaitingReason: (0, import_core35.isAwaitingReason)(task.awaitingReason) ? task.awaitingReason : void 0,
+          ...typeof task.checkpoint === "string" && task.checkpoint ? { checkpoint: sanitize(task.checkpoint) } : {},
           ...task.continuable ? { continuable: true } : {},
           awaitingApproval: typeof task.awaitingApproval === "number" && task.awaitingApproval > 0 ? task.awaitingApproval : void 0,
           ...task.mergeGate?.length ? { mergeGate: task.mergeGate.map(String) } : {},
@@ -7426,10 +7396,10 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     case "task_started":
       dispatch({ type: "taskStarted", taskId: String(event.taskId), title: String(event.title ?? event.taskId), runner: event.runner, sessionId });
       return;
-    // The extension shows these in its checkpoint panel; here they are
-    // transcript lines, which is the TUI's equivalent surface.
+    // The extension shows these in its checkpoint panel; here they are a
+    // transcript line, and the task view carries the card that answers them.
     case "checkpoint":
-      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core31.truncateCheckpointSummary)(event.summary)}` });
+      dispatch({ type: "taskCheckpoint", taskId: String(event.taskId), title: String(event.taskTitle), summary: event.summary, sessionId });
       return;
     case "review_needed":
       dispatch({ type: "notice", message: "Plan needs your sign-off \u2014 /approve to continue." });
@@ -7437,13 +7407,6 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     case "review_approved":
       dispatch({ type: "notice", message: "Plan approved." });
       return;
-    // The orchestrator paused fan-out because a structural edit is queued; drain
-    // it so the planner reconciles the plan and dependents resume spawning.
-    // Dropped on the floor, the queue suppresses every later tick() — which is
-    // exactly "tasks did not fan out when the dependent ones finished."
-    case "queue_ready":
-      dispatch({ type: "queueReady", sessionId });
-      return;
     case "execution_complete":
       dispatch({ type: "executionComplete", summary: event.summary, sessionId });
       return;
@@ -7493,8 +7456,7 @@ async function runEffect(effect, deps) {
     await perform(effect, deps);
   } catch (err) {
     if (!isConnectionRefused(err)) {
-      const message = err instanceof Error ? err.message : String(err);
-      deps.dispatch({ type: "failed", message: explain(message) });
+      deps.dispatch({ type: "failed", message: explain(err) });
       return;
     }
     let revived = false;
@@ -7511,21 +7473,20 @@ async function runEffect(effect, deps) {
     try {
       await perform(effect, deps);
     } catch (retryErr) {
-      const message = retryErr instanceof Error ? retryErr.message : String(retryErr);
       deps.dispatch({
         type: "failed",
         // A fresh daemon holds no sessions, so the retry of anything
         // session-scoped legitimately 404s. Say which of the two happened.
-        message: isConnectionRefused(retryErr) ? describeConnectionRefused(deps.port) : explain(message)
+        message: isConnectionRefused(retryErr) ? describeConnectionRefused(deps.port) : explain(retryErr)
       });
     }
   }
 }
-function explain(message) {
-  if (message === "Session not found") {
+function explain(err) {
+  if (err instanceof DaemonError && err.code === "session_not_found") {
     return "This server is no longer holding that session \u2014 it was probably restarted. Reload it with /sessions.";
   }
-  return message;
+  return err instanceof Error ? err.message : String(err);
 }
 function persistAfterDaemon(deps, env) {
   for (const [key, value] of Object.entries(env)) deps.setEnvVar(key, value);
@@ -7581,26 +7542,20 @@ async function perform(effect, deps) {
       timer.unref?.();
       return;
     }
-    case "processQueued":
-      await api.processQueued(effect.sessionId);
-      await refreshPlan(deps, effect.sessionId);
-      return;
     case "taskAction": {
       const { sessionId, taskId, action } = effect;
-      const request = action === "complete" || action === "skip" ? () => api.markTaskComplete(sessionId, taskId) : action === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.taskControl(sessionId, taskId, action);
+      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : (0, import_core36.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
       await (effect.watch ? withExecutionStream(deps, sessionId, request) : request());
       await refreshPlan(deps, sessionId);
       return;
     }
-    case "addTask":
-      await api.addTask(effect.sessionId, {
-        title: effect.title,
-        description: effect.title,
-        prompt: effect.title,
-        type: "ai"
-      });
+    case "addTask": {
+      const fields = (0, import_core36.newTaskFields)(effect.title);
+      if (!fields) return;
+      await api.addTask(effect.sessionId, { ...fields });
       await refreshPlan(deps, effect.sessionId);
       return;
+    }
     case "updateTask":
       await api.updateTask(effect.sessionId, effect.taskId, effect.changes);
       await refreshPlan(deps, effect.sessionId);
@@ -7627,6 +7582,13 @@ async function perform(effect, deps) {
       }
       return;
     }
+    // The card goes when the daemon's next status says the task left the
+    // checkpoint; a refusal (settled elsewhere, withdrawn) surfaces as the
+    // failure the daemon words.
+    case "answerTaskCheckpoint":
+      if (effect.answer === "approve") await api.approveTaskCheckpoint(effect.sessionId, effect.taskId);
+      else await api.rejectTaskCheckpoint(effect.sessionId, effect.taskId, effect.reason);
+      return;
     // A task with a saved log ran structured, whatever its `transport` says
     // after a reload; it has no tmux window, so open the log rather than fail.
     case "openTaskTerminal": {
@@ -7676,6 +7638,16 @@ async function perform(effect, deps) {
       if (!removed) dispatch({ type: "notice", message: "That message was already delivered to the task." });
       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: "The runner already has that message; it reads it after its current step." });
+      return;
+    }
     case "interruptTask":
       await api.interruptTask(effect.sessionId, effect.taskId);
       dispatch({ type: "notice", message: "Interrupting the task\u2026" });
@@ -7699,11 +7671,11 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core32.ALL_PROVIDERS[effect.provider];
+      const meta = import_core36.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
-      const recall2 = describePlannerSwitch(settings, effect.provider);
+      const recall2 = plannerSwitchRecall(settings);
       persistAfterDaemon(deps, { ...env, ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
       dispatch({
         type: "settingsLoaded",
@@ -7711,7 +7683,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core32.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core36.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -7723,7 +7695,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core32.ALL_PROVIDERS[effect.provider];
+      const meta = import_core36.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -7761,7 +7733,7 @@ async function perform(effect, deps) {
       return;
     case "setAutonomous":
       deps.setEnvVar("ORDEWELL_AUTONOMOUS_MODE", String(effect.enabled));
-      dispatch({ type: "notice", message: `Autonomy level: ${(0, import_core32.autonomyLevelLabel)(effect.enabled)} for new plans.` });
+      dispatch({ type: "notice", message: `Autonomy level: ${(0, import_core36.autonomyLevelLabel)(effect.enabled)} for new plans.` });
       return;
     case "setMouseCapture":
       deps.setMouseCapture(effect.enabled);
@@ -7895,7 +7867,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core32.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core36.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -7919,9 +7891,14 @@ async function withExecutionStream(deps, sessionId, request) {
   const inbound = inboundFor(deps.api, deps.dispatch, sessionId);
   const stream = deps.api.streamExecution(sessionId, inbound.execution(), settleReady);
   void stream.catch(settleReady);
-  await streamReady;
-  await request();
-  await stream;
+  try {
+    await streamReady;
+    await request();
+  } catch (err) {
+    deps.api.closeExecutionStream(stream);
+    throw err;
+  }
+  if (await stream === "lost") deps.dispatch({ type: "executionLost", sessionId });
 }
 async function converse(deps, sessionId, call) {
   const inbound = inboundFor(deps.api, deps.dispatch, sessionId);
@@ -8012,6 +7989,7 @@ var CONTROL2 = {
   "": "ctrl-o",
   "": "ctrl-p",
   "": "ctrl-r",
+  "": "ctrl-s",
   "": "ctrl-t",
   "": "ctrl-u",
   "": "ctrl-w",
@@ -8285,7 +8263,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core33.assertWorkspaceExists)(workspace);
+    (0, import_core37.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -8294,7 +8272,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core33.createSkillsService)(workspace).listSkills());
+  registerSkillCommands((0, import_core37.createSkillsService)(workspace).listSkills());
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
   const targetPort = explicitPort ? resolvePort(subArgs) : await findFreePort();
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(targetPort, { detached: false });
@@ -8311,7 +8289,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       workspace,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core33.mintSessionId)(),
+      newSessionId: () => (0, import_core37.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -8362,6 +8340,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     app.dispatch({ type: "resize", rows: r, cols: c });
   });
   process.on("uncaughtException", (err) => {
+    terminal?.close();
     console.error(`Fatal: ${err.message}`);
     shutdown(1);
   });
@@ -8402,6 +8381,7 @@ var COMMANDS = {
   "retry": handleRetry,
   "cancel": handleCancel,
   continue: handleContinue,
+  checkpoint: handleCheckpoint,
   "add-task": handleAddTask,
   "remove-task": handleRemoveTask,
   "task-runner": handleTaskRunner,
@@ -8435,7 +8415,7 @@ function cliVersion() {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core34.migrateOldConfigDir)();
+  (0, import_core38.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");