@ordewell/cli 0.11.1 → 0.11.2

package/AUTHORS.md

@@ -27,6 +27,10 @@ record of who built what, rather than `git log`.
 - [@haltingstate](https://github.com/haltingstate) — made the terminal UI's
   stepper say what a saved step does next, instead of encoding it in a
   sentinel index (#123).
+- [@Logic769](https://github.com/Logic769) — made `/resume` an alias of
+  `/sessions` in the planner chat (#139).
+- Hanbin Tan ([@hskl18](https://github.com/hskl18)) — documented how
+  planners and runners get their models and credentials (#140).
 
 Thank you. Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
 

package/README.md

@@ -6,7 +6,7 @@ and model assigned to each AI task. With worktree isolation enabled, code tasks
 run in separate worktrees; ops and script tasks run at the workspace root.
 Ordewell records task outcomes and combines code changes for review and merging.
 
-This README describes 0.11.1. See the [published releases](https://github.com/ordewell/ordewell/releases)
+This README describes 0.11.2. See the [published releases](https://github.com/ordewell/ordewell/releases)
 for versions available to install and their release notes.
 
 ## Installation

package/dist/main.js

@@ -188,7 +188,7 @@ Planner, models and runners:
   ordewell trailer [on|off]       (headless) End Ordewell's commits with "Planned-with: Ordewell"; set only here or in settings.json
   ordewell autorun [on|off]       (headless) Start each plan the planner submits, without review; /settings covers it
   ordewell parallel [<n>]         (headless) How many AI tasks run at once, a live run included; /settings covers it
-  ordewell refresh                Re-discover runners and model catalogs
+  ordewell refresh                Re-check runners; reread settings and cached models
   ordewell models                 List every provider's catalog (works without a server)
 
 Other:
@@ -792,7 +792,7 @@ var ApiClient = class _ApiClient {
   }
   /** The full provider catalog the daemon has discovered (used by the TUI model picker). */
   getModels() {
-    return this.call("GET", "/api/models", "Failed to fetch models");
+    return this.call("GET", `/api/models?workspace=${encodeURIComponent(this.workspace)}`, "Failed to fetch models");
   }
   setRunnerEnabled(runner, enabled) {
     return this.call("PUT", `/api/runners/${runner}`, `Failed to ${enabled ? "enable" : "disable"} ${runner}`, { enabled });
@@ -1140,16 +1140,19 @@ var ApiClient = class _ApiClient {
       socket.close();
     } };
   }
+  // Every settings call names this workspace, as `getModels` does: the
+  // planner's model is judged against its runner catalog, which its own
+  // CLAUDE_CONFIG_DIR can make another account's than the daemon's cwd.
   getSettings(sessionId) {
-    const route = sessionId ? `/api/settings?sessionId=${encodeURIComponent(sessionId)}` : "/api/settings";
-    return this.call("GET", route, "Failed to fetch settings");
+    const session = sessionId ? `sessionId=${encodeURIComponent(sessionId)}&` : "";
+    return this.call("GET", `/api/settings?${session}workspace=${encodeURIComponent(this.workspace)}`, "Failed to fetch settings");
   }
   /** Save run settings (ADR-0030); with `sessionId`, that session's run takes them at once. */
   updateRunSettings(changes, sessionId) {
-    return this.call("PATCH", "/api/settings", "Change run settings failed", { run: changes, ...sessionId ? { sessionId } : {} });
+    return this.call("PATCH", "/api/settings", "Change run settings failed", { run: changes, ...sessionId ? { sessionId } : {}, workspace: this.workspace });
   }
   updateSettings(changes) {
-    return this.call("PATCH", "/api/settings", "Failed to update settings", changes);
+    return this.call("PATCH", "/api/settings", "Failed to update settings", { ...changes, workspace: this.workspace });
   }
 };
 
@@ -4995,6 +4998,7 @@ function initialState(overrides = {}) {
     runSettings: { ...import_core31.RUN_SETTINGS_DEFAULTS },
     runSettingsKnown: false,
     settingsRead: 0,
+    runSettingsRead: 0,
     plannerKnown: false,
     runnersKnown: false,
     providersKnown: false,
@@ -5283,7 +5287,7 @@ var SLASH_COMMANDS = [
   { name: "runners", usage: "/runners [<id> on|off]", description: `Enable or disable runners (${runnerIdList()})`, category: "models" },
   { name: "login", usage: "/login [<runner>]", description: "Sign the active coding agent in, or the one named, in this terminal", category: "models" },
   { name: "settings", usage: "/settings", description: "Run settings: autonomy, supervisor, merging, autorun and parallel tasks", category: "models" },
-  { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
+  { name: "refresh", usage: "/refresh", description: "Re-check runners; reread settings and cached models", category: "models" },
   // Sessions
   { name: "sessions", usage: "/sessions", description: "List saved sessions", category: "session" },
   { name: "fork", usage: "/fork", description: "Continue in a copy of this conversation and its tasks; the original stays as it is", category: "session" },
@@ -5298,7 +5302,27 @@ var SLASH_COMMANDS = [
   { name: "mouse", usage: "/mouse [on|off]", description: "Wheel scrolling and drag-select, per-pane in the body and full-width in the composer (on), or the terminal's own selection (off)", category: "system" },
   { name: "quit", usage: "/quit", description: "Exit the TUI", category: "system" }
 ];
-var BY_NAME = new Map(SLASH_COMMANDS.map((c) => [c.name, c]));
+var COMMAND_ALIASES = [
+  // Editors call reopening a saved session "resume"; here it must open the same
+  // saved-session picker as /sessions, not restart a task or a runner.
+  { name: "resume", target: "sessions", description: "Alias for /sessions: open a saved session, not restart a task" }
+];
+function slashCommandTable() {
+  const table2 = [];
+  for (const command of SLASH_COMMANDS) {
+    table2.push(command);
+    for (const alias of COMMAND_ALIASES) {
+      if (alias.target !== command.name) continue;
+      table2.push({ name: alias.name, usage: `/${alias.name}`, description: alias.description, category: command.category });
+    }
+  }
+  return table2;
+}
+var BY_NAME = new Map(slashCommandTable().map((c) => [c.name, c]));
+function canonicalCommandName(name) {
+  const key = name.replace(/^\//, "").toLowerCase();
+  return COMMAND_ALIASES.find((a) => a.name === key)?.target ?? key;
+}
 var skillCommands = [];
 var skillByName = /* @__PURE__ */ new Map();
 function registerSkillCommands(skills) {
@@ -5369,7 +5393,7 @@ function composerCompletions(token, runner) {
   return tokenCompletions(token).map((c) => c.name);
 }
 function tokenCompletions(token) {
-  const pool = token.start === 0 ? [...SLASH_COMMANDS, ...skillCommands] : skillCommands;
+  const pool = token.start === 0 ? [...slashCommandTable(), ...skillCommands] : skillCommands;
   return pool.filter((c) => c.name.startsWith(token.name));
 }
 
@@ -5929,6 +5953,8 @@ function chatActivity(state) {
   const own = findTask(state.tasks, tv.taskId);
   const task = state.tasks.find((t) => t.subtasks?.some((s) => s.id === tv.taskId)) ?? own;
   if (!task) return null;
+  const attaching = (0, import_core38.attachingLabel)(task);
+  if (attaching) return { label: `${attaching}\u2026`, busy: true };
   if ((0, import_core31.isTaskRunning)(task) || own && (0, import_core31.isTaskRunning)(own)) return { label: "Working\u2026", busy: true };
   const at = task.status === "awaiting_user" && task.awaitingReason === "usage-limit" && task.resumeAt ? new Date(task.resumeAt) : null;
   if (at && !Number.isNaN(at.getTime())) return { label: `paused \xB7 resumes ${(0, import_core38.resumeTime)(at)}`, busy: false };
@@ -6404,7 +6430,7 @@ function taskLines(state, planRow, index, cols) {
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${row.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = row.runner ?? "";
   const bodyPad = parent ? "      " : "    ";
-  const activity = row.approvals ? `${inRow(row.approvals)}: enter opens it` : row.awaiting ? inRow(row.awaiting) : row.receipt ? inRow(row.receipt) : "";
+  const activity = row.approvals ? `${inRow(row.approvals)}: enter opens it` : row.awaiting ? inRow(row.awaiting) : row.receipt ? inRow(row.receipt) : row.attaching ? inRow(row.attaching) : "";
   const skills = (task.skills ?? []).join(" \xB7 ");
   const meta = [activity, ...row.research && row.running ? [style.cyan("research")] : [], runner, model];
   const variant = task.type === "ai" ? sanitize(task.assignedModel?.thinkingEffort ?? "") : "";
@@ -6570,7 +6596,7 @@ function keySheetBody(cols) {
 function commandSheetBody(cols) {
   const body = [];
   for (const [category, title] of Object.entries(CATEGORY_TITLE)) {
-    const commands = SLASH_COMMANDS.filter((c) => c.category === category);
+    const commands = slashCommandTable().filter((c) => c.category === category);
     if (commands.length === 0) continue;
     body.push(style.bold(title));
     for (const command of commands) {
@@ -8087,7 +8113,8 @@ function stopPlanning(state, sessionId) {
 function queueToEditor(state) {
   const all = (0, import_core47.unsendAll)(state.queuedPrompts);
   if (!all) return state;
-  return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text: all.text, cursor: all.text.length } };
+  const text = (0, import_core47.aheadOfDraft)(all.text, state.editor.text);
+  return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text, cursor: all.text.length } };
 }
 function unsendLatest(state) {
   const latest = (0, import_core47.unsendLatest)(state.queuedPrompts);
@@ -8168,6 +8195,7 @@ function runTaskToView(t) {
     status: planLabel(t.status, "pending"),
     idleSince: t.idleSince ?? null,
     ...t.completionReceived === "done" || t.completionReceived === "failed" || t.completionReceived === "blocked" ? { completionReceived: t.completionReceived } : {},
+    ...t.attaching === 1 || t.attaching === 2 ? { attaching: t.attaching } : {},
     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,
@@ -8390,8 +8418,10 @@ function saveSettings(state, effect) {
 
 // src/tui/reducers/commands.ts
 var unknownCommand = (state, name) => fail3(state, `Unknown command: /${name}. Type /help to see what's available.`);
-function runCommand(state, { name, args }) {
-  if (!findCommand(name)) return unknownCommand(state, name);
+function runCommand(state, parsed) {
+  const name = canonicalCommandName(parsed.name);
+  const { args } = parsed;
+  if (!findCommand(parsed.name)) return unknownCommand(state, parsed.name);
   switch (name) {
     case "help":
       return step({ ...state, overlay: { kind: "help", scroll: 0 } });
@@ -8556,6 +8586,8 @@ function newSession(state) {
     planScroll: null,
     status: "idle",
     planner: "idle",
+    plannerPause: null,
+    plannerResend: null,
     // Prompts belong to the session that raised them; the old planner is gone
     // and its pending requests deny on their own timeout.
     pendingApprovals: [],
@@ -9019,6 +9051,8 @@ function reduceAction(state, action) {
       return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, accountLimits: [], servedModels: {}, taskView: null, status: "idle" }, import_core52.EMPTY_RUN));
     // A loaded session is a different one: the turn the old one had out, the
     // prompts held behind it and a stop armed against it are not this one's.
+    // Nor is an open prompt editor: task ids repeat across plans, so the
+    // loaded plan's `task-1` would keep it, and Enter save the old draft there.
     // (`sessionStarted` cannot reset them: `startConversation` dispatches it
     // as its own turn begins.)
     case "sessionLoaded":
@@ -9029,12 +9063,17 @@ function reduceAction(state, action) {
         sessionId: action.sessionId,
         goal: action.goal,
         taskView: null,
+        expandedTaskId: null,
+        taskEditor: null,
         status: "idle",
         planner: "idle",
+        plannerPause: null,
+        plannerResend: null,
         turnGate: import_core52.NO_TURN,
         pendingApprovals: [],
         queuedPrompts: import_core52.EMPTY_HOLD,
         stopArmed: false,
+        stopRequested: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay,
         runSettingsKnown: false
@@ -9045,21 +9084,25 @@ function reduceAction(state, action) {
     // id is let go rather than guessed at. A reply that was merely lost is not
     // this: the session is the daemon's and the turn may be running (`turnLost`).
     case "sessionCleared":
+      if (stale(state, action.sessionId)) return step(state);
       return step(withRun({
-        ...state,
+        ...queueToEditor(state),
         accountLimits: [],
         servedModels: {},
         sessionId: null,
         goal: "",
         taskView: null,
+        expandedTaskId: null,
+        taskEditor: null,
         status: "idle",
+        plannerPause: null,
+        plannerResend: null,
         turnGate: import_core52.NO_TURN,
         pendingApprovals: [],
-        queuedPrompts: import_core52.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay,
-        runSettingsKnown: false
+        runSettingsKnown: action.unreached ? state.runSettingsKnown : false
       }, import_core52.EMPTY_RUN));
     // Deleting the session on screen stops it in the daemon; a view left on it
     // would answer every next message with a session-not-found.
@@ -9262,12 +9305,16 @@ function reduceAction(state, action) {
       });
     }
     case "settingsLoaded": {
-      if (action.read !== void 0 && action.read < state.settingsRead) return step(state);
-      const forThisSession = action.sessionId === void 0 ? action.read === void 0 || state.sessionId === null : action.sessionId === state.sessionId;
-      const next = applySettings(state, action.settings, forThisSession);
+      const { read } = action;
+      const forThisSession = action.sessionId === void 0 ? read === void 0 || state.sessionId === null : action.sessionId === state.sessionId;
+      const workspaceFresh = read === void 0 || read >= state.settingsRead;
+      const runFresh = forThisSession && (read === void 0 || read >= state.runSettingsRead);
+      if (!workspaceFresh && !runFresh) return step(state);
+      const next = workspaceFresh ? applySettings(state, action.settings, runFresh) : applySettings(state, { run: action.settings.run }, true);
       return step(refreshStepper({
         ...next,
-        settingsRead: action.read !== void 0 && forThisSession ? Math.max(state.settingsRead, action.read) : state.settingsRead
+        settingsRead: read !== void 0 && workspaceFresh ? Math.max(state.settingsRead, read) : state.settingsRead,
+        runSettingsRead: read !== void 0 && runFresh ? Math.max(state.runSettingsRead, read) : state.runSettingsRead
       }));
     }
     case "modelsLoaded":
@@ -9293,13 +9340,17 @@ function reduceAction(state, action) {
       return step(refillPicker({ ...state, rewindTargets: action.targets }, ["rewind"]));
     // A fork holds no run and no turn, whatever the session it came from was
     // doing — the original keeps both, and its events are stale from here on.
-    // Its plan arrives next, onto an empty run view.
+    // Its plan arrives next, onto an empty run view. Nor does it keep an open
+    // prompt editor: the fork copies the task ids, so Enter would save the
+    // original's draft into the fork.
     case "sessionForked":
       return step(withRun({
         ...state,
         sessionId: action.sessionId,
         goal: action.goal,
         taskView: null,
+        expandedTaskId: null,
+        taskEditor: null,
         status: "idle",
         planner: "idle",
         turnGate: import_core52.NO_TURN,
@@ -9307,6 +9358,7 @@ function reduceAction(state, action) {
         pendingApprovals: [],
         queuedPrompts: import_core52.EMPTY_HOLD,
         stopArmed: false,
+        stopRequested: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay,
         runSettingsKnown: false
@@ -9347,6 +9399,7 @@ function reduceAction(state, action) {
     case "daemonReconnected":
       return step(state, [{ type: "loadIsolationPreview" }]);
     case "failed": {
+      if (state.sessionId !== null && stale(state, action.sessionId)) return step(state);
       if (!action.turn) {
         const abandoned = reportError(taskLogAbandoned(state), action.message);
         return step(state.status === "starting" ? { ...abandoned, status: "idle" } : abandoned);
@@ -9367,7 +9420,10 @@ function reduceAction(state, action) {
       if (!plannerInFlight(state)) return step(reported);
       return drainQueue(state, reported);
     }
+    // As `failed`: an opening that let itself go asks on the welcome it left,
+    // never over a session loaded meanwhile.
     case "workspaceNeedsInit":
+      if (state.sessionId !== null && stale(state, action.sessionId)) return step(state);
       return step({
         ...state,
         planner: "idle",
@@ -9378,7 +9434,23 @@ function reduceAction(state, action) {
           action: { kind: "init-workspace", goal: action.goal, workspace: action.workspace }
         }
       });
+    // A refused opening stays on screen while the daemon is revived; the
+    // user may have moved to another session or a fresh welcome since, and
+    // that view, its queue and its planner are not the opening's to take.
+    case "openingRevived": {
+      const restarted = "The server had stopped; started a new one";
+      if (stale(state, action.sessionId)) {
+        return step(say(state, "system", `${restarted}. "${action.goal}" was not sent again, as it is no longer the session on screen.`));
+      }
+      if (!plannerInFlight(state) || state.stopRequested) {
+        const cleared = reduceAction(state, { type: "sessionCleared", sessionId: action.sessionId, unreached: true }).state;
+        return step(say({ ...cleared, planner: "idle", stopRequested: false }, "system", `${restarted}. The goal was not sent again, as planning was stopped.`));
+      }
+      const retry = { type: "startConversation", goal: action.goal, sessionId: action.sessionId, ...action.allowInit ? { allowInit: true } : {} };
+      return step(say(state, "system", `${restarted} and retried.`), [retry]);
+    }
     case "notice":
+      if (stale(state, action.sessionId)) return step(state);
       return step(say(state, action.level === "error" ? "error" : "system", action.message, !action.holdPlace));
     case "resize": {
       const resized = { ...state, rows: action.rows, cols: action.cols, selection: null };
@@ -10024,23 +10096,40 @@ function dispatchLifecycle(dispatch, event, sessionId) {
 
 // src/tui/effects.ts
 async function runEffect(effect, deps) {
+  const performed = effect.type === "startConversation" ? { ...effect, sessionId: effect.sessionId ?? deps.newSessionId() } : effect;
+  const opening = performed.type === "startConversation" ? performed : null;
   const turn = isPlannerTurn(effect);
-  const fail4 = (action) => deps.dispatch(turn ? { ...action, turn } : action);
+  const turnSession = turn && "sessionId" in performed ? { sessionId: performed.sessionId } : {};
+  const fail4 = (action) => deps.dispatch(turn ? { ...action, turn, ...turnSession } : action);
   try {
-    await perform(effect, deps);
+    await perform(performed, deps);
   } catch (err) {
     if (!isConnectionRefused(err)) {
       fail4(failedFrom(err));
       return;
     }
     let revived = false;
-    try {
-      revived = await deps.reviveDaemon();
-    } catch {
-      revived = false;
+    if (effect.type !== "startConversation" || effect.sessionId === void 0) {
+      try {
+        revived = await deps.reviveDaemon();
+      } catch {
+        revived = false;
+      }
     }
     if (!revived) {
+      if (opening) deps.dispatch({ type: "sessionCleared", sessionId: opening.sessionId, unreached: true });
       fail4({ type: "failed", message: describeConnectionRefused(deps.port) });
+      if (opening) await reloadSettings(deps);
+      return;
+    }
+    if (opening) {
+      deps.dispatch({ type: "daemonReconnected" });
+      deps.dispatch({
+        type: "openingRevived",
+        sessionId: opening.sessionId,
+        goal: opening.goal,
+        ...opening.allowInit ? { allowInit: opening.allowInit } : {}
+      });
       return;
     }
     deps.dispatch({ type: "notice", message: "The server had stopped; started a new one and retried." });
@@ -10048,7 +10137,7 @@ async function runEffect(effect, deps) {
       deps.dispatch({ type: "daemonReconnected" });
     }
     try {
-      await perform(effect, deps);
+      await perform(performed, deps);
     } catch (retryErr) {
       fail4(isConnectionRefused(retryErr) ? { type: "failed", message: describeConnectionRefused(deps.port) } : failedFrom(retryErr));
     }
@@ -10084,7 +10173,7 @@ async function perform(effect, deps) {
   const { api, dispatch, workspace } = deps;
   switch (effect.type) {
     case "startConversation": {
-      const sessionId = deps.newSessionId();
+      const { sessionId } = effect;
       dispatch({ type: "sessionStarted", sessionId, goal: effect.goal });
       try {
         await converse(deps, sessionId, () => api.startConversation(sessionId, effect.goal, void 0, workspace, effect.allowInit), true);
@@ -10093,11 +10182,15 @@ async function perform(effect, deps) {
           await reloadSettings(deps, sessionId);
           throw err;
         }
+        if (isConnectionRefused(err)) {
+          unfollow(deps, sessionId);
+          throw err;
+        }
         unfollow(deps, sessionId);
-        dispatch({ type: "sessionCleared" });
+        dispatch({ type: "sessionCleared", sessionId });
         await reloadSettings(deps);
         if (err instanceof WorkspaceInitNeededError && !effect.allowInit) {
-          dispatch({ type: "workspaceNeedsInit", goal: effect.goal, workspace: err.workspace });
+          dispatch({ type: "workspaceNeedsInit", goal: effect.goal, workspace: err.workspace, sessionId });
           return;
         }
         throw err;
@@ -10167,7 +10260,7 @@ async function perform(effect, deps) {
       try {
         await api.respondToApproval(effect.sessionId, effect.approvalId, effect.granted);
       } catch {
-        dispatch({ type: "failed", message: "Could not deliver the approval answer: the planner will treat it as denied." });
+        dispatch({ type: "failed", message: "Could not deliver the approval answer: the planner will treat it as denied.", sessionId: effect.sessionId });
       }
       return;
     }
@@ -10176,7 +10269,7 @@ async function perform(effect, deps) {
       try {
         await api.respondToApproval(effect.sessionId, effect.approvalId, effect.answer);
       } catch {
-        dispatch({ type: "failed", message: "Could not deliver the answer: the task is still waiting for approval." });
+        dispatch({ type: "failed", message: "Could not deliver the answer: the task is still waiting for approval.", sessionId: effect.sessionId });
       }
       return;
     }
@@ -10693,7 +10786,7 @@ async function converse(deps, sessionId, call, opening = false) {
   }
   if (unusable) {
     const { err, shown } = unusable;
-    deps.dispatch({ ...failedFrom(shown ? new Error(`The planner's reply arrived but could not be shown: ${explain(err)}`) : err), turn: true });
+    deps.dispatch({ ...failedFrom(shown ? new Error(`The planner's reply arrived but could not be shown: ${explain(err)}`) : err), turn: true, sessionId });
   } else if (lost !== null) {
     await settleLostReply(deps, sessionId, { opening, reason: lost });
   }
@@ -10737,15 +10830,15 @@ async function readBackSession(deps, sessionId, how) {
   } catch (err) {
     if (err instanceof DaemonError && err.code === "session_not_found" && how.opening) {
       unfollow(deps, sessionId);
-      deps.dispatch({ type: "sessionCleared" });
-      deps.dispatch({ type: "failed", message: "The reply was lost and the server holds no session for it. Send your goal again to start over.", code: err.code, turn: true });
+      deps.dispatch({ type: "sessionCleared", sessionId });
+      deps.dispatch({ type: "failed", message: "The reply was lost and the server holds no session for it. Send your goal again to start over.", code: err.code, turn: true, sessionId });
       return;
     }
     if (how.turnEnded || err instanceof DaemonError && err.code === "session_not_found") {
-      deps.dispatch({ ...failedFrom(err), turn: true });
+      deps.dispatch({ ...failedFrom(err), turn: true, sessionId });
       return;
     }
-    deps.dispatch({ type: "notice", level: "error", message: `Could not read the session back from the server: ${explain(err)}` });
+    deps.dispatch({ type: "notice", level: "error", message: `Could not read the session back from the server: ${explain(err)}`, sessionId });
   }
 }
 function restoredChat(plan, sessionId) {
@@ -11208,6 +11301,7 @@ var writeLine = (line) => console.error(line);
 var toStderr = { onNotice: writeLine, onUpdate: writeLine };
 
 // src/tui/index.ts
+var DAEMON_STOP_GRACE_MS = 3e3;
 async function runLogin(start, command, cwd, env) {
   const plan = await (0, import_core55.planDirectLaunch)(command[0], command.slice(1));
   return new Promise((resolve6, reject) => {
@@ -11353,12 +11447,19 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
   const { rows, cols } = terminal.size();
   app.dispatch({ type: "resize", rows, cols });
   app.start();
+  let exiting = false;
   function shutdown(code) {
+    if (exiting) return process.exit(code);
+    exiting = true;
     watchingSettings.dispose();
     terminal?.close();
-    if (owned) stopDaemon(port).catch(() => {
+    if (!owned) return process.exit(code);
+    const grace = setTimeout(() => process.exit(code), DAEMON_STOP_GRACE_MS);
+    void stopDaemon(port).catch(() => {
+    }).finally(() => {
+      clearTimeout(grace);
+      process.exit(code);
     });
-    process.exit(code);
   }
   process.on("SIGINT", () => {
     if (loginRunning) return;

package/package.json

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