@addai/node 0.4.0

package/dist/sleep-detector.d.ts

@@ -0,0 +1,11 @@
+export declare function isSleepGap(intervalMs: number, actualElapsedMs: number, thresholdMs: number): boolean;
+export interface SleepMonitorOpts {
+    intervalMs: number;
+    thresholdMs: number;
+    onWake: (gapMs: number) => void;
+    now?: () => number;
+}
+export interface SleepMonitor {
+    stop(): void;
+}
+export declare function startSleepMonitor(opts: SleepMonitorOpts): SleepMonitor;

package/dist/sleep-detector.js

@@ -0,0 +1,32 @@
+"use strict";
+// Detects that the machine slept (laptop lid closed mid-run — the most
+// likely cause of Hannah's d1dddb15: her runtime is a MacBook). A suspended
+// process's timers don't fire; on wake they all fire at once, far later than
+// scheduled. We schedule a probe every `intervalMs`; if a probe fires more
+// than `thresholdMs` late, wall-clock jumped forward while we were suspended
+// — i.e. we slept. On wake we re-heartbeat immediately (so the server doesn't
+// keep us marked offline) and reclaim our own in-flight runs (they went stale
+// while suspended) so they re-dispatch, to a backup if we're still groggy.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSleepGap = isSleepGap;
+exports.startSleepMonitor = startSleepMonitor;
+function isSleepGap(intervalMs, actualElapsedMs, thresholdMs) {
+    return actualElapsedMs - intervalMs > thresholdMs;
+}
+function startSleepMonitor(opts) {
+    const now = opts.now ?? Date.now;
+    let last = now();
+    const timer = setInterval(() => {
+        const t = now();
+        const elapsed = t - last;
+        last = t;
+        if (isSleepGap(opts.intervalMs, elapsed, opts.thresholdMs)) {
+            try {
+                opts.onWake(elapsed);
+            }
+            catch { /* best effort */ }
+        }
+    }, opts.intervalMs);
+    timer.unref?.();
+    return { stop() { clearInterval(timer); } };
+}

package/dist/state-migrate.d.ts

@@ -0,0 +1,8 @@
+export declare function migrateLegacyStateDir(opts?: {
+    home?: string;
+    legacy?: string;
+}): {
+    migrated: boolean;
+    copied: string[];
+    moved: string[];
+};

package/dist/state-migrate.js

@@ -0,0 +1,91 @@
+"use strict";
+// One-time move from ~/.entities-runtime to ~/.ainode (the +Ai Node rename).
+//
+// Two classes of state, handled differently on purpose:
+//
+//   * state.json / runtime.json are tiny and precious — COPIED, so the
+//     legacy dir still holds a working pairing token if we roll back.
+//   * tools/ (~100 MB of harness installs) and projects/ (git clones, 1.5 GB
+//     on this author's box) are MOVED. Copying them would duplicate gigabytes
+//     on every node and make first boot crawl. Both live under $HOME, so the
+//     rename is an instant same-filesystem inode move; a cross-device EXDEV
+//     falls back to a copy.
+//
+// The whole migration is skipped once the new home has its own state.json —
+// a node that already migrated (or paired fresh) must never be clobbered by
+// stale legacy state.
+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.migrateLegacyStateDir = migrateLegacyStateDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+const COPY_ENTRIES = ['state.json', 'runtime.json'];
+const MOVE_ENTRIES = ['tools', 'sessions', 'projects'];
+function migrateLegacyStateDir(opts = {}) {
+    const home = opts.home ?? paths_1.RUNTIME_HOME;
+    const legacy = opts.legacy ?? paths_1.LEGACY_RUNTIME_HOME;
+    const copied = [];
+    const moved = [];
+    if (!fs.existsSync(legacy))
+        return { migrated: false, copied, moved };
+    if (fs.existsSync(path.join(home, 'state.json')))
+        return { migrated: false, copied, moved };
+    fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+    for (const entry of COPY_ENTRIES) {
+        const from = path.join(legacy, entry);
+        if (!fs.existsSync(from))
+            continue;
+        fs.cpSync(from, path.join(home, entry), { recursive: true });
+        copied.push(entry);
+    }
+    for (const entry of MOVE_ENTRIES) {
+        const from = path.join(legacy, entry);
+        const to = path.join(home, entry);
+        if (!fs.existsSync(from) || fs.existsSync(to))
+            continue;
+        try {
+            fs.renameSync(from, to);
+        }
+        catch (err) {
+            if (err.code !== 'EXDEV')
+                throw err;
+            fs.cpSync(from, to, { recursive: true });
+            fs.rmSync(from, { recursive: true, force: true });
+        }
+        moved.push(entry);
+    }
+    return { migrated: copied.length > 0 || moved.length > 0, copied, moved };
+}

