@addai/node 0.5.0 → 0.6.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.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;
@@ -505,6 +506,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 +546,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,13 +237,21 @@ 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.
+    // 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.
     (0, command_runner_1.setRestartHook)(async ({ commandId, version }) => {
         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) {
             const err = await (0, self_update_1.installGlobal)(version);
             if (err)
@@ -251,11 +260,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,
@@ -270,7 +281,9 @@ async function start() {
         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`);
+        console.log(supervised
+            ? `[restart] standing down for launchd to restart us (${mode} → ${version}); exiting`
+            : `[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
         setTimeout(() => process.exit(0), 250).unref?.();
     });
     process.once('SIGINT', () => { stop().finally(() => process.exit(0)); });

package/dist/memory-capture.js

@@ -19,7 +19,16 @@ function buildCapturePayload(req, userText, assistantText, transcriptRef) {
         transcript_ref: transcriptRef,
     };
 }
-async function postCapture(baseUrl, serviceToken, payload, timeoutMs = 5000) {
+// timeoutMs default is 15000 (not 5000): the entity-memory-capture edge fn
+// synchronously summarizes each turn via an Anthropic Haiku call on its
+// DEFAULT path, so its server-side latency is inherently ~3-5s (measured over
+// 24h: p50 ~3.4s, p95 ~4.75s, p99 ~6.35s). A 5s abort clipped that long tail,
+// surfacing "operation was aborted due to timeout" and dropping those turns'
+// captures. postCapture is fire-and-forget (void, post-terminal — see
+// session-runner notifyCaptureIfEnabled), so a longer timeout NEVER slows a
+// run; it only lets slow/tail captures land. 15s clears observed p99 with 2x
+// headroom for network/TLS.
+async function postCapture(baseUrl, serviceToken, payload, timeoutMs = 15000) {
     try {
         const res = await fetch(`${baseUrl}/functions/v1/entity-memory-capture`, {
             method: 'POST',

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<{
@@ -29,6 +35,25 @@ 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 node's own state, as a label.
+ *
+ * A daemon is running — we either started it or the lockfile proved it — so
+ * the node IS online, whatever the server has got round to saying. Waiting
+ * for `runtime_self` to come back before admitting that meant the first
+ * 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[];
 export declare function renderDashboard(st: DashboardState, width: number, height: number): string[];
 export declare function createDashboardScreen(deps: {

package/dist/tui/dashboard.js

@@ -8,59 +8,118 @@
 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;
 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' },
-    { key: 'harnesses', label: 'Harnesses', hint: 'install / log in agent CLIs', shortcut: 'h' },
-    { key: 'logs', label: 'Logs', hint: 'what the daemon is saying', shortcut: 'l' },
+    { key: 'activity', label: 'Activity', hint: 'Every request this node has handled', shortcut: 'a' },
+    { key: 'harnesses', label: 'Harnesses', hint: 'Install / log in agent CLIs', shortcut: 'h' },
+    { key: 'logs', label: 'Logs', hint: 'What the daemon is saying', shortcut: 'l' },
 ];
 /** Live rows the NOW band shows before it starts counting the rest. */
 exports.MAX_NOW_ROWS = 6;
 function liveRequests(rows) {
     return rows.filter(r => request_row_1.ACTIVE.has(r.status));
 }
+/**
+ * The node's own state, as a label.
+ *
+ * A daemon is running — we either started it or the lockfile proved it — so
+ * the node IS online, whatever the server has got round to saying. Waiting
+ * for `runtime_self` to come back before admitting that meant the first
+ * second of every session claimed the node was in an unknown state.
+ */
+function stateLabel(st) {
+    const reported = st.self?.effective_status;
+    if (!reported)
+        return (0, render_1.green)('Online');
+    if (reported === 'online')
+        return (0, render_1.green)('Online');
+    return (0, render_1.yellow)(reported.charAt(0).toUpperCase() + reported.slice(1));
+}
 function headerLines(st) {
     if (!st.paired) {
         return [
-            (0, render_1.yellow)('not paired'),
+            (0, render_1.yellow)('Not paired'),
             (0, render_1.dim)('run `ainode` and follow the prompt to vault.add.ai/entity/connect/<CODE>'),
         ];
     }
     const self = st.self;
-    const name = self?.name ?? self?.hostname ?? 'this node';
-    const state = self?.effective_status === 'online'
-        ? (0, render_1.green)('online')
-        : (0, render_1.yellow)(self?.effective_status ?? 'unknown');
+    const name = self?.name ?? self?.hostname ?? 'This node';
     const paired = self?.created_at ? `paired ${(0, render_1.fmtRelative)(self.created_at, st.now)}` : '';
-    const first = `${(0, render_1.bold)(name)} ${(0, render_1.dim)('·')} ${state} ${(0, render_1.dim)('·')} ${(0, render_1.dim)(paired)}`;
+    const first = `${(0, render_1.bold)(name)} ${(0, render_1.dim)('·')} ${stateLabel(st)}${paired ? ` ${(0, render_1.dim)('·')} ${(0, render_1.dim)(paired)}` : ''}`;
     const up = st.startedAt ? (0, render_1.fmtDuration)(st.now - st.startedAt) : '—';
     const daemon = st.viewerMode
-        ? `${(0, render_1.cyan)('⏺')} viewer ${(0, render_1.dim)('· another ainode owns this node')}  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}`
-        : `${(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];
+        ? `${(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, 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) {
+    if (n == null)
+        return '—';
+    return String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+/** A labelled figure, padded so the labels line up down the screen. */
+function stat(label, value, width = 14) {
+    return (0, render_1.padEndVisible)(`${(0, render_1.dim)(label)} ${value}`, width);
 }
 function statsLines(st) {
     const s = st.stats;
-    if (!s)
-        return [(0, render_1.dim)('stats unavailable')];
+    // Keep the shape while the first fetch is in flight, so the band doesn't
+    // pop into place a second after the header.
+    if (!s) {
+        return [
+            `${stat('Today', (0, render_1.dim)('—'))}${stat('24h', (0, render_1.dim)('—'), 26)}${stat('Avg', (0, render_1.dim)('—'))}`,
+            `${stat('Week', (0, render_1.dim)('—'))}${stat('Month', (0, render_1.dim)('—'), 26)}${stat('Total', (0, render_1.dim)('—'))}`,
+        ];
+    }
     const agents = Object.entries(s.by_agent)
         .sort((a, b) => b[1] - a[1])
-        .map(([k, v]) => `${k} ${v}`)
-        .join(' · ');
-    const cancels = s.canceled_24h ? (0, render_1.dim)(`  ${s.canceled_24h} cancelled`) : '';
-    // The ✓/✗/avg figures are a rolling 24h window while "Today" is the
-    // calendar day, so they are labelled — otherwise ✓3 next to Today 2
-    // looks like an arithmetic bug.
+        .map(([k, v]) => `${k.charAt(0).toUpperCase()}${k.slice(1)} ${fmtCount(v)}`)
+        .join((0, render_1.dim)(' · '));
+    // The ✓/✗ figures are a rolling 24h window while "Today" is the calendar
+    // day, so the window is labelled — otherwise ✓3 next to Today 2 looks
+    // like an arithmetic bug.
+    const outcomes = [
+        (0, render_1.green)(`✓ ${fmtCount(s.succeeded_24h)}`),
+        s.failed_24h ? (0, render_1.red)(`✗ ${fmtCount(s.failed_24h)}`) : (0, render_1.dim)('✗ 0'),
+        s.canceled_24h ? (0, render_1.grey)(`⊘ ${fmtCount(s.canceled_24h)}`) : '',
+    ].filter(Boolean).join('  ');
+    // Both rows share one three-column grid, so Month sits under 24h and
+    // Total under Avg rather than the two rows drifting apart.
     return [
-        `${(0, render_1.bold)(`Today ${s.today}`)}   ${(0, render_1.dim)('·')}   ${(0, render_1.dim)('24h')} ${(0, render_1.green)(`✓ ${s.succeeded_24h}`)}  ${s.failed_24h ? (0, render_1.red)(`✗ ${s.failed_24h}`) : (0, render_1.dim)('✗ 0')}${cancels}   ${(0, render_1.dim)(`avg ${(0, render_1.fmtDuration)(s.avg_duration_ms)}`)}   ${(0, render_1.dim)(agents)}`,
-        (0, render_1.dim)(`Week ${s.week}   Month ${s.month}   Total ${s.total}`),
+        `${stat('Today', (0, render_1.bold)(fmtCount(s.today)))}${stat('24h', outcomes, 26)}${stat('Avg', (0, render_1.fmtDuration)(s.avg_duration_ms))}`,
+        `${stat('Week', fmtCount(s.week))}${stat('Month', fmtCount(s.month), 26)}${stat('Total', fmtCount(s.total))}${(0, render_1.dim)(agents)}`,
     ];
 }
 /** The most recent request that actually finished, for the idle line. */
@@ -69,12 +128,12 @@ function lastFinished(rows) {
 }
 function nowLines(st, width, rows) {
     const live = liveRequests(st.recent);
-    const out = [`  ${(0, render_1.bold)('NOW')}`];
+    const out = [`  ${(0, render_1.bold)('Now')}`];
     if (live.length === 0) {
         const last = lastFinished(st.recent);
         out.push(last
-            ? (0, render_1.dim)(`  idle — last run finished ${(0, render_1.fmtRelative)(last.finished_at, st.now)}`)
-            : (0, render_1.dim)('  idle'));
+            ? (0, render_1.dim)(`  Idle — last run finished ${(0, render_1.fmtRelative)(last.finished_at, st.now)}`)
+            : (0, render_1.dim)('  Idle'));
         return out;
     }
     out.push((0, request_row_1.requestHeader)(width));
@@ -86,7 +145,7 @@ function nowLines(st, width, rows) {
     return out;
 }
 function renderDashboard(st, width, height) {
-    const head = (0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`ainode v${st.version}`)}`, headerLines(st), width);
+    const head = (0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`@addai/node v${st.version}`)}`, headerLines(st), width);
     if (!st.paired) {
         return [...head, '', (0, app_1.footerHint)([{ keys: 'q', label: 'quit' }])].slice(0, height);
     }
@@ -104,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' },
@@ -142,7 +202,45 @@ 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',
@@ -165,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) {
@@ -190,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/harnesses.js

@@ -89,10 +89,10 @@ function formatVersion(v) {
 }
 function accountLabel(p) {
     if (!p?.available)
-        return 'not installed';
+        return 'Not installed';
     if (!p.authed)
-        return 'not logged in';
-    const who = p.account ?? p.accountKind ?? 'logged in';
+        return 'Not logged in';
+    const who = p.account ?? p.accountKind ?? 'Logged in';
     return p.plan ? `${who} · ${p.plan}` : who;
 }
 /**
@@ -120,7 +120,10 @@ function harnessRow(id, p, selected, width) {
     const spec = harness_registry_1.HARNESSES[id];
     const w = harnessColumns(width);
     const act = actionFor(id, p);
-    const action = act === 'ok' ? (0, render_1.green)('✓ ready') : act === 'log out' ? (0, render_1.dim)(`⏎ ${act}`) : (0, render_1.cyan)(`⏎ ${act}`);
+    // The verb is Title Case in the row the same way every other label is; the
+    // value actionFor returns stays lowercase because the key handler reads it.
+    const verb = act.charAt(0).toUpperCase() + act.slice(1);
+    const action = act === 'ok' ? (0, render_1.green)('✓ Ready') : act === 'log out' ? (0, render_1.dim)(`⏎ ${verb}`) : (0, render_1.cyan)(`⏎ ${verb}`);
     const line = (0, render_1.tableRow)([
         dot(p),
         selected ? (0, render_1.bold)(spec.label) : spec.label,
@@ -135,14 +138,14 @@ function harnessRow(id, p, selected, width) {
 function renderHarnesses(st, width, height) {
     const out = [];
     const authed = st.caps ? harness_registry_1.HARNESS_IDS.filter(id => st.caps?.[id]?.authed).length : 0;
-    out.push((0, app_1.heading)('HARNESSES', st.caps ? `${authed}/${harness_registry_1.HARNESS_IDS.length} ready` : 'probing…'));
+    out.push((0, app_1.heading)('Harnesses', st.caps ? `${authed}/${harness_registry_1.HARNESS_IDS.length} ready` : 'Probing…'));
     out.push('');
     if (!st.caps) {
-        out.push(`  ${(0, render_1.cyan)(render_1.SPIN[st.spin % render_1.SPIN.length])} ${(0, render_1.dim)('probing installed harnesses…')}`);
+        out.push(`  ${(0, render_1.cyan)(render_1.SPIN[st.spin % render_1.SPIN.length])} ${(0, render_1.dim)('Probing installed harnesses…')}`);
     }
     else {
         const w = harnessColumns(width);
-        out.push((0, render_1.dim)('  ' + (0, render_1.tableRow)(['', 'HARNESS', 'VERSION', 'ACCOUNT', 'MODELS', 'EFFORTS', ''], w)));
+        out.push((0, render_1.dim)('  ' + (0, render_1.tableRow)(['', 'Harness', 'Version', 'Account', 'Models', 'Efforts', ''], w)));
         harness_registry_1.HARNESS_IDS.forEach((id, i) => out.push(harnessRow(id, st.caps?.[id], i === st.sel, width)));
     }
     if (st.busy)
@@ -353,7 +356,7 @@ async function plainStatus() {
     const caps = await (0, capabilities_1.probeCapabilities)();
     for (const id of harness_registry_1.HARNESS_IDS) {
         const p = caps[id];
-        const state = !p?.available ? 'not installed' : p.authed ? `authed (${p.account ?? p.accountKind ?? '?'})` : 'not logged in';
+        const state = !p?.available ? 'Not installed' : p.authed ? `authed (${p.account ?? p.accountKind ?? '?'})` : 'Not logged in';
         console.log(`${id.padEnd(8)} ${(p?.version ?? '—').padEnd(12)} ${state}`);
     }
 }

package/dist/tui/logs.js

@@ -40,13 +40,13 @@ function renderLogs(st, lines, width, height, emptyHint) {
     const scope = st.filter
         ? `${shown.length} matching “${st.filter}”`
         : `${shown.length} lines this session`;
-    out.push((0, app_1.heading)('LOGS', scope));
+    out.push((0, app_1.heading)('Logs', scope));
     out.push('');
     if (shown.length === 0) {
         if (st.filter)
-            out.push((0, render_1.dim)('  nothing matches that filter'));
+            out.push((0, render_1.dim)('  Nothing matches that filter'));
         else
-            out.push((0, render_1.dim)(`  ${emptyHint ?? 'the daemon has said nothing yet'}`));
+            out.push((0, render_1.dim)(`  ${emptyHint ?? 'The daemon has said nothing yet'}`));
     }
     else {
         const maxScroll = Math.max(0, shown.length - rows);