@addai/node 0.30.7 → 0.30.10

package/dist/capabilities.js

@@ -92,16 +92,45 @@ function runCmd(cmd, args, timeoutMs = 5000) {
         }
     });
 }
-// Curated model lists baked into the daemon. The CLIs don't expose a
-// stable "list models" command; the daemon reports whatever the
-// installed daemon version knows about, so bumping the daemon refreshes
-// the UI's dropdown.
+// Curated model lists baked into the daemon. The CLIs still expose no
+// non-interactive "list models" command, so this stays a constant — but
+// WHAT goes in it is what decides whether the UI's dropdown rots.
+//
+// Do not "fix" this by probing the CLI. Checked against Claude Code
+// 2.1.266: there is no `claude models` subcommand and no `claude config
+// list`. Both strings are read as a PROMPT — the CLI starts a billed
+// session and answers in prose. Probing that on every heartbeat would
+// spend money several times a minute and still return nothing parseable.
+//
+// `claude --help` documents the real contract instead: --model takes
+// "an alias for the latest model (e.g. 'fable', 'opus', or 'sonnet') or
+// a model's full name (e.g. 'claude-fable-5')".
+//
+// So the ALIASES lead the list. They are the only entries that cannot go
+// stale — the CLI resolves each to whatever is current in its tier — and
+// staleness is exactly what went wrong before: this list was still
+// offering claude-opus-4-1 and claude-sonnet-4-5 long after they were
+// superseded, and no amount of heartbeating fixes a wrong constant.
+// Pinned ids follow, newest first, for anyone who must hold one model.
+//
+// Availability is plan-gated (these nodes sign in with claude.ai
+// subscriptions, not API keys), so a listed model can still be refused
+// at spawn time — the CLI stays the source of truth for validity, the
+// same way model-filter.ts already assumes.
 const CLAUDE_MODELS = [
+    // Aliases — always the latest in their tier.
+    'opus',
+    'sonnet',
+    'haiku',
+    'fable',
+    // Pinned ids, newest first.
+    'claude-opus-5',
+    'claude-sonnet-5',
+    'claude-fable-5-1',
+    'claude-opus-4-8',
     'claude-opus-4-7',
     'claude-sonnet-4-6',
     'claude-haiku-4-5',
-    'claude-opus-4-1',
-    'claude-sonnet-4-5',
 ];
 const CODEX_MODELS = [
     'gpt-5',

package/dist/claude-print.js

@@ -11,6 +11,7 @@ exports.spawnClaudePrint = spawnClaudePrint;
 const child_process_1 = require("child_process");
 const claude_binary_1 = require("./claude-binary");
 const win_1 = require("./win");
+const claude_system_prompt_1 = require("./claude-system-prompt");
 /**
  * The text to emit for one flushed block, given what came before.
  *
@@ -174,9 +175,13 @@ function spawnClaudePrint(input) {
     // its node script instead (identity on POSIX). It can throw; so can
     // spawn() itself (synchronously, on win32). Surface either as a normal
     // rejected `done` so callers keep their single error path.
+    // An entity system prompt of tens of thousands of characters does not fit
+    // on a Windows command line — see claude-system-prompt.ts. No-op when it
+    // fits, which is every case that works today.
+    const sysPrompt = (0, claude_system_prompt_1.offloadLongSystemPrompt)(bin, args);
     let proc;
     try {
-        const inv = (0, win_1.resolveCliInvocation)(bin, args);
+        const inv = (0, win_1.resolveCliInvocation)(bin, sysPrompt.args);
         proc = (0, child_process_1.spawn)(inv.file, inv.args, {
             cwd: input.workingDirectory,
             env: { ...process.env, TERM: 'dumb' },
@@ -187,6 +192,7 @@ function spawnClaudePrint(input) {
         });
     }
     catch (err) {
+        sysPrompt.cleanup();
         const done = Promise.reject(err instanceof Error ? err : new Error(String(err)));
         // Mark handled now — the caller awaits `done` a few ticks later, and an
         // already-rejected promise with no handler would fire unhandledRejection.
@@ -332,6 +338,7 @@ function spawnClaudePrint(input) {
     const done = new Promise((resolve, reject) => {
         proc.once('error', reject);
         proc.once('exit', (code) => {
+            sysPrompt.cleanup();
             flushThinking();
             flushText();
             const trimmed = stderrBuf.trim();

package/dist/claude-spawn.js

@@ -47,6 +47,7 @@ const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
 const claude_binary_1 = require("./claude-binary");
 const win_1 = require("./win");
+const claude_system_prompt_1 = require("./claude-system-prompt");
 const mcp_config_1 = require("./mcp-config");
 const paths_1 = require("./paths");
 function resolveMcpFilter(workingDirectory, enabled) {
@@ -150,6 +151,11 @@ function spawnClaudeForRuntime(input) {
         ...entityFlags,
         ...claudeArgs,
     ];
+    // Same overflow as claude-print: a long --append-system-prompt does not fit
+    // on a Windows command line. Applied before the branch so both the ConPTY
+    // and the POSIX shell form get the shortened argv; cleaned up in onExit
+    // beside the temp MCP config.
+    const sysPrompt = (0, claude_system_prompt_1.offloadLongSystemPrompt)(claudeBin, effectiveArgs);
     let shell;
     let shellArgs;
     if (isWin) {
@@ -160,14 +166,14 @@ function spawnClaudeForRuntime(input) {
         // node script (run via process.execPath) or passes an .exe straight
         // through; either target parses argv via CommandLineToArgvW, matching
         // node-pty's quoting. ConPTY handles both fine.
-        const inv = (0, win_1.resolveCliInvocation)(claudeBin, effectiveArgs);
+        const inv = (0, win_1.resolveCliInvocation)(claudeBin, sysPrompt.args);
         shell = inv.file;
         shellArgs = inv.args;
     }
     else {
         // `exec "$@"` passes positional args straight through without shell escaping.
         shell = process.env.SHELL || '/bin/bash';
-        shellArgs = ['-l', '-c', 'exec "$@"', '_', claudeBin, ...effectiveArgs];
+        shellArgs = ['-l', '-c', 'exec "$@"', '_', claudeBin, ...sysPrompt.args];
     }
     const proc = pty.spawn(shell, shellArgs, {
         name: 'xterm-256color',
@@ -196,6 +202,7 @@ function spawnClaudeForRuntime(input) {
                 l(exitCode);
             }
             catch { }
+        sysPrompt.cleanup();
         // best-effort cleanup of any temp MCP config
         if (mcpConfigPath) {
             try {

package/dist/claude-system-prompt.d.ts

@@ -0,0 +1,18 @@
+/** Rough rendered length of `file` + `args` as one command line. Counts two
+ *  quotes and a separating space per argument — the shape a renderer uses for
+ *  anything that might contain whitespace. */
+export declare function commandLineLength(file: string, args: string[]): number;
+export interface OffloadResult {
+    args: string[];
+    /** Removes the temp file, if one was written. Safe to call more than once. */
+    cleanup: () => void;
+}
+/**
+ * Swap an oversized inline system prompt for a file-backed one.
+ *
+ * Returns the args unchanged (and a no-op cleanup) whenever the command line
+ * already fits, whenever there is no --append-system-prompt to move, or when
+ * the temp file cannot be written — in that last case the spawn is left to
+ * fail with its own error rather than a worse one invented here.
+ */
+export declare function offloadLongSystemPrompt(file: string, args: string[], isWindows?: boolean): OffloadResult;

package/dist/claude-system-prompt.js

@@ -0,0 +1,110 @@
+"use strict";
+// A long --append-system-prompt does not fit on a Windows command line.
+//
+// CreateProcess caps the entire command line at 32,767 characters, and an
+// entity's system prompt is routinely tens of thousands — Hannah's was 31,004,
+// which with the user prompt and the rest of the flags overflowed, and every
+// run died with a bare `spawn ENAMETOOLONG` and no hint of which argument was
+// to blame. POSIX is nowhere near its limit at these sizes (ARG_MAX is ~256KB
+// on macOS, ~2MB on Linux), which is why this only ever bit on Windows — and
+// only once claude could be spawned there at all.
+//
+// claude takes the same text from a file, so when the rendered command line
+// would not fit, the prompt is written to a temp file and the flag becomes
+// --append-system-prompt-file. ONLY when it would not fit: the inline form is
+// what every working install uses today and an older claude may not know the
+// -file variant, so nothing that currently works changes shape.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandLineLength = commandLineLength;
+exports.offloadLongSystemPrompt = offloadLongSystemPrompt;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const INLINE_FLAG = '--append-system-prompt';
+const FILE_FLAG = '--append-system-prompt-file';
+/** Head-room under the real 32,767 limit. Both node and node-pty escape quotes
+ *  and backslashes when they render argv into a command line, so what actually
+ *  reaches CreateProcess is longer than the sum of the arguments. */
+const WINDOWS_BUDGET = 30_000;
+/** POSIX only needs catching if a prompt has gone genuinely pathological. */
+const POSIX_BUDGET = 120_000;
+/** Rough rendered length of `file` + `args` as one command line. Counts two
+ *  quotes and a separating space per argument — the shape a renderer uses for
+ *  anything that might contain whitespace. */
+function commandLineLength(file, args) {
+    return args.reduce((n, a) => n + a.length + 3, file.length + 3);
+}
+/**
+ * Swap an oversized inline system prompt for a file-backed one.
+ *
+ * Returns the args unchanged (and a no-op cleanup) whenever the command line
+ * already fits, whenever there is no --append-system-prompt to move, or when
+ * the temp file cannot be written — in that last case the spawn is left to
+ * fail with its own error rather than a worse one invented here.
+ */
+function offloadLongSystemPrompt(file, args, isWindows = process.platform === 'win32') {
+    const noop = { args, cleanup: () => { } };
+    const budget = isWindows ? WINDOWS_BUDGET : POSIX_BUDGET;
+    if (commandLineLength(file, args) <= budget)
+        return noop;
+    const i = args.indexOf(INLINE_FLAG);
+    if (i < 0 || i + 1 >= args.length)
+        return noop;
+    const promptPath = path.join(os.tmpdir(), `ainode-sysprompt-${(0, crypto_1.randomUUID)()}.txt`);
+    try {
+        fs.writeFileSync(promptPath, args[i + 1], 'utf8');
+    }
+    catch {
+        return noop;
+    }
+    const next = args.slice();
+    next[i] = FILE_FLAG;
+    next[i + 1] = promptPath;
+    let removed = false;
+    return {
+        args: next,
+        cleanup: () => {
+            if (removed)
+                return;
+            removed = true;
+            try {
+                fs.unlinkSync(promptPath);
+            }
+            catch { /* swept from tmp anyway */ }
+        },
+    };
+}

package/dist/cli.js

@@ -202,6 +202,10 @@ async function main() {
             pid: runtime.pid,
             startedAt: Date.now(),
             version: index_1.VERSION,
+            // The daemon is running in this process, so the dashboard needs a way to
+            // stop it properly when the user actually asks — and, just as important,
+            // a way to tell that case apart from the terminal disappearing.
+            stop: runtime.stop,
         });
         return;
     }