package/dist/store.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimePairingState } from './types';
+export declare function readPairing(): RuntimePairingState | null;
+export declare function writePairing(state: RuntimePairingState): void;
+export declare function clearPairing(): void;
+export declare function isPaired(): boolean;

package/dist/store.js

@@ -0,0 +1,82 @@
+"use strict";
+// Pairing state: ~/.ainode/state.json.
+//
+// Once paired with +Ai (Supabase), this file holds the runtimeId +
+// daemonToken the daemon uses to authenticate to RPCs. While unpaired
+// it doesn't exist; the CLI's first-run flow creates it.
+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.readPairing = readPairing;
+exports.writePairing = writePairing;
+exports.clearPairing = clearPairing;
+exports.isPaired = isPaired;
+const fs = __importStar(require("fs"));
+const paths_1 = require("./paths");
+const win_1 = require("./win");
+function ensureHome() {
+    if (!fs.existsSync(paths_1.RUNTIME_HOME)) {
+        fs.mkdirSync(paths_1.RUNTIME_HOME, { recursive: true, mode: 0o700 });
+    }
+}
+function readPairing() {
+    if (!fs.existsSync(paths_1.RUNTIME_STATE_FILE))
+        return null;
+    try {
+        const raw = fs.readFileSync(paths_1.RUNTIME_STATE_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.runtimeId || !parsed.daemonToken)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writePairing(state) {
+    ensureHome();
+    const tmp = paths_1.RUNTIME_STATE_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 0o600 });
+    // rename-over-open-file fails EPERM/EBUSY on Windows — retried there.
+    (0, win_1.safeRenameSync)(tmp, paths_1.RUNTIME_STATE_FILE);
+}
+function clearPairing() {
+    try {
+        fs.unlinkSync(paths_1.RUNTIME_STATE_FILE);
+    }
+    catch { /* already gone */ }
+}
+function isPaired() {
+    return readPairing() !== null;
+}

package/dist/supabase-client.d.ts

@@ -0,0 +1,15 @@
+export declare class RpcError extends Error {
+    readonly code: string | undefined;
+    readonly status: number;
+    constructor(message: string, status: number, code?: string);
+}
+export declare function rpcBreakerOpen(): boolean;
+/** Pollers should call this at the top of each tick. If it returns true,
+ *  skip the RPC and wait for the next tick — the breaker is open and the
+ *  endpoint is presumed unhealthy. */
+export declare function rpcShouldSkip(): boolean;
+/**
+ * Call a Supabase RPC and return its JSON body.
+ * Throws RpcError if the request fails or the server returns 4xx/5xx.
+ */
+export declare function rpc<T>(name: string, args?: Record<string, unknown>): Promise<T>;

package/dist/supabase-client.js

