@addai/node 0.6.0 → 0.8.0

package/dist/command-runner.d.ts

@@ -1,6 +1,9 @@
 export type RestartHook = (opts: {
     commandId: string;
     version: string;
+    /** Bounce this daemon on the version it is already running: no npm
+     *  install, no version change. See runUpdateRuntime. */
+    restartOnly?: boolean;
 }) => Promise<void>;
 export declare function setRestartHook(fn: RestartHook): void;
 /** Called from index.ts when a heartbeat reports pending_commands > 0.

package/dist/command-runner.js

@@ -479,26 +479,45 @@ async function runLogout(cmd, spec) {
 /* ── update_runtime ──────────────────────────────────────────────────────
  * Roll THIS node to a version (default: npm latest) and come back up.
  *
+ * Two shapes share the command:
+ *
+ *   {}                       roll to npm latest
+ *   {"version": "0.6.0"}     roll to a pinned version
+ *   {"restart_only": true}   bounce the daemon on the version it is already
+ *                            running — no npm install, no version change
+ *
+ * restart_only exists because the reasons to bounce a node are mostly not
+ * version reasons: a credential edit the running daemon has cached, a wedged
+ * harness, a machine that has been up for a fortnight. Doing that through a
+ * version roll meant an unwanted upgrade every time, and could not be done at
+ * all on a node running from a source checkout — where a restart is exactly
+ * the safe half of the operation.
+ *
+ * An older daemon that has never heard of restart_only still does the right
+ * thing, because the caller also pins `version` to the version it can see the
+ * node running: the old code installs the version already installed and
+ * restarts. Same destination, one wasted npm call.
+ *
  * The command is deliberately left `running` here: this process is about to
  * stop existing, so it cannot honestly report the outcome. index.ts's boot
  * path completes it from the handoff file once the replacement daemon is
  * actually up, with whatever version it actually came up as. */
 async function runUpdateRuntime(cmd) {
-    const target = (cmd.input?.version ?? '').trim() || 'latest';
     if (!restartHook) {
         await update(cmd.id, 'failed', {}, 'this daemon is too old to restart itself');
         return;
     }
     const mode = (0, self_update_1.detectLaunchMode)(process.argv[1] ?? '');
-    if (mode === 'source' && target !== 'latest') {
-        // A git checkout's version comes from the working tree, not npm — we'd
-        // restart and report the same old version, looking like a silent no-op.
-        await update(cmd.id, 'failed', { mode }, 'this node runs from a source checkout — pull and rebuild it there; a remote version bump cannot apply');
+    const { target, restartOnly, refusal } = (0, self_update_1.planRoll)(cmd.input, mode, VERSION);
+    if (refusal) {
+        await update(cmd.id, 'failed', { mode }, refusal);
         return;
     }
-    await update(cmd.id, 'running', { step: 'draining', mode, target_version: target, from_version: VERSION });
+    await update(cmd.id, 'running', {
+        step: 'draining', mode, target_version: target, from_version: VERSION, restart_only: restartOnly,
+    });
     try {
-        await restartHook({ commandId: cmd.id, version: target });
+        await restartHook({ commandId: cmd.id, version: target, restartOnly });
     }
     catch (err) {
         // The hook owns the point of no return (it writes the handoff only once

package/dist/index.js

@@ -248,11 +248,17 @@ async function start() {
     // daemon for one node — the failure the lockfile-identity fix was about. So
     // when launchd is holding us up, the roll simply STANDS DOWN and lets
     // KeepAlive do the starting.
-    (0, command_runner_1.setRestartHook)(async ({ commandId, version }) => {
+    //
+    // A restart-only bounce takes the same path minus the install: `version` is
+    // already this process's version, so the respawn plan pins the replacement
+    // to the same bits (which matters for npx, whose cache dir is per-version)
+    // and npm is never called — nothing to fetch, and nothing that can fail
+    // offline.
+    (0, command_runner_1.setRestartHook)(async ({ commandId, version, restartOnly }) => {
         const mode = (0, self_update_1.detectLaunchMode)(process.argv[1] ?? '');
         const plan = (0, self_update_1.planRespawn)(mode, process.argv[1] ?? '', version, process.execPath, process.argv.slice(2));
         const supervised = (0, autostart_1.isSupervised)();
-        if (plan.installFirst) {
+        if (plan.installFirst && !restartOnly) {
             const err = await (0, self_update_1.installGlobal)(version);
             if (err)
                 throw new Error(err);
@@ -276,14 +282,16 @@ async function start() {
                 at: new Date().toISOString(),
                 drained: lastDrain.drained,
                 timed_out: lastDrain.timedOut,
+                restart_only: restartOnly === true,
             });
         }
         catch (err) {
             console.error('[restart] handoff write failed — the roll still happened, it just cannot self-report:', err.message);
         }
+        const what = restartOnly ? `${mode} → restart on ${version}` : `${mode} → ${version}`;
         console.log(supervised
-            ? `[restart] standing down for launchd to restart us (${mode} → ${version}); exiting`
-            : `[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
+            ? `[restart] standing down for launchd to restart us (${what}); exiting`
+            : `[restart] handed over to ${plan.file} (${what}); exiting`);
         setTimeout(() => process.exit(0), 250).unref?.();
     });
     process.once('SIGINT', () => { stop().finally(() => process.exit(0)); });
@@ -395,6 +403,7 @@ async function finalizeRestartHandoff() {
                 version: VERSION,
                 mode: h.mode,
                 restarted: true,
+                restart_only: h.restart_only === true,
                 version_changed: changed,
                 drained: h.drained ?? 0,
                 // >0 means the drain ceiling expired with work still running — the

package/dist/self-update.d.ts

@@ -45,6 +45,27 @@ export declare function planRespawn(mode: LaunchMode, entryPath: string, targetV
  *  slice(2)) — carried across the restart so a node launched as
  *  `… cli.js run --foo` doesn't silently come back up without them. */
 userArgs?: string[]): RespawnPlan;
+export interface RollPlan {
+    /** Version the replacement must come up as. */
+    target: string;
+    /** A bounce on the running version: nothing is installed, nothing moves. */
+    restartOnly: boolean;
+    /** Non-null = refuse before anything drains, with this explanation. */
+    refusal: string | null;
+}
+/**
+ * Read an `update_runtime` command's input into what this node should do.
+ *
+ * Pure so the one rule that is easy to get wrong stays testable: a source
+ * checkout may not be version-bumped remotely (its version comes from the
+ * working tree, so it would restart and report the same version — a silent
+ * no-op dressed up as success) but it MAY be restarted, which is the half of
+ * the operation that works there.
+ */
+export declare function planRoll(input: {
+    version?: string;
+    restart_only?: boolean;
+} | null, mode: LaunchMode, currentVersion: string): RollPlan;
 export interface RestartHandoff {
     command_id: string;
     from_version: string;
@@ -56,6 +77,10 @@ export interface RestartHandoff {
      *  work unfinished rather than claiming a clean restart either way. */
     drained?: number;
     timed_out?: number;
+    /** True when this was a bounce on the running version rather than a roll,
+     *  so the completed command says which one actually happened instead of
+     *  leaving it to be inferred from two versions that match. */
+    restart_only?: boolean;
 }
 export declare function handoffPath(runtimeDir: string): string;
 export declare function writeHandoff(runtimeDir: string, h: RestartHandoff): void;

package/dist/self-update.js

@@ -55,6 +55,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_NAME = void 0;
 exports.detectLaunchMode = detectLaunchMode;
 exports.planRespawn = planRespawn;
+exports.planRoll = planRoll;
 exports.handoffPath = handoffPath;
 exports.writeHandoff = writeHandoff;
 exports.takeHandoff = takeHandoff;
@@ -112,6 +113,26 @@ userArgs = []) {
         canChangeVersion: mode === 'global',
     };
 }
+/**
+ * Read an `update_runtime` command's input into what this node should do.
+ *
+ * Pure so the one rule that is easy to get wrong stays testable: a source
+ * checkout may not be version-bumped remotely (its version comes from the
+ * working tree, so it would restart and report the same version — a silent
+ * no-op dressed up as success) but it MAY be restarted, which is the half of
+ * the operation that works there.
+ */
+function planRoll(input, mode, currentVersion) {
+    const restartOnly = input?.restart_only === true;
+    // A restart targets the version already running, which keeps the boot-side
+    // "did we come up as what was asked for?" check meaningful instead of
+    // special-cased — and pins npx, whose cache dir is per-version.
+    const target = restartOnly ? currentVersion : (input?.version ?? '').trim() || 'latest';
+    const refusal = !restartOnly && mode === 'source' && target !== 'latest'
+        ? 'this node runs from a source checkout — pull and rebuild it there; a remote version bump cannot apply'
+        : null;
+    return { target, restartOnly, refusal };
+}
 function handoffPath(runtimeDir) {
     return path.join(runtimeDir, 'restart.json');
 }

package/dist/tui/dashboard.d.ts

@@ -7,7 +7,15 @@ export interface DashboardState {
     /** Recent requests, newest first — the NOW band reads the live ones off
      *  the top and the idle line reads the most recent finish. */
     recent: RequestRow[];
+    /** Cursor position in the menu. */
     sel: number;
+    /** Id of the selected live run, or null when the cursor is in the menu.
+     *  Pinned by id rather than by index because the band reorders under the
+     *  cursor: a new run is prepended the moment it starts, and an index would
+     *  quietly leave you pointing at a different run than the one you chose. */
+    nowSelId: string | null;
+    /** Live rows the last render could fit — what bounds the cursor. */
+    nowRows: number;
     spin: number;
     pid: number | null;
     startedAt: number | null;
@@ -35,6 +43,19 @@ export declare const MENU: Array<{
 /** Live rows the NOW band shows before it starts counting the rest. */
 export declare const MAX_NOW_ROWS = 6;
 export declare function liveRequests(rows: RequestRow[]): RequestRow[];
+/** The live rows the band actually draws — the only ones the cursor can reach.
+ *  Everything past the cap lives on the Activity screen. A short terminal
+ *  draws fewer than MAX_NOW_ROWS, and the cursor must not run off into rows
+ *  that are not on screen, so the last render's row count is what bounds it. */
+export declare function selectableNow(st: DashboardState): RequestRow[];
+/**
+ * Where the cursor is in the NOW band, or -1 for "in the menu".
+ *
+ * Derived from the pinned id on every read, so a run that finishes while
+ * selected drops the cursor back to the menu rather than silently moving it
+ * onto whichever run took that row.
+ */
+export declare function nowIndex(st: DashboardState): number;
 /**
  * The node's own state, as a label.
  *

package/dist/tui/dashboard.js

@@ -8,6 +8,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_NOW_ROWS = exports.MENU = void 0;
 exports.liveRequests = liveRequests;
+exports.selectableNow = selectableNow;
+exports.nowIndex = nowIndex;
 exports.stateLabel = stateLabel;
 exports.autostartLine = autostartLine;
 exports.fmtCount = fmtCount;
@@ -29,6 +31,26 @@ exports.MAX_NOW_ROWS = 6;
 function liveRequests(rows) {
     return rows.filter(r => request_row_1.ACTIVE.has(r.status));
 }
+/** The live rows the band actually draws — the only ones the cursor can reach.
+ *  Everything past the cap lives on the Activity screen. A short terminal
+ *  draws fewer than MAX_NOW_ROWS, and the cursor must not run off into rows
+ *  that are not on screen, so the last render's row count is what bounds it. */
+function selectableNow(st) {
+    const cap = Math.max(1, Math.min(exports.MAX_NOW_ROWS, st.nowRows || exports.MAX_NOW_ROWS));
+    return liveRequests(st.recent).slice(0, cap);
+}
+/**
+ * Where the cursor is in the NOW band, or -1 for "in the menu".
+ *
+ * Derived from the pinned id on every read, so a run that finishes while
+ * selected drops the cursor back to the menu rather than silently moving it
+ * onto whichever run took that row.
+ */
+function nowIndex(st) {
+    if (!st.nowSelId)
+        return -1;
+    return selectableNow(st).findIndex(r => r.id === st.nowSelId);
+}
 /**
  * The node's own state, as a label.
  *
@@ -128,7 +150,10 @@ function lastFinished(rows) {
 }
 function nowLines(st, width, rows) {
     const live = liveRequests(st.recent);
-    const out = [`  ${(0, render_1.bold)('Now')}`];
+    const heading = live.length
+        ? `  ${(0, render_1.bold)('Now')}  ${(0, render_1.dim)('↑ to select · ⏎ to watch')}`
+        : `  ${(0, render_1.bold)('Now')}`;
+    const out = [heading];
     if (live.length === 0) {
         const last = lastFinished(st.recent);
         out.push(last
@@ -138,7 +163,9 @@ function nowLines(st, width, rows) {
     }
     out.push((0, request_row_1.requestHeader)(width));
     const shown = live.slice(0, Math.max(1, rows));
-    shown.forEach(r => out.push((0, request_row_1.requestLine)(r, st.now, false, width, st.spin)));
+    st.nowRows = shown.length;
+    const cursor = nowIndex(st);
+    shown.forEach((r, i) => out.push((0, request_row_1.requestLine)(r, st.now, i === cursor, width, st.spin)));
     if (live.length > shown.length) {
         out.push((0, render_1.dim)(`     +${live.length - shown.length} more running`));
     }
@@ -153,8 +180,11 @@ function renderDashboard(st, width, height) {
     // The shortcut letters line up in a column of their own, so the eye can
     // find them without reading the hints.
     const hintWidth = Math.max(...exports.MENU.map(m => m.hint.length)) + 2;
+    // One cursor on screen at a time: while it is up in the NOW band the menu
+    // shows no selection, or the eye reads two.
+    const inNow = nowIndex(st) >= 0;
     const menu = exports.MENU.map((m, i) => {
-        const selected = i === st.sel;
+        const selected = !inNow && i === st.sel;
         const label = selected ? (0, render_1.bold)(m.label.padEnd(11)) : m.label.padEnd(11);
         const cursor = selected ? (0, render_1.cyan)('❯') : ' ';
         const badge = m.key === 'logs' && st.logCount ? `${st.logCount} lines` : '';
@@ -162,7 +192,7 @@ function renderDashboard(st, width, height) {
     });
     const foot = (0, app_1.footerHint)([
         { keys: '↑↓', label: 'move' },
-        { keys: '⏎', label: 'open' },
+        { keys: '⏎', label: inNow ? 'watch this run' : 'open' },
         { keys: 's', label: st.autostart?.enabled ? 'startup off' : 'startup on' },
         { keys: 'r', label: 'refresh' },
         { keys: '?', label: 'keys' },
@@ -202,6 +232,11 @@ function createDashboardScreen(deps) {
         if (recent.length)
             st.recent = recent;
         st.offline = deps.data.offline();
+        // A selected run that has finished is no longer in the band. nowIndex
+        // already reads that as "cursor is in the menu"; drop the id too so the
+        // state doesn't keep pointing at a run nobody can see.
+        if (st.nowSelId && !selectableNow(st).some(r => r.id === st.nowSelId))
+            st.nowSelId = null;
         // Reads a file (and, on Windows, a cached schtasks query) — cheap enough
         // to ride the same poll, so the header can't disagree with reality after
         // someone changes it from Studio or the CLI.
@@ -242,6 +277,43 @@ function createDashboardScreen(deps) {
         // line — a note that never clears becomes furniture.
         setTimeout(() => { st.autostartNote = null; deps.host.redraw(); }, 8000).unref?.();
     };
+    /**
+     * One cursor over two stacked lists: the NOW band sits above the menu, so
+     * ↑ off the top of the menu lands on the LAST live row (the one nearest the
+     * menu) and ↓ off the bottom of the band returns to the first menu item.
+     * Reading the screen top to bottom, the cursor moves the way the eye does.
+     */
+    const moveUp = () => {
+        const live = selectableNow(st);
+        const i = nowIndex(st);
+        if (i < 0) {
+            // In the menu. Step up inside it first; only leave from the top row.
+            if (st.sel > 0) {
+                st.sel -= 1;
+                return;
+            }
+            if (live.length)
+                st.nowSelId = live[live.length - 1].id;
+            return;
+        }
+        if (i > 0)
+            st.nowSelId = live[i - 1].id;
+    };
+    const moveDown = () => {
+        const live = selectableNow(st);
+        const i = nowIndex(st);
+        if (i < 0) {
+            st.sel = Math.min(exports.MENU.length - 1, st.sel + 1);
+            return;
+        }
+        // Past the last live row is the menu, entered at its first item.
+        if (i >= live.length - 1) {
+            st.nowSelId = null;
+            st.sel = 0;
+            return;
+        }
+        st.nowSelId = live[i + 1].id;
+    };
     return {
         id: 'dashboard',
         title: '+Ai Node',
@@ -258,8 +330,8 @@ function createDashboardScreen(deps) {
             return true;
         },
         keys: () => [
-            { keys: '↑↓ / jk', label: 'move between destinations' },
-            { keys: '⏎', label: 'open the selected destination' },
+            { keys: '↑↓ / jk', label: 'move — up from the menu into the live runs' },
+            { keys: '⏎', label: 'open the destination, or watch the selected run' },
             { keys: 'a', label: 'activity — full request history' },
             { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
             { keys: 'l', label: 'logs — daemon output' },
@@ -268,12 +340,12 @@ function createDashboardScreen(deps) {
         ],
         async onKey(key) {
             if (key.name === 'up' || key.name === 'k') {
-                st.sel = Math.max(0, st.sel - 1);
+                moveUp();
                 deps.host.redraw();
                 return;
             }
             if (key.name === 'down' || key.name === 'j') {
-                st.sel = Math.min(exports.MENU.length - 1, st.sel + 1);
+                moveDown();
                 deps.host.redraw();
                 return;
             }
@@ -298,6 +370,12 @@ function createDashboardScreen(deps) {
                 return;
             }
             if (key.name === 'return') {
+                // A selected run wins over the menu: the cursor is visibly on it.
+                const live = selectableNow(st)[nowIndex(st)];
+                if (live) {
+                    deps.openTranscript(live);
+                    return;
+                }
                 const target = exports.MENU[st.sel]?.key;
                 if (target === 'harnesses')
                     deps.openHarnesses();

package/dist/tui/run.js

@@ -192,7 +192,7 @@ async function runDashboard(opts) {
     // the daemon log file, so nothing is lost by watching.
     const logs = (0, console_capture_1.captureConsole)({ logFile: paths_1.RUNTIME_LOG_FILE });
     const state = {
-        self: null, stats: null, recent: [], sel: 0, spin: 0,
+        self: null, stats: null, recent: [], sel: 0, nowSelId: null, nowRows: 0, spin: 0,
         pid: opts.pid, startedAt: opts.startedAt,
         inflight: 0, paired: (0, store_1.isPaired)(), viewerMode: opts.viewerMode,
         offline: false, now: Date.now(), version: opts.version,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "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": [