@ordewell/cli 0.7.1 → 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_core37 = require("@ordewell/core");
+var import_core38 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -406,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;
@@ -422,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();
@@ -436,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
@@ -445,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}`);
@@ -492,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
@@ -508,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.
@@ -568,228 +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). */
-  async forceSendTaskMessage(sessionId, taskId, text) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages/now`, { text });
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Send now failed");
-    }
-    return res.data;
+  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. */
-  async forceSendQueuedTaskMessage(sessionId, taskId, messageId) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}/now`
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Send now failed");
-    }
-    return res.data;
+  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");
   }
   /** Let a task go on from the checkpoint it waits at; refused, with the reason, when none waits. */
-  async approveTaskCheckpoint(sessionId, taskId) {
-    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/approve`);
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Approve checkpoint failed");
-    }
-    return res.data;
+  approveTaskCheckpoint(sessionId, taskId) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/approve`, "Approve checkpoint failed");
   }
   /** Turn a task back at its checkpoint; `reason` is what the agent is told. */
-  async rejectTaskCheckpoint(sessionId, taskId, reason) {
-    const res = await this.httpRequest(
-      "POST",
-      `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/reject`,
-      reason ? { reason } : {}
-    );
-    if (res.status !== 200) {
-      throw new Error(res.data?.error || "Reject checkpoint failed");
-    }
-    return res.data;
+  rejectTaskCheckpoint(sessionId, taskId, reason) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/checkpoint/reject`, "Reject checkpoint failed", reason ? { reason } : {});
   }
-  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;
+  addTask(sessionId, task) {
+    return this.call("POST", `/api/plans/${sessionId}/tasks`, "Add task failed", task);
   }
-  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;
+  updateTask(sessionId, taskId, changes) {
+    return this.call("PUT", `/api/plans/${sessionId}/tasks/${taskId}`, "Update task failed", changes);
   }
-  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;
+  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");
@@ -804,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`);
@@ -829,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
@@ -895,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;
@@ -912,6 +770,7 @@ var ApiClient = class _ApiClient {
         resolve3();
       };
       this.executionStreams.set(sessionId, end);
+      endStream = end;
       socket.on("open", () => {
         opened = true;
         onReady?.();
@@ -928,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);
         }
       });
@@ -938,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
@@ -954,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;
   }
   /**
@@ -979,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);
   }
 };
 
@@ -1253,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;
   }
@@ -1319,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) {
@@ -1466,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) {
@@ -1584,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");
@@ -1756,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)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
+      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) {
@@ -1805,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);
@@ -1833,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();
@@ -1904,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}`);
     }
   }
 }
@@ -1961,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);
@@ -1979,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)) {
@@ -1998,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)"}`);
@@ -2032,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)");
@@ -2042,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):`
@@ -2094,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;
@@ -2166,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) {
@@ -2210,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) {
@@ -2388,7 +2248,7 @@ async function handleTransport(subArgs, api) {
 }
 
 // src/commands/task-control.ts
-var import_core15 = require("@ordewell/core");
+var import_core16 = require("@ordewell/core");
 var PAST_TENSE = {
   run: "Task started.",
   "force-start": "Task force-started.",
@@ -2431,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 = `${(0, import_core15.pastGateConfirmation)(unmerged.map((d) => (0, import_core15.titledTaskRef)(d)))} 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) {
@@ -2744,24 +2604,24 @@ async function handleRewind(subArgs, injectedApi) {
 }
 
 // src/tui/transcript.ts
-var import_core16 = 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_core16.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_core16.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_core16.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") };
@@ -3175,26 +3035,17 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core17 = 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_core17.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);
@@ -3203,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_core17.ALL_PROVIDERS[provider];
+  const meta = import_core18.ALL_PROVIDERS[provider];
   const catalog = await fetchCatalog(api);
   console.log(
-    (0, import_core17.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_core17.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>\`.`);
   }
 }