@@ -0,0 +1,119 @@
+"use strict";
+// Tiny PostgREST RPC client. We hit Supabase RPC endpoints directly
+// instead of pulling in @supabase/supabase-js — the daemon only needs
+// a handful of calls and shipping the full SDK is unnecessary weight.
+//
+// Auth model: the anon JWT in config.ts gives us access to call
+// SECURITY DEFINER RPCs. Each RPC validates the caller's identity
+// via its arguments (pair_code or daemon_token).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcError = void 0;
+exports.rpcBreakerOpen = rpcBreakerOpen;
+exports.rpcShouldSkip = rpcShouldSkip;
+exports.rpc = rpc;
+const config_1 = require("./config");
+class RpcError extends Error {
+    code;
+    status;
+    constructor(message, status, code) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}
+exports.RpcError = RpcError;
+// Hard timeout for any single RPC call. 10s used to be the value but it
+// caused a death spiral when Supabase got slow: each stalled call held
+// a pooler connection for the full 10s, the pump kept tick()-ing and
+// piling on more, and the connection pool exhausted. 4s frees the
+// connection fast enough that pooler stays healthy even if individual
+// calls fail — the daemon's pickup loop already exponentially backs
+// off on failure, so trading a longer timeout for fewer held
+// connections is the right call here.
+const DEFAULT_RPC_TIMEOUT_MS = 4_000;
+// Shared circuit-breaker state. Every RPC failure increments the counter;
+// every success resets it. When the counter passes BREAKER_THRESHOLD,
+// every poller in the daemon (pump, projects, heartbeat) is expected to
+// pause new RPCs until BREAKER_PAUSE_MS has elapsed, then probe with a
+// SINGLE rpc — if that succeeds, traffic resumes; if it fails the breaker
+// re-opens with the same pause. The whole point is: when Supabase melts,
+// we don't keep hammering it from 3 separate timers and amplify the
+// outage. This module is the single source of truth; pollers call
+// `breakerCheckBeforeRpc()` at the top of their tick.
+const BREAKER_THRESHOLD = 4;
+const BREAKER_PAUSE_MS = 30_000;
+let consecutiveRpcFailures = 0;
+let breakerOpenUntil = 0;
+function rpcBreakerOpen() {
+    return Date.now() < breakerOpenUntil;
+}
+/** Pollers should call this at the top of each tick. If it returns true,
+ *  skip the RPC and wait for the next tick — the breaker is open and the
+ *  endpoint is presumed unhealthy. */
+function rpcShouldSkip() {
+    return rpcBreakerOpen();
+}
+/**
+ * Call a Supabase RPC and return its JSON body.
+ * Throws RpcError if the request fails or the server returns 4xx/5xx.
+ */
+async function rpc(name, args = {}) {
+    const url = `${config_1.SUPABASE_URL}/rest/v1/rpc/${name}`;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), DEFAULT_RPC_TIMEOUT_MS);
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                apikey: config_1.SUPABASE_ANON_KEY,
+                authorization: `Bearer ${config_1.SUPABASE_ANON_KEY}`,
+                'content-type': 'application/json',
+                accept: 'application/json',
+            },
+            body: JSON.stringify(args),
+            signal: ac.signal,
+        });
+    }
+    catch (err) {
+        clearTimeout(timer);
+        // Timeout + network errors both indicate Supabase distress — open the
+        // circuit breaker after a few in a row.
+        consecutiveRpcFailures++;
+        if (consecutiveRpcFailures >= BREAKER_THRESHOLD) {
+            breakerOpenUntil = Date.now() + BREAKER_PAUSE_MS;
+        }
+        if (err?.name === 'AbortError') {
+            throw new RpcError(`rpc ${name} timed out after ${DEFAULT_RPC_TIMEOUT_MS}ms`, 0, 'timeout');
+        }
+        throw err;
+    }
+    clearTimeout(timer);
+    const text = await res.text();
+    let parsed = undefined;
+    if (text) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch { /* leave as undefined */ }
+    }
+    if (!res.ok) {
+        const errBody = parsed;
+        // 4xx other than 429 = "our request is wrong"; don't count those as
+        // breaker failures (they don't indicate Supabase distress). 5xx, 429,
+        // 502/503/504 + network errors (caught above) do.
+        if (res.status >= 500 || res.status === 429) {
+            consecutiveRpcFailures++;
+            if (consecutiveRpcFailures >= BREAKER_THRESHOLD) {
+                breakerOpenUntil = Date.now() + BREAKER_PAUSE_MS;
+            }
+        }
+        throw new RpcError(errBody?.message ?? text ?? `rpc ${name} failed`, res.status, errBody?.code);
+    }
+    // Success — close the breaker.
+    if (consecutiveRpcFailures > 0) {
+        consecutiveRpcFailures = 0;
+        breakerOpenUntil = 0;
+    }
+    return parsed;
+}

package/dist/time-context.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The system-prompt block. `now`/`timeZone` are injectable for tests; callers
+ * omit them to get the machine clock and zone at spawn time.
+ */
+export declare function currentTimeBlock(now?: Date, timeZone?: string): string;
+/**
+ * Append the time block to a request's system prompt (or stand alone when the
+ * request has none). Used at every agent spawn site in session-runner.
+ */
+export declare function appendTimeContext(systemPrompt: string | null | undefined, now?: Date, timeZone?: string): string;

package/dist/time-context.js