package/dist/desktop/relay-client.js

@@ -71,13 +71,25 @@ const IDLE_CHECK_MS = 60_000;
  *  leaves a half-open socket that never fires 'close', so without this the
  *  client sits holding a dead handle and never reconnects. */
 const PING_INTERVAL_MS = 30_000;
+/** How often to ask the relay which deploy is answering. Cloud Run keeps a
+ *  retiring instance alive until its in-flight connections end — for this
+ *  socket, the hourly cut — so after a relay deploy this node sat attached to
+ *  the OLD instance, pongs and all, while every viewer landed on the new one
+ *  and was told the machine was offline. The relay's greeting names the
+ *  instance this socket reached; /health is answered by the live one. When
+ *  the two differ, move. */
+const REVISION_CHECK_MS = 60_000;
+const RELAY_HTTP_URL = RELAY_URL.replace(/^ws/, 'http');
 let ws = null;
 let stopped = true;
 let backoff = RECONNECT_MIN_MS;
 let idleTimer = null;
-let liveTimer = null;
-/** Set on every pong; cleared when a ping goes out. Two misses = dead. */
-let missedPongs = 0;
+/** Silences the CURRENT socket's timers; set when a socket opens so
+ *  stopRelayClient can reach them. Each socket owns its own timers and miss
+ *  count: a socket closing late used to clear the module-wide timer, which by
+ *  then belonged to its replacement — leaving the live socket with no ping
+ *  loop and no way to notice a dead link. */
+let clearCurrentTimers = null;
 /** viewerId -> that viewer's OWN TCP socket to the desktop's RFB port.
  *  Keyed per viewer, not per desktop: RFB is a stateful 1:1 protocol, so two
  *  people watching the same screen each need their own connection and their
@@ -157,16 +169,51 @@ async function connect() {
     }
     const sock = new ws_1.default(`${RELAY_URL}/node?token=${encodeURIComponent(token)}`);
     ws = sock;
+    // Which deploy of the relay this socket reached, from its greeting. Null
+    // until the relay says — an older relay never does, and then there is
+    // nothing to compare and the check stays quiet.
+    let attachedRevision = null;
+    /** Set on every pong; cleared when a ping goes out. Two misses = dead. */
+    let missedPongs = 0;
+    let pingTimer = null;
+    let revisionTimer = null;
+    const clearTimers = () => {
+        if (pingTimer) {
+            clearInterval(pingTimer);
+            pingTimer = null;
+        }
+        if (revisionTimer) {
+            clearInterval(revisionTimer);
+            revisionTimer = null;
+        }
+        if (clearCurrentTimers === clearTimers)
+            clearCurrentTimers = null;
+    };
+    const checkRevision = async () => {
+        if (!attachedRevision || sock.readyState !== ws_1.default.OPEN)
+            return;
+        let live;
+        try {
+            const res = await fetch(`${RELAY_HTTP_URL}/health`, { signal: AbortSignal.timeout(8_000) });
+            live = (await res.json()).revision;
+        }
+        catch {
+            return;
+        } // could not ask; the ping loop still guards the link
+        if (live && live !== attachedRevision && sock.readyState === ws_1.default.OPEN) {
+            console.warn(`[relay] the relay moved from ${attachedRevision} to ${live} — reconnecting`);
+            sock.terminate(); // 'close' → retry → redial, onto the live instance
+        }
+    };
     sock.on('open', () => {
         backoff = RECONNECT_MIN_MS;
-        missedPongs = 0;
-        if (liveTimer)
-            clearInterval(liveTimer);
+        clearCurrentTimers?.();
+        clearCurrentTimers = clearTimers;
         // A suspended Mac comes back with a socket that looks open and is not.
         // Ping until two go unanswered, then tear it down so the normal backoff
         // path reconnects - the daemon's own sleep detector reports the same
         // suspends this is guarding against.
-        liveTimer = setInterval(() => {
+        pingTimer = setInterval(() => {
             if (sock.readyState !== ws_1.default.OPEN) {
                 sock.terminate();
                 return;
@@ -184,6 +231,7 @@ async function connect() {
                 sock.terminate();
             }
         }, PING_INTERVAL_MS);
+        revisionTimer = setInterval(() => { void checkRevision(); }, REVISION_CHECK_MS);
     });
     sock.on('pong', () => { missedPongs = 0; });
     sock.on('message', async (raw) => {
@@ -208,6 +256,11 @@ async function connect() {
                 sock.send(JSON.stringify({ type: 'gone', viewerId, reason }));
             }
         };
+        if (msg.type === 'hello') {
+            attachedRevision = msg.revision ?? null;
+            console.log(`[relay] connected — relay revision ${attachedRevision ?? '?'}`);
+            return;
+        }
         if (msg.type === 'attach') {
             // Claim the viewer BEFORE the await, so a packet arriving during the
             // lookup is held rather than treated as arriving after a lost bridge.
@@ -312,10 +365,7 @@ async function connect() {
         }
     });
     const retry = () => {
-        if (liveTimer) {
-            clearInterval(liveTimer);
-            liveTimer = null;
-        }
+        clearTimers(); // only ever this socket's own
         if (ws !== sock)
             return; // superseded by a newer socket
         dropBridges();
@@ -338,10 +388,7 @@ function stopRelayClient() {
         clearTimeout(idleTimer);
         idleTimer = null;
     }
-    if (liveTimer) {
-        clearInterval(liveTimer);
-        liveTimer = null;
-    }
+    clearCurrentTimers?.();
     dropBridges();
     try {
         ws?.close();

package/dist/index.js

@@ -376,7 +376,7 @@ async function sweepStaleSessionDirs() {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const path = require('path');
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { RUNTIME_SESSIONS_DIR } = require('./paths');
+    const { RUNTIME_SESSIONS_DIR, RUNTIME_LOG_FILE } = require('./paths');
     if (!fs.existsSync(RUNTIME_SESSIONS_DIR))
         return;
     const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
@@ -404,30 +404,63 @@ async function sweepStaleSessionDirs() {
         catch { /* unreadable dir — fall back to its own mtime */ }
         return newest;
     };
-    let removed = 0;
+    // Deleting a session dir un-homes any chat still resuming a session keyed to
+    // it, so the names have to be recoverable — a bare count made that class of
+    // breakage invisible. But a node that has been up for months sweeps hundreds
+    // at once, and one console line each buried the dashboard under a screenful
+    // of scrollback on every single start. So: the full list goes to the daemon
+    // log, and the terminal gets a sample and the totals.
+    const SHOWN = 5;
+    const swept = [];
+    const failures = [];
     let kept = 0;
     for (const name of fs.readdirSync(RUNTIME_SESSIONS_DIR)) {
         const p = path.join(RUNTIME_SESSIONS_DIR, name);
+        let st;
         try {
-            const st = fs.statSync(p);
-            if (!st.isDirectory())
-                continue;
-            if (effectiveMtimeMs(p, st.mtimeMs) < cutoff) {
-                // Deleting a session dir un-homes any chat still resuming a session
-                // keyed to it, so say which ones went — the old count-only line made
-                // that class of breakage invisible.
-                console.log(`[startup] sweeping stale session dir: ${p}`);
-                fs.rmSync(p, { recursive: true, force: true });
-                removed++;
-            }
-            else {
-                kept++;
-            }
+            st = fs.statSync(p);
+        }
+        catch {
+            continue; /* unreadable entry */
+        }
+        if (!st.isDirectory())
+            continue;
+        if (effectiveMtimeMs(p, st.mtimeMs) >= cutoff) {
+            kept++;
+            continue;
+        }
+        try {
+            fs.rmSync(p, { recursive: true, force: true });
+            swept.push(p);
+        }
+        catch (err) {
+            // A dir we cannot delete comes back every start. It used to be announced
+            // as swept each time, forever, with the real error swallowed — so the
+            // one line that would explain a home disk filling up never appeared.
+            failures.push(`${p}: ${err.message}`);
         }
-        catch { /* skip unreadable entry */ }
     }
-    if (removed > 0) {
-        console.log(`[startup] swept ${removed} session dir(s) unused for 7d; ${kept} kept`);
+    if (swept.length === 0 && failures.length === 0)
+        return;
+    // Append before logging: the console line points at this file, so it had
+    // better already say what happened by the time anyone opens it.
+    try {
+        const stamp = new Date().toISOString();
+        const body = [
+            ...swept.map(p => `${stamp} [startup] swept stale session dir: ${p}`),
+            ...failures.map(l => `${stamp} [startup] could NOT sweep session dir ${l}`),
+        ].join('\n');
+        fs.appendFileSync(RUNTIME_LOG_FILE, `${body}\n`);
+    }
+    catch { /* the sweep still happened; losing the record is not fatal */ }
+    if (swept.length > 0) {
+        const sample = swept.slice(0, SHOWN).map(p => path.basename(p));
+        const more = swept.length > SHOWN ? `, +${swept.length - SHOWN} more` : '';
+        console.log(`[startup] swept ${swept.length} session dir(s) unused for 7d; ${kept} kept`);
+        console.log(`[startup]   ${sample.join(', ')}${more} — full list in ${RUNTIME_LOG_FILE}`);
+    }
+    if (failures.length > 0) {
+        console.error(`[startup] ${failures.length} stale session dir(s) could not be deleted — first: ${failures[0]}`);
     }
 }
 /** How long a remote restart waits for live turns to finish before handing

package/dist/tui/run.d.ts

@@ -3,11 +3,38 @@ export declare function shouldRenderTui(env: {
     stdinTTY: boolean;
     noTui: boolean;
 }): boolean;
+/** Why the console gave the terminal back. Only `quit` is the user asking
+ *  to stop; the rest are the terminal being taken away underneath us. */
+export type LeaveReason = 'quit' | 'SIGHUP' | 'SIGTTIN' | 'SIGTTOU' | 'stdin-error';
+/** What giving the terminal back should cost. */
+export type LeaveAction = 
+/** Close the screen and go — nothing of ours is running here. */
+'exit'
+/** Drain the in-process daemon first, then go. */
+ | 'shutdown'
+/** Close the screen and keep the daemon running headless. */
+ | 'detach';
+/**
+ * The rule that decides whether this node survives the night.
+ *
+ * `ainode` runs the daemon in the SAME process as the dashboard, and every
+ * teardown used to end in process.exit(0). So a terminal that went away while
+ * nobody was watching — a closed window, an ssh drop, a stray read from a
+ * background process group — stopped the node, and it stayed stopped until
+ * someone re-ran `ainode` the next morning. Only `quit` is a person asking.
+ *
+ * Pure and exported so the rule is checkable without a TTY.
+ */
+export declare function leaveAction(reason: LeaveReason, ownsDaemon: boolean): LeaveAction;
 export declare function runDashboard(opts: {
     viewerMode: boolean;
     pid: number | null;
     startedAt: number | null;
     version: string;
+    /** The in-process daemon's graceful shutdown, when this process owns one.
+     *  Its presence is also how the screen knows quitting means stopping the
+     *  node rather than closing a window onto someone else's. */
+    stop?: () => Promise<void>;
 }): Promise<void>;
 /** `ainode harnesses` — straight to the harness screen. */
 export declare function runHarnessesTui(): Promise<void>;

package/dist/tui/run.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldRenderTui = shouldRenderTui;
+exports.leaveAction = leaveAction;
 exports.runDashboard = runDashboard;
 exports.runHarnessesTui = runHarnessesTui;
 const readline = __importStar(require("readline"));
@@ -62,6 +63,22 @@ function shouldRenderTui(env) {
 const TICK_MS = 250;
 /** Spinner cadence. Cheap now that frames are painted as a diff. */
 const SPIN_MS = 120;
+/**
+ * The rule that decides whether this node survives the night.
+ *
+ * `ainode` runs the daemon in the SAME process as the dashboard, and every
+ * teardown used to end in process.exit(0). So a terminal that went away while
+ * nobody was watching — a closed window, an ssh drop, a stray read from a
+ * background process group — stopped the node, and it stayed stopped until
+ * someone re-ran `ainode` the next morning. Only `quit` is a person asking.
+ *
+ * Pure and exported so the rule is checkable without a TTY.
+ */
+function leaveAction(reason, ownsDaemon) {
+    if (!ownsDaemon)
+        return 'exit';
+    return reason === 'quit' ? 'shutdown' : 'detach';
+}
 /**
  * Own the terminal on behalf of a screen stack.
  *
@@ -69,7 +86,13 @@ const SPIN_MS = 120;
  * screen can hand the TTY to a vendor CLI. It returns the root screen.
  */
 function createConsole(build, hooks = {}) {
-    const painter = (0, render_1.createPainter)(s => process.stdout.write(s));
+    // A terminal that has gone away makes every write fail with EIO/EPIPE. In
+    // daemon mode the node is running in this very process, so a dead screen
+    // must never be the thing that takes it down.
+    const painter = (0, render_1.createPainter)(s => { try {
+        process.stdout.write(s);
+    }
+    catch { /* screen gone */ } });
     let quitting = false;
     let inputAttached = false;
     // Building the root screen redraws, and that happens before run() has
@@ -82,7 +105,7 @@ function createConsole(build, hooks = {}) {
     // silent: its timers keep firing otherwise and repaint straight over the
     // child's output.
     let suspended = false;
-    const app = (0, app_1.createApp)({ id: 'boot', title: '+Ai Node', render: () => [] }, { onQuit: () => teardown(), onRedraw: () => draw() });
+    const app = (0, app_1.createApp)({ id: 'boot', title: '+Ai Node', render: () => [] }, { onQuit: () => teardown('quit'), onRedraw: () => draw() });
     function draw() {
         if (!started || quitting || suspended)
             return;
@@ -92,7 +115,7 @@ function createConsole(build, hooks = {}) {
         void app.handleKey(key);
     }
     function onStdinError() {
-        teardown();
+        teardown('stdin-error');
     }
     function attachInput() {
         if (inputAttached)
@@ -116,14 +139,24 @@ function createConsole(build, hooks = {}) {
             return;
         process.stdin.off('keypress', onKeypress);
         process.stdin.off('error', onStdinError);
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(false);
-        process.stdin.pause();
+        // Putting a terminal back that no longer exists throws — and this runs
+        // from the very signal handler that means it no longer exists. Unguarded,
+        // that throw skips the rest of teardown, so onLeave never gets to say the
+        // node is still up and the reason is lost.
+        try {
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+        }
+        catch { /* gone */ }
+        try {
+            process.stdin.pause();
+        }
+        catch { /* gone */ }
         inputAttached = false;
     }
     let pollTimer = null;
     let spinTimer = null;
-    function teardown() {
+    function teardown(reason) {
         if (quitting)
             return;
         quitting = true;
@@ -132,9 +165,14 @@ function createConsole(build, hooks = {}) {
         if (spinTimer)
             clearInterval(spinTimer);
         detachInput();
-        (0, render_1.altOff)();
-        hooks.onTeardown?.();
-        process.exit(0);
+        try {
+            (0, render_1.altOff)();
+        }
+        catch { /* the terminal is already gone */ }
+        if (hooks.onLeave)
+            hooks.onLeave(reason);
+        else
+            process.exit(0);
     }
     const suspend = async (fn) => {
         suspended = true;
@@ -157,12 +195,21 @@ function createConsole(build, hooks = {}) {
     // background process group earns SIGTTIN, and the default action is to STOP
     // the process — which is what "zsh: suspended (tty input)" is. Stopped mid-
     // draw it still holds the terminal in raw mode, so the session it was
-    // sharing degrades too. Stop reading and leave instead; the daemon is a
-    // separate process and keeps running either way.
-    process.on('SIGTTIN', teardown);
-    process.on('SIGTTOU', teardown);
+    // sharing degrades too. Stop reading and leave instead.
+    //
+    // Leaving is NOT exiting: under `ainode` the daemon IS this process, so what
+    // the screen does when it loses its terminal decides whether the node
+    // survives the night. onLeave settles that — see runDashboard.
+    process.on('SIGTTIN', () => teardown('SIGTTIN'));
+    process.on('SIGTTOU', () => teardown('SIGTTOU'));
     // The terminal went away without the read failing first.
-    process.on('SIGHUP', teardown);
+    process.on('SIGHUP', () => teardown('SIGHUP'));
+    // An async write to a dead terminal surfaces as an 'error' event, and an
+    // 'error' with no listener is a throw. Same reasoning as the write guard.
+    process.stdout.on('error', () => { });
+    // Same for stdin, which keeps its listener past detachInput's removal so a
+    // late EIO on a torn-down terminal has somewhere to land.
+    process.stdin.on('error', () => { });
     app.replace(build(app, suspend));
     return {
         host: app,
@@ -205,6 +252,9 @@ function createConsole(build, hooks = {}) {
         },
     };
 }
+/** How long a deliberate quit waits for the daemon to drain before it stops
+ *  being a courtesy and starts being a hung terminal. */
+const QUIT_DRAIN_CEILING_MS = 20_000;
 async function runDashboard(opts) {
     const pairing = (0, store_1.readPairing)();
     const data = (0, data_1.createDataLayer)({ token: pairing?.daemonToken ?? '' });
@@ -240,11 +290,38 @@ async function runDashboard(opts) {
             })),
         });
     }, {
-        onTeardown: () => {
+        // The screen and the daemon used to share one fate: every teardown ended
+        // in process.exit(0), so a terminal that went away overnight — SIGHUP from
+        // a closed window, an ssh drop, a stray background read — took the node
+        // down with it and left it dead until someone re-ran `ainode` in the
+        // morning. Losing a screen is not a reason to stop working.
+        onLeave: (reason) => {
+            const stop = opts.stop;
+            const action = leaveAction(reason, !opts.viewerMode && Boolean(stop));
+            if (action === 'detach') {
+                // The terminal is gone, the daemon is not. Keep capturing rather than
+                // restoring: the real console writes to an fd that no longer exists,
+                // whereas the capture keeps appending to the daemon log — which is now
+                // the only place anyone can watch this node from.
+                console.log(`[tui] terminal gone (${reason}) — dashboard closed; the node is still running (pid ${process.pid})`);
+                console.log(`[tui] follow it with: tail -f ${paths_1.RUNTIME_LOG_FILE}`);
+                return;
+            }
             logs.restore();
             if (logs.count()) {
                 console.log(`${logs.count()} daemon log lines this session — ${paths_1.RUNTIME_LOG_FILE}`);
             }
+            if (action === 'exit' || !stop) {
+                process.exit(0);
+                return;
+            }
+            // Asked for, so drain properly: in-flight turns get to post their final
+            // status and the server is told we are going, rather than discovering it
+            // 90s later through a missed heartbeat. The ceiling is there because a
+            // wedged drain must not become a terminal that never comes back.
+            console.log('stopping the node…');
+            setTimeout(() => process.exit(0), QUIT_DRAIN_CEILING_MS).unref?.();
+            void stop().finally(() => process.exit(0));
         },
     });
     // The daemon's own numbers don't come from an RPC.

package/dist/win.d.ts

@@ -34,6 +34,11 @@ export declare function resolveCliInvocation(bin: string, args: string[]): CliIn
  *  pnpm/yarn-classic write `"%~dp0\<rel>.js"` (batch parameter expansion —
  *  note: no trailing `%`). */
 declare function resolveNpmShimScript(shimPath: string): string | null;
+/** Parse a .cmd shim for a `%~dp0`-relative NATIVE executable, for packages
+ *  that ship one instead of a node script. Same two dialects and the same
+ *  on-disk check as resolveNpmShimScript; deliberately a separate function so
+ *  the npm path the auto-updater depends on is untouched by this. */
+declare function resolveShimExecutable(shimPath: string): string | null;
 /**
  * Kill an agent child process AND everything it spawned.
  *
@@ -99,5 +104,6 @@ export declare function linkDir(real: string, dest: string): void;
  *  worth exercising on any platform, not just on a Windows box. */
 export declare const __testables: {
     resolveNpmShimScript: typeof resolveNpmShimScript;
+    resolveShimExecutable: typeof resolveShimExecutable;
 };
 export {};

package/dist/win.js

@@ -203,11 +203,24 @@ function resolveCliInvocation(bin, args) {
     }
     if (/\.(cmd|bat)$/i.test(target)) {
         const script = resolveNpmShimScript(target);
-        if (!script) {
-            throw new Error(`cannot spawn npm shim safely: ${target} — could not resolve the node script it wraps. ` +
-                `Install the CLI's native Windows build (an .exe) or reinstall via npm.`);
-        }
-        return { file: process.execPath, args: [script, ...args] };
+        if (script)
+            return { file: process.execPath, args: [script, ...args] };
+        // Not every npm shim wraps a node script. A package may ship a native
+        // Windows binary and have its shim exec THAT:
+        //
+        //     "%dp0%\\node_modules\\@anthropic-ai\\claude-code\\bin\\claude.exe" %*
+        //
+        // which is what @anthropic-ai/claude-code does now. There is no .js to
+        // find, so this threw — and the capabilities probe swallows the throw and
+        // reports the harness `available: false`. On a machine where `claude
+        // --version` worked in every shell, claude was simply missing from the
+        // picker. The old message's advice ('install the native Windows build')
+        // was already satisfied: the .exe sits inside the package the shim names.
+        const exe = resolveShimExecutable(target);
+        if (exe)
+            return { file: exe, args };
+        throw new Error(`cannot spawn npm shim safely: ${target} — it wraps neither a node script ` +
+            `nor an executable this can find. Reinstall the CLI via npm.`);
     }
     return { file: target, args };
 }
@@ -278,6 +291,26 @@ function resolveNpmShimScript(shimPath) {
     }
     return null;
 }
+/** Parse a .cmd shim for a `%~dp0`-relative NATIVE executable, for packages
+ *  that ship one instead of a node script. Same two dialects and the same
+ *  on-disk check as resolveNpmShimScript; deliberately a separate function so
+ *  the npm path the auto-updater depends on is untouched by this. */
+function resolveShimExecutable(shimPath) {
+    let body;
+    try {
+        body = fs.readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const re = /%(?:~dp0|dp0%)[\\/]([^"\s]+\.exe)/gi;
+    for (const m of body.matchAll(re)) {
+        const exe = path.join(path.dirname(shimPath), ...m[1].split(/[\\/]+/));
+        if (fs.existsSync(exe))
+            return exe;
+    }
+    return null;
+}
 /** How long a POSIX agent gets to honour SIGINT before we stop asking. */
 const KILL_ESCALATE_MS = 3000;
 /** One `ps` snapshot as (pid, ppid) pairs. Empty on any failure — callers
@@ -466,4 +499,4 @@ function linkDir(real, dest) {
 }
 /** Exposed for tests only: the shim parsing is pure file-shape logic and is
  *  worth exercising on any platform, not just on a Windows box. */
-exports.__testables = { resolveNpmShimScript };
+exports.__testables = { resolveNpmShimScript, resolveShimExecutable };

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "@addai/node",
-  "version": "0.30.7",
-  "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
-  "license": "MIT",
-  "keywords": [
-    "addai",
-    "entity-studio",
-    "claude",
-    "codex",
-    "kimi",
-    "gemini",
-    "agent",
-    "daemon",
-    "supabase",
-    "mcp"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
-  },
-  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
-  "bugs": {
-    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
-  },
-  "type": "commonjs",
-  "main": "dist/index.js",
-  "bin": {
-    "ainode": "dist/cli.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist",
-    "scripts",
-    "README.md",
-    "assets"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
-    "start": "node dist/cli.js",
-    "dev": "tsc -p tsconfig.json && node dist/cli.js",
-    "test": "npm run build && node --test test/*.test.mjs",
-    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
-    "postinstall": "node scripts/fix-pty-helper.js",
-    "prepublishOnly": "npm run build"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@addai/node-flows": "^1.0.0",
-    "node-pty": "^1.1.0",
-    "ws": "^8.21.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.6.0"
-  }
-}
+{
+  "name": "@addai/node",
+  "version": "0.30.10",
+  "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
+  "license": "MIT",
+  "keywords": [
+    "addai",
+    "entity-studio",
+    "claude",
+    "codex",
+    "kimi",
+    "gemini",
+    "agent",
+    "daemon",
+    "supabase",
+    "mcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
+  },
+  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "ainode": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
+    "start": "node dist/cli.js",
+    "dev": "tsc -p tsconfig.json && node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "postinstall": "node scripts/fix-pty-helper.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@addai/node-flows": "^1.0.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.6.0"
+  }
+}