@@ -3233,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_core17.CLI_PROVIDERS) {
-    const runner = (0, import_core17.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_core17.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_core17.PROVIDER_PRIORITY) {
+  for (const id of import_core18.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core17.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(`
@@ -3258,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_core17.runnerForProvider)(provider);
+  const runner = isAiProvider(provider) ? (0, import_core18.runnerForProvider)(provider) : null;
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -3298,7 +3149,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core18 = 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);
@@ -3308,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_core18.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_core19 = 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);
@@ -3326,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_core19.PROVIDER_PRIORITY) {
-      const meta2 = import_core19.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}`);
     }
@@ -3337,7 +3188,7 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core19.ALL_PROVIDERS[id];
+  const meta = import_core20.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -3348,7 +3199,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var import_core20 = 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);
@@ -3379,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_core20.autonomyLevelLabel)(current)}`);
+    console.log(`Autonomy level: ${(0, import_core21.autonomyLevelLabel)(current)}`);
     console.log(`  ${AUTO_USAGE}`);
     return;
   }
-  const enabled = (0, import_core20.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_core20.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);
@@ -3419,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_core21 = 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);
@@ -3439,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_core21.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_core21.tmuxSessionName)(port);
-  const socket = (0, import_core21.tmuxSocketName)(port);
-  const base = (0, import_core21.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}"]);
@@ -3760,7 +3611,7 @@ ${(0, import_plan_utils.titledTaskRef)(task)} is ${task.ops ? "an ops task: it r
 }
 
 // src/tui/index.ts
-var import_core36 = require("@ordewell/core");
+var import_core37 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -4010,7 +3861,7 @@ function tokenCompletions(token) {
 }
 
 // src/tui/blocks.ts
-var import_core22 = require("@ordewell/core");
+var import_core23 = require("@ordewell/core");
 
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
@@ -4230,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_core22.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_core22.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_core22.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)));
@@ -4253,7 +4104,7 @@ var DIFF_PAINT = {
 };
 var DIFF_SIGN = { added: "+", removed: "-", context: " ", gap: "" };
 function diffLines(block, diff, room, detailAll) {
-  const rows = (0, import_core22.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)}`;
@@ -4262,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_core22.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);
@@ -4397,7 +4248,7 @@ function tokenLine(blocks, cols) {
 }
 
 // src/tui/state.ts
-var import_core23 = require("@ordewell/core");
+var import_core24 = require("@ordewell/core");
 var SKILL_IDS = ["tdd", "verify"];
 function noSkills() {
   return { tdd: false, verify: false };
@@ -4409,7 +4260,7 @@ function visibleItems(picker2) {
     (i) => i.id.toLowerCase().includes(filter) || i.label.toLowerCase().includes(filter) || (i.detail ?? "").toLowerCase().includes(filter)
   );
 }
-var anyTaskRunning = (state) => state.tasks.some(import_core23.isTaskRunning);
+var anyTaskRunning = (state) => state.tasks.some(import_core24.isTaskRunning);
 var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
 function planRows(state) {
   const rows = [];
@@ -4446,9 +4297,9 @@ function findTask(tasks, id) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core23.EMPTY_CONVERSATION,
+    conversation: import_core24.EMPTY_CONVERSATION,
     taskView: null,
-    turnGate: import_core23.NO_TURN,
+    turnGate: import_core24.NO_TURN,
     detailAll: false,
     status: "idle",
     busyLabel: "",
@@ -4473,7 +4324,7 @@ function initialState(overrides = {}) {
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
-    maxParallel: import_core23.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core24.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
@@ -4485,7 +4336,7 @@ function initialState(overrides = {}) {
     gate: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core23.EMPTY_HOLD,
+    queuedPrompts: import_core24.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4533,7 +4384,7 @@ function chatEditorRoomFor(state, active) {
 }
 
 // src/tui/layout.ts
-var import_core24 = require("@ordewell/core");
+var import_core25 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -4542,7 +4393,7 @@ function chatInputWrap(state) {
 }
 function footerHints(state) {
   const selected = selectedPlanRow(state)?.task;
-  const markHint = selected && (0, import_core24.markAction)(selected) === "uncomplete" ? "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";
@@ -4573,7 +4424,7 @@ function footerHints(state) {
       "tab chat"
     ];
   }
-  const detailHint = (0, import_core24.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",
@@ -4609,10 +4460,10 @@ function queuedTaskBubble(message, selected, cols) {
   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) {
-  const approvals = (0, import_core24.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 inRow((0, import_core24.awaitingLabel)(task) ?? "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) {
@@ -4687,9 +4538,9 @@ function chatScrollMax(state) {
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core24.ALL_PROVIDERS[provider];
+  const registration = import_core25.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core24.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 };
 }
@@ -4861,7 +4712,7 @@ function planScrollExtent(state) {
 }
 function taskLines(state, planRow, index, cols, orderOf) {
   const { task, parent } = planRow;
-  const row = (0, import_core24.taskRowView)(task, { parent, orderOf, modes: modesForTask(state.modesByRunner, task) });
+  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 rawIcon = row.status === "running" ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[row.status];
@@ -5008,7 +4859,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core25 = require("@ordewell/core");
+var import_core26 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -5273,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_core25.capConflictFiles)(task.repairedFiles)})`) : "";
-    return `  ${style.green("\u2713")} ${(0, import_core25.titledTaskRef)(task)}${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;
@@ -5363,10 +5214,10 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core33 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
 
 // src/tui/reducers/overlays.ts
-var import_core31 = require("@ordewell/core");
+var import_core32 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -5415,10 +5266,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core30 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core26 = 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 = {}) {
@@ -5437,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_core26.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_core26.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,
@@ -5455,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_core26.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 }];
   }
@@ -5519,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: (0, import_core26.titledTaskRef)(candidate),
+      label: (0, import_core27.titledTaskRef)(candidate),
       detail: candidate.status === "completed" ? "already completed" : void 0
     }));
   }