@@ -0,0 +1,71 @@
+"use strict";
+// Current-time context injection.
+//
+// Entities had no "now" signal beyond a bare date: the studio-built system
+// prompt carries no clock, and the timestamps they DO see (chat history,
+// background-activity lines) are UTC. With nothing local to anchor on, the
+// model read the UTC clock and called it UK time — a constant 1-hour error
+// all through BST, and an offset error year-round for any non-UTC workspace.
+//
+// The daemon machine's clock and zoneinfo are the source of truth (verified
+// correct where this bit), so every spawned agent turn gets a system-prompt
+// block stating the local wall-clock time, timezone and UTC offset at spawn.
+// Each request is a fresh CLI invocation, so the block is per-turn fresh.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentTimeBlock = currentTimeBlock;
+exports.appendTimeContext = appendTimeContext;
+function machineTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    }
+    catch {
+        return 'UTC';
+    }
+}
+function formatParts(now, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-GB', {
+        timeZone,
+        weekday: 'long', day: 'numeric', month: 'long', year: 'numeric',
+        hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+        timeZoneName: 'short',
+    }).formatToParts(now);
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? '';
+    const stamp = `${get('weekday')} ${get('day')} ${get('month')} ${get('year')}, ${get('hour')}:${get('minute')}`;
+    const zone = get('timeZoneName');
+    const offsetParts = new Intl.DateTimeFormat('en-GB', {
+        timeZone, hour: '2-digit', minute: '2-digit', timeZoneName: 'longOffset',
+    }).formatToParts(now);
+    const rawOffset = offsetParts.find((p) => p.type === 'timeZoneName')?.value ?? 'GMT';
+    // 'GMT+01:00' → 'UTC+01:00'; bare 'GMT' (zero offset) → 'UTC+00:00'.
+    const offset = rawOffset === 'GMT' ? 'UTC+00:00' : rawOffset.replace(/^GMT/, 'UTC');
+    return { stamp, zone, offset };
+}
+/**
+ * The system-prompt block. `now`/`timeZone` are injectable for tests; callers
+ * omit them to get the machine clock and zone at spawn time.
+ */
+function currentTimeBlock(now = new Date(), timeZone = machineTimeZone()) {
+    let tz = timeZone;
+    let fmt;
+    try {
+        fmt = formatParts(now, tz);
+    }
+    catch {
+        tz = 'UTC';
+        fmt = formatParts(now, tz);
+    }
+    return [
+        '## Current date & time',
+        `It is now ${fmt.stamp} ${fmt.zone} (${tz}, ${fmt.offset}). Treat this as "now" — it is the local wall-clock time where you are running, and the time to use when telling users what time it is or when something will happen.`,
+        'Timestamps on chat messages, records and logs may be stored in UTC — convert them to this timezone before repeating them to users. Never read a UTC timestamp as if it were local time.',
+    ].join('\n');
+}
+/**
+ * Append the time block to a request's system prompt (or stand alone when the
+ * request has none). Used at every agent spawn site in session-runner.
+ */
+function appendTimeContext(systemPrompt, now, timeZone) {
+    const block = currentTimeBlock(now, timeZone);
+    const sp = (systemPrompt ?? '').trim();
+    return sp ? `${systemPrompt}\n\n${block}` : block;
+}

package/dist/tokens.d.ts

@@ -0,0 +1,4 @@
+export declare function generateEndpointToken(): string;
+export declare function hashToken(token: string): string;
+export declare function tokensMatch(token: string, expectedHash: string): boolean;
+export declare function tokenPrefix(token: string): string;

package/dist/tokens.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEndpointToken = generateEndpointToken;
+exports.hashToken = hashToken;
+exports.tokensMatch = tokensMatch;
+exports.tokenPrefix = tokenPrefix;
+const crypto_1 = require("crypto");
+const ENDPOINT_PREFIX = 'cf_';
+function generateEndpointToken() {
+    return ENDPOINT_PREFIX + (0, crypto_1.randomBytes)(32).toString('hex');
+}
+function hashToken(token) {
+    return (0, crypto_1.createHash)('sha256').update(token).digest('hex');
+}
+function tokensMatch(token, expectedHash) {
+    if (!token || !expectedHash)
+        return false;
+    let actual;
+    let expected;
+    try {
+        actual = Buffer.from(hashToken(token), 'hex');
+        expected = Buffer.from(expectedHash, 'hex');
+    }
+    catch {
+        return false;
+    }
+    if (actual.length !== expected.length || actual.length === 0)
+        return false;
+    return (0, crypto_1.timingSafeEqual)(actual, expected);
+}
+function tokenPrefix(token) {
+    return token.slice(0, 8);
+}

