@addai/node 0.5.1 → 0.7.0

package/dist/cli.js

@@ -4,6 +4,7 @@
 //
 //   ainode                run this node: daemon + live dashboard
 //   ainode harnesses      interactive harness manager (install / login)
+//   ainode startup …      start this node when the machine starts
 //   ainode unpair --yes   disconnect from +Ai, cancel in-flight work
 //   ainode version        print version
 //
@@ -15,12 +16,46 @@
 //
 // Unpair reaches Supabase via the daemon token in ~/.ainode/state.json and
 // does not require the daemon to be running.
+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 });
 const lockfile_1 = require("./lockfile");
 const index_1 = require("./index");
 const store_1 = require("./store");
 const supabase_client_1 = require("./supabase-client");
 const run_1 = require("./tui/run");
+const autostart = __importStar(require("./autostart"));
 const args = process.argv.slice(2);
 function token() {
     const p = (0, store_1.readPairing)();
@@ -53,9 +88,53 @@ async function cmdUnpair() {
     (0, store_1.clearPairing)();
     console.log('Unpaired. Run `ainode` to pair again.');
 }
+function cmdStartup() {
+    const sub = args[1] ?? 'status';
+    if (sub === 'status') {
+        console.log(autostart.describeStatus(autostart.status()));
+        return;
+    }
+    if (sub === 'enable') {
+        const r = autostart.enable({ force: args.includes('--force') });
+        if (!r.ok) {
+            console.error(r.error ?? 'could not enable startup');
+            process.exit(1);
+        }
+        for (const w of r.warnings)
+            console.log(`  note: ${w}`);
+        console.log('This node now starts when you log in.');
+        if (r.path)
+            console.log(`  definition: ${r.path}`);
+        return;
+    }
+    if (sub === 'disable') {
+        const before = autostart.status();
+        const r = autostart.disable();
+        if (!r.ok) {
+            console.error(r.error ?? 'could not disable startup');
+            process.exit(1);
+        }
+        console.log('This node no longer starts at login.');
+        // launchd's bootout stops the job it was supervising, so the node just
+        // went offline. Saying so beats letting the user discover it later.
+        if (before.supervisor === 'launchd' && before.enabled) {
+            console.log('  the supervised node was stopped — run `ainode` to bring it back');
+        }
+        return;
+    }
+    console.error(`unknown startup command: ${sub}`);
+    console.error('try: ainode startup enable | disable | status');
+    process.exit(2);
+}
 async function main() {
     const cmd = args[0];
     if (!cmd || cmd === 'run' || cmd === 'start' || cmd === '--run') {
+        // `--ensure` means "make sure a node is running here, then get out of the
+        // way". Windows' startup task repeats every five minutes to catch a
+        // crashed daemon; without this it would stack a second one every time.
+        if (args.includes('--ensure') && (0, lockfile_1.lockfileAlive)((0, lockfile_1.readLockfile)())) {
+            return;
+        }
         const tui = (0, run_1.shouldRenderTui)({
             isTTY: Boolean(process.stdout.isTTY),
             stdinTTY: Boolean(process.stdin.isTTY),
@@ -99,6 +178,9 @@ async function main() {
         case 'harnesses':
             await (0, run_1.runHarnessesTui)();
             return;
+        case 'startup':
+            cmdStartup();
+            return;
         case 'unpair':
             await cmdUnpair();
             return;
@@ -115,11 +197,15 @@ async function main() {
 usage:
   ainode                    run this +Ai Node — daemon + live dashboard
   ainode harnesses          install / log in agent harnesses (interactive)
+  ainode startup enable     start this node whenever you log in
+  ainode startup disable    stop starting at login
+  ainode startup status     where the startup entry is and what it runs
   ainode unpair --yes       disconnect from +Ai
   ainode version            print version
 
 Piped or headless output falls back to plain log lines. Set AINODE_NO_TUI=1
-to force that on a terminal.
+to force that on a terminal. \`ainode run --ensure\` starts a node only if one
+isn't already running — what the Windows startup task uses.
 
 Pair the node by running it with no args and following the prompt
 to vault.add.ai/entity/connect/<CODE>.

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

@@ -56,6 +56,7 @@ const heartbeat_1 = require("./heartbeat");
 const win_1 = require("./win");
 const harness_registry_1 = require("./harness-registry");
 const self_update_1 = require("./self-update");
+const autostart_1 = require("./autostart");
 const paths_1 = require("./paths");
 const pty_helper_1 = require("./pty-helper");
 const COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
@@ -478,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
@@ -505,6 +525,38 @@ async function runUpdateRuntime(cmd) {
         await update(cmd.id, 'failed', { mode }, `restart failed: ${err.message}`);
     }
 }
+/* ── set_autostart ───────────────────────────────────────────────────────
+ * Arm (or disarm) "start when the machine starts" on a node you are not
+ * sitting at. Unlike a roll, this one CAN honestly report its own outcome:
+ * nothing restarts, so the process that did the work is still here to say
+ * what happened — and it reports the state it actually READ BACK afterwards,
+ * not the state it intended.
+ *
+ * Enabling under launchd hands the node over: a daemon started by hand is
+ * asked to drain and stop so launchd can own it. That means this command can
+ * legitimately stop and restart the daemon underneath the caller. It does not
+ * restart THIS process, so the reporting contract still holds. */
+async function runSetAutostart(cmd) {
+    const want = cmd.input?.enabled !== false;
+    await update(cmd.id, 'running', { step: want ? 'enabling' : 'disabling' });
+    if (want) {
+        const r = (0, autostart_1.enable)({ force: cmd.input?.force === true });
+        const state = (0, autostart_1.status)();
+        if (!r.ok) {
+            await update(cmd.id, 'failed', { autostart: state }, r.error ?? 'could not enable startup');
+            return;
+        }
+        await update(cmd.id, 'completed', { autostart: state, path: r.path, warnings: r.warnings });
+        return;
+    }
+    const r = (0, autostart_1.disable)();
+    const state = (0, autostart_1.status)();
+    if (!r.ok) {
+        await update(cmd.id, 'failed', { autostart: state }, r.error ?? 'could not disable startup');
+        return;
+    }
+    await update(cmd.id, 'completed', { autostart: state });
+}
 /* ── dispatcher ──────────────────────────────────────────────────────── */
 async function execute(cmd) {
     // Not a harness command — dispatch before the harness lookup, which would
@@ -513,6 +565,10 @@ async function execute(cmd) {
         await runUpdateRuntime(cmd);
         return;
     }
+    if (cmd.kind === 'set_autostart') {
+        await runSetAutostart(cmd);
+        return;
+    }
     const spec = (0, harness_registry_1.harness)(cmd.harness ?? '');
     if (!spec) {
         await update(cmd.id, 'failed', {}, `unknown harness: ${cmd.harness}`);

package/dist/index.js

@@ -49,6 +49,7 @@ const pairing_1 = require("./pairing");
 const heartbeat_1 = require("./heartbeat");
 const command_runner_1 = require("./command-runner");
 const self_update_1 = require("./self-update");
+const autostart_1 = require("./autostart");
 const sleep_detector_1 = require("./sleep-detector");
 const claude_config_1 = require("./claude-config");
 const request_pump_1 = require("./request-pump");
@@ -236,14 +237,28 @@ async function start() {
         (0, lockfile_1.releaseLockfile)();
     };
     // Remote roll: drain like a clean shutdown, install the target version if
-    // this launch mode can, then hand over to a detached replacement. The
-    // handoff file is written only AFTER the replacement is spawned, so a
-    // failure anywhere before that leaves this daemon running and the command
-    // is failed by the caller instead of silently taking the node down.
-    (0, command_runner_1.setRestartHook)(async ({ commandId, version }) => {
+    // this launch mode can, then hand over to a replacement. The handoff file is
+    // written only AFTER the replacement is arranged, so a failure anywhere
+    // before that leaves this daemon running and the command is failed by the
+    // caller instead of silently taking the node down.
+    //
+    // WHO starts the replacement depends on whether anything is supervising us.
+    // Historically nothing was, so this spawned a detached child of its own. On
+    // a node with `ainode startup enable` under launchd that would be a second
+    // 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.
+    //
+    // 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));
-        if (plan.installFirst) {
+        const supervised = (0, autostart_1.isSupervised)();
+        if (plan.installFirst && !restartOnly) {
             const err = await (0, self_update_1.installGlobal)(version);
             if (err)
                 throw new Error(err);
@@ -251,11 +266,13 @@ async function start() {
         // Drain generously — a restart is elective, so it should never guillotine
         // a live entity turn the way a 15s SIGTERM drain would.
         await stop(RESTART_DRAIN_MS);
-        // Point of no return. Past this line a replacement daemon exists, so we
-        // MUST exit — two live daemons on one node is worse than a command left
-        // unreported. Hence the handoff write (which only affects reporting) can
-        // never abort the exit.
-        (0, self_update_1.spawnReplacement)(plan, path.join(paths_1.RUNTIME_HOME, 'daemon.log'), process.cwd());
+        // Point of no return. Past this line a replacement daemon either exists or
+        // is guaranteed by the supervisor, so we MUST exit — two live daemons on
+        // one node is worse than a command left unreported. Hence the handoff
+        // write (which only affects reporting) can never abort the exit.
+        if (!supervised) {
+            (0, self_update_1.spawnReplacement)(plan, path.join(paths_1.RUNTIME_HOME, 'daemon.log'), process.cwd());
+        }
         try {
             (0, self_update_1.writeHandoff)(paths_1.RUNTIME_HOME, {
                 command_id: commandId,
@@ -265,12 +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);
         }
-        console.log(`[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
+        const what = restartOnly ? `${mode} → restart on ${version}` : `${mode} → ${version}`;
+        console.log(supervised
+            ? `[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)); });
@@ -382,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

@@ -1,5 +1,6 @@
 import { type AppHost, type Screen } from './app';
 import type { DataLayer, NodeSelf, NodeStats, RequestRow } from './data';
+import { type AutostartState } from '../autostart';
 export interface DashboardState {
     self: NodeSelf | null;
     stats: NodeStats | null;
@@ -18,6 +19,11 @@ export interface DashboardState {
     version: string;
     /** How many daemon log lines have been captured this session. */
     logCount: number;
+    /** Does this node come back after a reboot? Null until first read. */
+    autostart: AutostartState | null;
+    /** Set while a toggle is in flight, and to whatever it had to say after —
+     *  enabling can stop and restart the daemon, which deserves a sentence. */
+    autostartNote: string | null;
 }
 /** The landing screen's menu. */
 export declare const MENU: Array<{
@@ -38,6 +44,14 @@ export declare function liveRequests(rows: RequestRow[]): RequestRow[];
  * second of every session claimed the node was in an unknown state.
  */
 export declare function stateLabel(st: DashboardState): string;
+/**
+ * Whether the box comes back on its own.
+ *
+ * On the header, not buried in a menu: "will this node survive a reboot" is a
+ * property of the node in the same way "is it online" is, and the answer was
+ * previously knowable only by reading the docs and looking for a plist.
+ */
+export declare function autostartLine(st: DashboardState): string;
 /** 1204 reads as a year; 1,204 reads as a count. */
 export declare function fmtCount(n: number | null | undefined): string;
 export declare function nowLines(st: DashboardState, width: number, rows: number): string[];

package/dist/tui/dashboard.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_NOW_ROWS = exports.MENU = void 0;
 exports.liveRequests = liveRequests;
 exports.stateLabel = stateLabel;
+exports.autostartLine = autostartLine;
 exports.fmtCount = fmtCount;
 exports.nowLines = nowLines;
 exports.renderDashboard = renderDashboard;
@@ -16,6 +17,7 @@ exports.createDashboardScreen = createDashboardScreen;
 const render_1 = require("./render");
 const request_row_1 = require("./request-row");
 const app_1 = require("./app");
+const autostart_1 = require("../autostart");
 /** The landing screen's menu. */
 exports.MENU = [
     { key: 'activity', label: 'Activity', hint: 'Every request this node has handled', shortcut: 'a' },
@@ -59,7 +61,27 @@ function headerLines(st) {
         ? `${(0, render_1.cyan)('⏺')} Viewer  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)('· another process owns this node')}`
         : `${(0, render_1.green)('⏺')} Running  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)(`up ${up}`)}  ${(0, render_1.dim)(`${st.inflight} in flight`)}`;
     const chip = st.offline ? `  ${(0, render_1.yellow)('⚠ Offline · retrying')}` : '';
-    return [first, daemon + chip];
+    return [first, daemon + chip, autostartLine(st)];
+}
+/**
+ * Whether the box comes back on its own.
+ *
+ * On the header, not buried in a menu: "will this node survive a reboot" is a
+ * property of the node in the same way "is it online" is, and the answer was
+ * previously knowable only by reading the docs and looking for a plist.
+ */
+function autostartLine(st) {
+    if (st.autostartNote)
+        return (0, render_1.dim)(`  ${st.autostartNote}`);
+    const a = st.autostart;
+    if (!a)
+        return (0, render_1.dim)('  Starts at login  …');
+    if (!a.supported)
+        return (0, render_1.dim)(`  Starts at login  ${(0, render_1.grey)('not supported on this platform')}`);
+    const issue = a.issues?.length ? `  ${(0, render_1.yellow)(`⚠ ${a.issues[0]}`)}` : '';
+    return a.enabled
+        ? `  ${(0, render_1.dim)('Starts at login')}  ${(0, render_1.green)('yes')}${(0, render_1.dim)(a.supervisor ? ` · ${a.supervisor}` : '')}${issue}`
+        : `  ${(0, render_1.dim)('Starts at login')}  ${(0, render_1.yellow)('no')}  ${(0, render_1.dim)('press s to turn it on')}`;
 }
 /** 1204 reads as a year; 1,204 reads as a count. */
 function fmtCount(n) {
@@ -141,6 +163,7 @@ function renderDashboard(st, width, height) {
     const foot = (0, app_1.footerHint)([
         { keys: '↑↓', label: 'move' },
         { keys: '⏎', label: 'open' },
+        { keys: 's', label: st.autostart?.enabled ? 'startup off' : 'startup on' },
         { keys: 'r', label: 'refresh' },
         { keys: '?', label: 'keys' },
         { keys: 'q', label: 'quit' },
@@ -179,8 +202,46 @@ function createDashboardScreen(deps) {
         if (recent.length)
             st.recent = recent;
         st.offline = deps.data.offline();
+        // 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.
+        st.autostart = (0, autostart_1.status)();
         deps.host.redraw();
     };
+    /**
+     * Turn "start at login" on or off from here.
+     *
+     * Enabling can stop a daemon — a node started by hand has to stand down so
+     * launchd can own it — so the outcome is reported in the header rather than
+     * left for the user to infer. The work is deferred a tick so the "Working…"
+     * line is actually on screen before the blocking call begins.
+     */
+    const toggleAutostart = async () => {
+        const on = st.autostart?.enabled === true;
+        if (st.autostart && !st.autostart.supported) {
+            st.autostartNote = `Starts at login isn't supported on ${process.platform}`;
+            deps.host.redraw();
+            return;
+        }
+        st.autostartNote = on ? 'Turning off start at login…' : 'Turning on start at login…';
+        deps.host.redraw();
+        await new Promise(r => setTimeout(r, 0));
+        if (on) {
+            const r = (0, autostart_1.disable)();
+            st.autostartNote = r.ok ? 'This node no longer starts at login' : `Could not turn it off: ${r.error}`;
+        }
+        else {
+            const r = (0, autostart_1.enable)();
+            st.autostartNote = r.ok
+                ? ['This node now starts when you log in', ...r.warnings].join(' — ')
+                : `Could not turn it on: ${r.error}`;
+        }
+        st.autostart = (0, autostart_1.status)();
+        deps.host.redraw();
+        // Let the sentence sit long enough to read, then fall back to the state
+        // line — a note that never clears becomes furniture.
+        setTimeout(() => { st.autostartNote = null; deps.host.redraw(); }, 8000).unref?.();
+    };
     return {
         id: 'dashboard',
         title: '+Ai Node',
@@ -202,6 +263,7 @@ function createDashboardScreen(deps) {
             { keys: 'a', label: 'activity — full request history' },
             { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
             { keys: 'l', label: 'logs — daemon output' },
+            { keys: 's', label: 'start this node at login (on / off)' },
             { keys: 'r', label: 'refresh now' },
         ],
         async onKey(key) {
@@ -227,6 +289,10 @@ function createDashboardScreen(deps) {
                 deps.openLogs();
                 return;
             }
+            if (key.name === 's') {
+                await toggleAutostart();
+                return;
+            }
             if (key.name === 'r') {
                 await refresh();
                 return;

package/dist/tui/data.d.ts

@@ -2,6 +2,15 @@ export interface RequestRow {
     id: string;
     entity_name: string | null;
     agent: string;
+    /** Where the row ENDED up. `agent` is what this node actually spawned — the
+     *  ladder mutates the request's agent column in place, so the two differ on
+     *  a run that hopped. */
+    current_agent?: string | null;
+    ladder_hops?: number | null;
+    /** This node ran it but no longer owns it — it was handed to another
+     *  machine, and that machine finished it. */
+    handed_off?: boolean | null;
+    to_runtime_name?: string | null;
     mode: string;
     model: string | null;
     issued_via: string | null;

package/dist/tui/request-row.d.ts

@@ -19,7 +19,7 @@ export declare function shortModel(model: string | null | undefined): string;
 export declare function statusLabel(status: string): string;
 export declare function statusColour(status: string): (s: string) => string;
 /** Live rows get a moving spinner; settled rows get a dot. */
-export declare function marker(status: string, spin: number): string;
+export declare function marker(status: string, spin: number, handedOff?: boolean): string;
 export declare function durationOf(r: RequestRow, now: number): number | null;
 /**
  * Column widths for the request table.

package/dist/tui/request-row.js

@@ -78,7 +78,12 @@ function statusColour(status) {
     return render_1.red;
 }
 /** Live rows get a moving spinner; settled rows get a dot. */
-function marker(status, spin) {
+function marker(status, spin, handedOff = false) {
+    // A run this node handed on didn't finish here, whatever the row's terminal
+    // status says. Marking it as an outcome would credit this machine with
+    // another machine's work.
+    if (handedOff)
+        return (0, render_1.grey)('↗');
     const colour = statusColour(status);
     return colour(exports.ACTIVE.has(status) ? render_1.SPIN[spin % render_1.SPIN.length] : '⏺');
 }
@@ -106,7 +111,7 @@ function requestColumns(width) {
         // status, which is the one column that must never be ambiguous.
         { min: 9 },
         { min: 10, grow: 1 },
-        { min: 12 },
+        { min: 13 },
         // 'haiku-4-5' is nine columns once the claude- prefix is stripped.
         { min: 9 },
         { min: 8 },
@@ -122,18 +127,27 @@ function requestHeader(width) {
 function requestLine(r, now, selected, width, spin = 0) {
     const w = requestColumns(width);
     const colour = statusColour(r.status);
+    const handedOff = r.handed_off === true;
     // A run that failed once and then succeeded on retry still carries the
     // old error_code. Showing it on a DONE row reads as "this broke" when
     // the work actually landed — so the code is only for rows that ended badly.
     const endedBadly = r.status !== 'completed' && !exports.ACTIVE.has(r.status);
-    const tail = r.error_code && endedBadly
-        ? (0, render_1.red)(`[${r.error_code}]`)
-        : (r.prompt ?? '').replace(/\s+/g, ' ');
+    const tail = handedOff
+        // Say where it went. Without this the row reads as a run that simply
+        // stopped, when in fact it continued somewhere else.
+        ? (0, render_1.grey)(`→ ${r.to_runtime_name ?? 'another node'}  `) + (0, render_1.dim)((r.prompt ?? '').replace(/\s+/g, ' '))
+        : (r.error_code && endedBadly
+            ? (0, render_1.red)(`[${r.error_code}]`)
+            : (r.prompt ?? '').replace(/\s+/g, ' '));
+    // `agent` is what this node spawned. A run that laddered ended somewhere
+    // else, and saying so is the difference between a history and a guess.
+    const hopped = (r.ladder_hops ?? 0) > 0 && r.current_agent && r.current_agent !== r.agent;
+    const agentCell = hopped ? `${r.agent}→${r.current_agent}` : `${r.agent}/${r.mode}`;
     const cells = [
-        marker(r.status, spin),
-        colour(statusLabel(r.status)),
+        marker(r.status, spin, handedOff),
+        handedOff ? (0, render_1.grey)('Moved') : colour(statusLabel(r.status)),
         r.entity_name ?? '—',
-        (0, render_1.dim)(`${r.agent}/${r.mode}`),
+        (0, render_1.dim)(agentCell),
         (0, render_1.dim)(shortModel(r.model)),
         (0, render_1.dim)(shortVia(r.issued_via)),
         (0, render_1.dim)((0, render_1.fmtDuration)(durationOf(r, now))),