@@ -5564,28 +5415,24 @@ function pickerItemsFor(state, action) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core26.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core26.runnerForProvider)(id);
-    const ready = installed.has(runner);
-    return {
-      id,
-      label: import_core26.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_core26.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
-    id,
-    label: import_core26.ALL_PROVIDERS[id].label,
-    detail: import_core26.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_core28 = require("@ordewell/core");
+var import_core29 = require("@ordewell/core");
 
 // src/tui/reducers/pointer.ts
 var WHEEL_NOTCH = 3;
@@ -5663,13 +5510,13 @@ function handleMouseSelect(state, key) {
 }
 
 // src/tui/reducers/taskView.ts
-var import_core27 = 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_core27.EMPTY_TASK_LOG,
+    view: import_core28.EMPTY_TASK_LOG,
     attempts: [],
     attempt: 0,
     pending: [],
@@ -5702,13 +5549,13 @@ function applyLive(tv, attempt, events) {
     }
     next = {
       ...next,
-      view: import_core27.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_core27.reduceTaskLog, next.view) });
+  return clampQueueIndex({ ...next, view: events.reduce(import_core28.reduceTaskLog, next.view) });
 }
 function taskLogAbandoned(state) {
   const tv = state.taskView;
@@ -5728,14 +5575,14 @@ 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_core27.runnerToolSubject)(event.tool, event.args)} \u2014 t on it, then ctrl-y to allow or ctrl-g to deny`) : 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_core27.truncateCheckpointSummary)(action.summary)} \u2014 ${where}`);
+  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) {
@@ -5743,7 +5590,7 @@ function taskLogLoaded(state, action) {
   if (!tv || tv.taskId !== action.taskId) return state;
   const loaded = action.attempt >= 1 ? {
     ...tv,
-    view: (0, import_core27.replayTaskLog)(action.events),
+    view: (0, import_core28.replayTaskLog)(action.events),
     attempts: action.attempts ?? tv.attempts,
     attempt: action.attempt
   } : { ...tv, attempts: action.attempts ?? tv.attempts };
@@ -6120,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" ? (0, import_core28.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)]);
@@ -6155,14 +6002,14 @@ function commitTaskEdit(state, task, editor) {
     sessionId: state.sessionId,
     taskId: task.id,
     changes: { prompt },
-    message: `Task ${(0, import_core28.taskRef)(task)} prompt updated.`
+    message: `Task ${(0, import_core29.taskRef)(task)} prompt updated.`
   }]);
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core29 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core29.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);
@@ -6181,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_core29.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_core29.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core30.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core29.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core30.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -6205,7 +6052,7 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/commands.ts
-var KNOWN_PROVIDERS2 = Object.keys(import_core30.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.`);
@@ -6371,8 +6218,8 @@ function newSession(state) {
     taskView: null,
     tasks: [],
     planApproved: false,
-    conversation: import_core30.EMPTY_CONVERSATION,
-    turnGate: import_core30.NO_TURN,
+    conversation: import_core31.EMPTY_CONVERSATION,
+    turnGate: import_core31.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -6383,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_core30.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_core30.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}.`);
@@ -6413,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 }]);
@@ -6452,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]) {
@@ -6463,16 +6310,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core30.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core31.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core30.ALL_PROVIDERS[id].label,
-    detail: import_core30.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_core30.ALL_PROVIDERS[provider];
+  const meta = import_core31.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -6549,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_core30.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_core30.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
-  const enabled = (0, import_core30.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_core30.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) {
@@ -6738,7 +6585,7 @@ function choose(state, picker2, item) {
       sessionId: state.sessionId,
       taskId: task.id,
       changes: { dependencies: picker2.chosen },
-      message: picker2.chosen.length > 0 ? `Task ${(0, import_core31.taskRef)(task)} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task ${(0, import_core31.taskRef)(task)} 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);
@@ -6815,7 +6662,7 @@ function choose(state, picker2, item) {
 }
 
 // src/tui/reducers/incoming.ts
-var import_core32 = 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 : {};
@@ -6846,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_core32.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,
@@ -6879,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_core32.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(import_core23.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;
@@ -6950,13 +6797,13 @@ function reduceAction(state, action) {
         goal: "",
         taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core33.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_core33.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);
@@ -7003,9 +6850,9 @@ function reduceAction(state, action) {
     case "taskStarted": {
       if (stale(state, action.sessionId)) return step(state);
       const existing = findTask(state.tasks, action.taskId);
-      if (existing && (0, import_core23.isTaskRunning)(existing)) return step(state);
-      const tasks = state.tasks.map((t) => t.id === action.taskId && !(0, import_core23.isTaskRunning)(t) ? { ...t, status: "in_progress" } : t);
-      const spoken = say(state, "system", (0, import_core33.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":
@@ -7046,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));
@@ -7084,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":
@@ -7118,7 +6967,7 @@ function reduceAction(state, action) {
         busyLabel: "",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core33.EMPTY_HOLD,
+        queuedPrompts: import_core34.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
@@ -7185,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(import_core23.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";
 }
@@ -7254,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_core33.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 };
@@ -7314,10 +7163,10 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core35 = require("@ordewell/core");
+var import_core36 = require("@ordewell/core");
 
 // src/tui/inbound.ts
-var import_core34 = require("@ordewell/core");
+var import_core35 = require("@ordewell/core");
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
   "planner_message",
   "planner_turn_started",
@@ -7532,7 +7381,7 @@ function dispatchLifecycle(dispatch, event, sessionId) {
           idleSince: task.idleSince ?? null,
           isolation: task.isolation,
           transport: task.transport,
-          awaitingReason: (0, import_core34.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,
@@ -7558,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;
@@ -7614,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;
@@ -7632,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);
@@ -7702,19 +7542,15 @@ 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 === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : (0, import_core35.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
+      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": {
-      const fields = (0, import_core35.newTaskFields)(effect.title);
+      const fields = (0, import_core36.newTaskFields)(effect.title);
       if (!fields) return;
       await api.addTask(effect.sessionId, { ...fields });
       await refreshPlan(deps, effect.sessionId);
@@ -7835,11 +7671,11 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core35.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",
@@ -7847,7 +7683,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core35.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;
@@ -7859,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_core35.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);
@@ -7897,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_core35.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);
@@ -8031,7 +7867,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core35.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core36.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -8055,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);
@@ -8422,7 +8263,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core36.assertWorkspaceExists)(workspace);
+    (0, import_core37.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -8431,7 +8272,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core36.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 });
@@ -8448,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_core36.mintSessionId)(),
+      newSessionId: () => (0, import_core37.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -8499,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);
   });
@@ -8573,7 +8415,7 @@ function cliVersion() {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core37.migrateOldConfigDir)();
+  (0, import_core38.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");