package/dist/tui/app.d.ts

@@ -0,0 +1,35 @@
+export interface Key {
+    name?: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    sequence?: string;
+}
+export interface Screen {
+    id: string;
+    title: string;
+    render(width: number): string[];
+    onKey?(key: Key): void | Promise<void>;
+    poll?(): Promise<void>;
+    pollMs?(): number;
+    /** True while the screen is consuming raw text (a filter prompt), so the
+     *  global q-to-go-back binding must not steal the keystroke. */
+    capturesKeys?(): boolean;
+}
+export interface AppHost {
+    push(s: Screen): void;
+    pop(): void;
+    replace(s: Screen): void;
+    current(): Screen;
+    depth(): number;
+    quit(): void;
+    redraw(): void;
+    note(msg: string | null): void;
+}
+export declare function createApp(root: Screen, hooks?: {
+    onQuit?: () => void;
+    onRedraw?: () => void;
+}): AppHost & {
+    handleKey(k: Key): Promise<void>;
+    frame(width: number): string[];
+    lastError(): string | null;
+};

package/dist/tui/app.js

@@ -0,0 +1,82 @@
+"use strict";
+// Screen stack + key dispatch for the node console.
+//
+// Deliberately free of terminal I/O so the whole interaction model is
+// unit-testable: run.ts owns stdin/stdout and calls handleKey/frame.
+//
+// The hard rule this file enforces: a screen may throw, and the daemon
+// must not care. Every screen call is fenced.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApp = createApp;
+const render_1 = require("./render");
+function createApp(root, hooks = {}) {
+    const stack = [root];
+    let error = null;
+    let noteMsg = null;
+    const host = {
+        push(s) { stack.push(s); host.redraw(); },
+        pop() { if (stack.length > 1) {
+            stack.pop();
+            host.redraw();
+        } },
+        replace(s) { stack[stack.length - 1] = s; host.redraw(); },
+        current: () => stack[stack.length - 1],
+        depth: () => stack.length,
+        quit() { hooks.onQuit?.(); },
+        redraw() { hooks.onRedraw?.(); },
+        note(msg) { noteMsg = msg; host.redraw(); },
+    };
+    async function toScreen(k) {
+        try {
+            await host.current().onKey?.(k);
+        }
+        catch (err) {
+            error = err.message;
+            host.redraw();
+        }
+    }
+    return {
+        ...host,
+        async handleKey(k) {
+            if (!k)
+                return;
+            // Ctrl-C is unconditional: it must work even from a filter prompt.
+            if (k.ctrl && k.name === 'c') {
+                host.quit();
+                return;
+            }
+            let capturing = false;
+            try {
+                capturing = host.current().capturesKeys?.() === true;
+            }
+            catch {
+                capturing = false;
+            }
+            if (k.name === 'q' && !capturing) {
+                if (stack.length > 1)
+                    host.pop();
+                else
+                    host.quit();
+                return;
+            }
+            await toScreen(k);
+        },
+        frame(width) {
+            let body;
+            try {
+                body = host.current().render(width);
+            }
+            catch (err) {
+                error = err.message;
+                body = [(0, render_1.red)(`screen error: ${err.message}`)];
+            }
+            const footer = [];
+            if (noteMsg)
+                footer.push('', noteMsg);
+            if (error)
+                footer.push('', (0, render_1.dim)(`last error: ${error}`));
+            return [...body, ...footer];
+        },
+        lastError: () => error,
+    };
+}

package/dist/tui/console-capture.d.ts

@@ -0,0 +1,13 @@
+export interface CapturedLog {
+    level: 'log' | 'warn' | 'error';
+    text: string;
+    at: number;
+}
+export interface ConsoleCapture {
+    lines(): CapturedLog[];
+    last(): CapturedLog | null;
+    count(): number;
+    /** Restore the real console and replay everything captured. */
+    restoreAndReplay(): void;
+}
+export declare function captureConsole(): ConsoleCapture;