@addai/node 0.4.0 → 0.5.1

package/dist/cli.js

@@ -20,7 +20,6 @@ const lockfile_1 = require("./lockfile");
 const index_1 = require("./index");
 const store_1 = require("./store");
 const supabase_client_1 = require("./supabase-client");
-const harnesses_1 = require("./tui/harnesses");
 const run_1 = require("./tui/run");
 const args = process.argv.slice(2);
 function token() {
@@ -71,7 +70,7 @@ async function main() {
         // could never come back from a crash without someone deleting the file
         // by hand. Same liveness check acquireLockfile() uses.
         const existing = (0, lockfile_1.readLockfile)();
-        if (existing && (0, lockfile_1.processAlive)(existing.pid) && tui) {
+        if ((0, lockfile_1.lockfileAlive)(existing) && existing && tui) {
             await (0, run_1.runDashboard)({
                 viewerMode: true,
                 pid: existing.pid,
@@ -98,7 +97,7 @@ async function main() {
     }
     switch (cmd) {
         case 'harnesses':
-            await (0, harnesses_1.runHarnessesTui)();
+            await (0, run_1.runHarnessesTui)();
             return;
         case 'unpair':
             await cmdUnpair();

package/dist/lockfile.d.ts

@@ -3,28 +3,68 @@ export interface LockfileBody {
     port: number;
     version: string;
     startedAt: number;
+    /** Absolute path of the script this daemon is running. Recorded so a later
+     *  `ainode` can identify the process exactly, however it was invoked. */
+    script?: string;
 }
+/** The script this process is running — what ends up in the lockfile. */
+export declare function entryScript(): string;
 /**
  * Does this command line belong to one of our daemons?
  *
  * Kept deliberately broad across the +Ai Node rename: a box mid-roll may
  * still be running a pre-rename daemon, and treating it as an unrelated
  * process would let a second daemon start alongside it.
+ *
+ * This is now a FALLBACK, used only for lockfiles written before we started
+ * recording the script path. On its own it is not a sound test: a daemon
+ * started from a checkout as `node dist/cli.js` matches none of these names,
+ * and calling that live daemon stale is exactly how two of them ended up
+ * heartbeating for the same node.
  */
 export declare function isOwnDaemonCmdline(cmdline: string): boolean;
+/**
+ * Is `cmdline` running `script`?
+ *
+ * Compares the full path first, then the last two segments, so a daemon
+ * reached through a symlink or a realpath'd temp dir still identifies as
+ * itself. Exported for tests.
+ */
+export declare function cmdlineRunsScript(cmdline: string, script: string): boolean;
+/** What the lockfile claims, for `processAlive` to check the pid against. */
+export interface ProcessIdentity {
+    script?: string;
+    startedAt?: number;
+}
 /**
  * Is the pid in the lockfile a live daemon of ours?
  *
  * Exported because the CLI's read-only "viewer" path needs the same answer
  * acquireLockfile() needs: a lockfile left behind by a crashed daemon must
- * not be mistaken for a running one.
+ * not be mistaken for a running one, and a live one must never be mistaken
+ * for stale.
+ *
+ * The order matters. We ask, in turn:
+ *
+ *   1. Can we signal it at all? ESRCH means dead, and that's the end of it.
+ *   2. Is it running the exact script the lockfile recorded? This is the
+ *      sound test — it does not care whether the daemon was started as
+ *      `ainode`, `npx @addai/node` or `node dist/cli.js`.
+ *   3. Failing that (old lockfile, no script recorded), does the command line
+ *      carry one of the names we've shipped under?
+ *   4. Failing that, did the process start when the lockfile says it did?
+ *      A recycled pid will have started much later.
+ *
+ * Only when all of those fail do we call the lockfile stale.
  */
-export declare function processAlive(pid: number): boolean;
+export declare function processAlive(pid: number, expect?: ProcessIdentity): boolean;
+/** `processAlive` for a lockfile body — the form every caller actually wants. */
+export declare function lockfileAlive(body: LockfileBody | null): boolean;
 export declare function readLockfile(): LockfileBody | null;
 /**
  * Throw if another runtime is already running. Returns the lockfile body
  * we wrote on success. The caller is responsible for calling
  * `releaseLockfile()` on clean shutdown.
  */
-export declare function acquireLockfile(body: Omit<LockfileBody, 'pid'>): LockfileBody;
+export declare function acquireLockfile(body: Omit<LockfileBody, 'pid' | 'script'>): LockfileBody;
 export declare function releaseLockfile(): void;

package/dist/lockfile.js

@@ -1,7 +1,8 @@
 "use strict";
 // Tiny lockfile at `~/.ainode/runtime.json`. Written on start
-// (with pid + port + version), polled by the CodeFlows desktop to decide
-// whether the runtime is alive, and unlinked on a clean exit.
+// (with pid + port + version + the script that is running), polled by the
+// CodeFlows desktop to decide whether the runtime is alive, and unlinked on a
+// clean exit.
 //
 // We trust pid checks via `process.kill(pid, 0)` to detect stale lockfiles
 // from previous crashes — Node throws if the pid doesn't belong to a
@@ -40,8 +41,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.entryScript = entryScript;
 exports.isOwnDaemonCmdline = isOwnDaemonCmdline;
+exports.cmdlineRunsScript = cmdlineRunsScript;
 exports.processAlive = processAlive;
+exports.lockfileAlive = lockfileAlive;
 exports.readLockfile = readLockfile;
 exports.acquireLockfile = acquireLockfile;
 exports.releaseLockfile = releaseLockfile;
@@ -52,12 +56,22 @@ function ensureHome() {
         fs.mkdirSync(paths_1.RUNTIME_HOME, { recursive: true, mode: 0o700 });
     }
 }
+/** The script this process is running — what ends up in the lockfile. */
+function entryScript() {
+    return require.main?.filename ?? process.argv[1] ?? '';
+}
 /**
  * Does this command line belong to one of our daemons?
  *
  * Kept deliberately broad across the +Ai Node rename: a box mid-roll may
  * still be running a pre-rename daemon, and treating it as an unrelated
  * process would let a second daemon start alongside it.
+ *
+ * This is now a FALLBACK, used only for lockfiles written before we started
+ * recording the script path. On its own it is not a sound test: a daemon
+ * started from a checkout as `node dist/cli.js` matches none of these names,
+ * and calling that live daemon stale is exactly how two of them ended up
+ * heartbeating for the same node.
  */
 function isOwnDaemonCmdline(cmdline) {
     const s = cmdline.toLowerCase();
@@ -74,14 +88,82 @@ function isOwnDaemonCmdline(cmdline) {
         || s.includes('entity-runtime')
         || s.includes('entities-runtime');
 }
+/** Normalise for comparison: lowercase, forward slashes. */
+function normalisePath(p) {
+    return p.toLowerCase().replace(/\\/g, '/');
+}
+/**
+ * Is `cmdline` running `script`?
+ *
+ * Compares the full path first, then the last two segments, so a daemon
+ * reached through a symlink or a realpath'd temp dir still identifies as
+ * itself. Exported for tests.
+ */
+function cmdlineRunsScript(cmdline, script) {
+    if (!script.trim() || !cmdline.trim())
+        return false;
+    const c = normalisePath(cmdline);
+    const s = normalisePath(script);
+    if (c.includes(s))
+        return true;
+    const tail = s.split('/').slice(-2).join('/');
+    return tail.length > 0 && c.includes(tail);
+}
+/** Run a probe for the pid, returning trimmed stdout or null if it failed. */
+function probe(args, pid) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { execFileSync } = require('child_process');
+        const out = process.platform === 'win32'
+            ? execFileSync('powershell.exe', [
+                '-NoProfile', '-NonInteractive', '-Command',
+                args.win.replace('$PID', String(Number(pid))),
+            ], { encoding: 'utf8', timeout: 5000, windowsHide: true })
+            : execFileSync('ps', args.unix.map(a => a.replace('$PID', String(Number(pid)))), {
+                encoding: 'utf8',
+                timeout: 2000,
+            });
+        return out.toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** When did this pid start, in epoch ms? Null if we can't tell. */
+function processStartedAt(pid) {
+    const raw = probe({
+        unix: ['-p', '$PID', '-o', 'lstart='],
+        win: '(Get-CimInstance Win32_Process -Filter "ProcessId=$PID").CreationDate.ToString("o")',
+    }, pid);
+    if (!raw)
+        return null;
+    const ms = new Date(raw).getTime();
+    return Number.isFinite(ms) ? ms : null;
+}
+/** A process may legitimately start slightly before it writes its lockfile. */
+const START_TIME_TOLERANCE_MS = 60_000;
 /**
  * Is the pid in the lockfile a live daemon of ours?
  *
  * Exported because the CLI's read-only "viewer" path needs the same answer
  * acquireLockfile() needs: a lockfile left behind by a crashed daemon must
- * not be mistaken for a running one.
+ * not be mistaken for a running one, and a live one must never be mistaken
+ * for stale.
+ *
+ * The order matters. We ask, in turn:
+ *
+ *   1. Can we signal it at all? ESRCH means dead, and that's the end of it.
+ *   2. Is it running the exact script the lockfile recorded? This is the
+ *      sound test — it does not care whether the daemon was started as
+ *      `ainode`, `npx @addai/node` or `node dist/cli.js`.
+ *   3. Failing that (old lockfile, no script recorded), does the command line
+ *      carry one of the names we've shipped under?
+ *   4. Failing that, did the process start when the lockfile says it did?
+ *      A recycled pid will have started much later.
+ *
+ * Only when all of those fail do we call the lockfile stale.
  */
-function processAlive(pid) {
+function processAlive(pid, expect = {}) {
     let signalSucceeded;
     try {
         process.kill(pid, 0);
@@ -98,41 +180,35 @@ function processAlive(pid) {
     // a system process owned by another user. `process.kill(pid, 0)` then
     // returns EPERM (legitimately — that process IS alive, just not ours)
     // and the naive check would refuse to start the new daemon forever.
-    // Verify the PID actually points at OUR daemon by checking its command
-    // line for the expected binary name. If the cmdline doesn't include
-    // 'entity-runtime' or 'entities-runtime', the lockfile is stale.
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { execFileSync } = require('child_process');
-        let out;
-        if (process.platform === 'win32') {
-            // No `ps` on Windows; the daemon runs as node.exe so tasklist's image
-            // name can't identify it — read the full command line via CIM.
-            out = execFileSync('powershell.exe', [
-                '-NoProfile', '-NonInteractive', '-Command',
-                `(Get-CimInstance Win32_Process -Filter "ProcessId=${Number(pid)}").CommandLine`,
-            ], { encoding: 'utf8', timeout: 5000, windowsHide: true }).toString().toLowerCase();
-        }
-        else {
-            out = execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
-                encoding: 'utf8',
-                timeout: 2000,
-            }).toString().toLowerCase();
-        }
-        // Both probes exit 0 with empty output if pid is dead — handle that too.
-        if (!out.trim())
-            return false;
-        if (!isOwnDaemonCmdline(out)) {
-            return false; // pid was recycled to an unrelated process
-        }
-        return true;
-    }
-    catch {
+    const cmdline = probe({
+        unix: ['-p', '$PID', '-o', 'command='],
+        win: '(Get-CimInstance Win32_Process -Filter "ProcessId=$PID").CommandLine',
+    }, pid);
+    if (cmdline === null) {
         // ps/powershell failed (timeout, weird platform). Fall back to the
-        // original signal result — better to refuse start than to clobber a
-        // real daemon.
+        // signal result — better to refuse start than to clobber a real daemon.
         return signalSucceeded;
     }
+    // Both probes exit 0 with empty output if the pid is dead.
+    if (!cmdline)
+        return false;
+    if (expect.script && cmdlineRunsScript(cmdline, expect.script))
+        return true;
+    if (isOwnDaemonCmdline(cmdline))
+        return true;
+    if (expect.startedAt) {
+        const started = processStartedAt(pid);
+        if (started !== null && Math.abs(started - expect.startedAt) <= START_TIME_TOLERANCE_MS) {
+            return true;
+        }
+    }
+    return false; // pid was recycled to an unrelated process
+}
+/** `processAlive` for a lockfile body — the form every caller actually wants. */
+function lockfileAlive(body) {
+    if (!body)
+        return false;
+    return processAlive(body.pid, { script: body.script, startedAt: body.startedAt });
 }
 function readLockfile() {
     try {
@@ -154,10 +230,10 @@ function readLockfile() {
 function acquireLockfile(body) {
     ensureHome();
     const existing = readLockfile();
-    if (existing && processAlive(existing.pid)) {
+    if (lockfileAlive(existing)) {
         throw new Error(`ainode is already running (pid ${existing.pid}, port ${existing.port}).`);
     }
-    const final = { pid: process.pid, ...body };
+    const final = { pid: process.pid, script: entryScript(), ...body };
     fs.writeFileSync(paths_1.RUNTIME_LOCK_FILE, JSON.stringify(final, null, 2), { mode: 0o600 });
     return final;
 }

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/paths.d.ts

@@ -3,6 +3,9 @@ export declare const RUNTIME_HOME: string;
 export declare const LEGACY_RUNTIME_HOME: string;
 export declare const RUNTIME_STATE_FILE: string;
 export declare const RUNTIME_LOCK_FILE: string;
+/** Where the daemon's output lands: the file nohup/launchd redirect into,
+ *  and the file the console appends to while it owns the terminal. */
+export declare const RUNTIME_LOG_FILE: string;
 export declare const RUNTIME_SESSIONS_DIR: string;
 export declare const CLAUDE_HOME: string;
 export declare const CLAUDE_PROJECTS_DIR: string;

package/dist/paths.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RELAY_HOST = exports.CLAUDE_PROJECTS_DIR = exports.CLAUDE_HOME = exports.RUNTIME_SESSIONS_DIR = exports.RUNTIME_LOCK_FILE = exports.RUNTIME_STATE_FILE = exports.LEGACY_RUNTIME_HOME = exports.RUNTIME_HOME = void 0;
+exports.RELAY_HOST = exports.CLAUDE_PROJECTS_DIR = exports.CLAUDE_HOME = exports.RUNTIME_SESSIONS_DIR = exports.RUNTIME_LOG_FILE = exports.RUNTIME_LOCK_FILE = exports.RUNTIME_STATE_FILE = exports.LEGACY_RUNTIME_HOME = exports.RUNTIME_HOME = void 0;
 // All on-disk paths the runtime uses.
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -42,6 +42,9 @@ exports.RUNTIME_HOME = path.join(os.homedir(), '.ainode');
 exports.LEGACY_RUNTIME_HOME = path.join(os.homedir(), '.entities-runtime');
 exports.RUNTIME_STATE_FILE = path.join(exports.RUNTIME_HOME, 'state.json');
 exports.RUNTIME_LOCK_FILE = path.join(exports.RUNTIME_HOME, 'runtime.json');
+/** Where the daemon's output lands: the file nohup/launchd redirect into,
+ *  and the file the console appends to while it owns the terminal. */
+exports.RUNTIME_LOG_FILE = path.join(exports.RUNTIME_HOME, 'daemon.log');
 exports.RUNTIME_SESSIONS_DIR = path.join(exports.RUNTIME_HOME, 'sessions');
 exports.CLAUDE_HOME = path.join(os.homedir(), '.claude');
 exports.CLAUDE_PROJECTS_DIR = path.join(exports.CLAUDE_HOME, 'projects');

package/dist/tui/app.d.ts

@@ -4,16 +4,29 @@ export interface Key {
     shift?: boolean;
     sequence?: string;
 }
+/** One line of the `?` help screen. */
+export interface KeyHint {
+    keys: string;
+    label: string;
+}
 export interface Screen {
     id: string;
     title: string;
-    render(width: number): string[];
+    /** Must return at most `height` lines. The app clamps as a backstop, but a
+     *  screen that leans on the clamp loses its own footer to the cut. */
+    render(width: number, height: 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;
+    /** Screen-specific bindings, listed by the `?` screen. */
+    keys?(): KeyHint[];
+    /** Animation tick, several times a second. Return true to ask for a
+     *  repaint — a screen with nothing moving should return false so an idle
+     *  node isn't repainting the terminal for no reason. */
+    tick?(n: number): boolean;
 }
 export interface AppHost {
     push(s: Screen): void;
@@ -25,11 +38,20 @@ export interface AppHost {
     redraw(): void;
     note(msg: string | null): void;
 }
+export declare const GLOBAL_KEYS: KeyHint[];
 export declare function createApp(root: Screen, hooks?: {
     onQuit?: () => void;
     onRedraw?: () => void;
 }): AppHost & {
     handleKey(k: Key): Promise<void>;
-    frame(width: number): string[];
+    frame(width: number, height: number): string[];
+    /** The screen due for a poll now, or null. Marks it polled. */
+    duePoll(now: number): Screen | null;
     lastError(): string | null;
+    helpOpen(): boolean;
 };
+/** Screens build their footers with this so the grammar is identical
+ *  everywhere: dim, two-space indent, key then label. */
+export declare function footerHint(hints: KeyHint[]): string;
+/** A screen heading: bold label with dim trailing detail. */
+export declare function heading(label: string, detail?: string): string;

package/dist/tui/app.js

@@ -7,20 +7,31 @@
 // 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.GLOBAL_KEYS = void 0;
 exports.createApp = createApp;
+exports.footerHint = footerHint;
+exports.heading = heading;
 const render_1 = require("./render");
+exports.GLOBAL_KEYS = [
+    { keys: '?', label: 'this help' },
+    { keys: 'q', label: 'back — quit from the home screen' },
+    { keys: 'ctrl-c', label: 'quit immediately' },
+];
 function createApp(root, hooks = {}) {
-    const stack = [root];
+    const stack = [{ screen: root, lastPoll: 0 }];
     let error = null;
     let noteMsg = null;
+    let help = false;
+    const top = () => stack[stack.length - 1];
     const host = {
-        push(s) { stack.push(s); host.redraw(); },
+        push(s) { stack.push({ screen: s, lastPoll: 0 }); help = false; host.redraw(); },
         pop() { if (stack.length > 1) {
             stack.pop();
+            help = false;
             host.redraw();
         } },
-        replace(s) { stack[stack.length - 1] = s; host.redraw(); },
-        current: () => stack[stack.length - 1],
+        replace(s) { stack[stack.length - 1] = { screen: s, lastPoll: 0 }; host.redraw(); },
+        current: () => top().screen,
         depth: () => stack.length,
         quit() { hooks.onQuit?.(); },
         redraw() { hooks.onRedraw?.(); },
@@ -28,15 +39,32 @@ function createApp(root, hooks = {}) {
     };
     async function toScreen(k) {
         try {
-            await host.current().onKey?.(k);
+            await top().screen.onKey?.(k);
         }
         catch (err) {
             error = err.message;
             host.redraw();
         }
     }
+    function helpLines(width) {
+        let own = [];
+        try {
+            own = top().screen.keys?.() ?? [];
+        }
+        catch {
+            own = [];
+        }
+        const rows = [...own, ...exports.GLOBAL_KEYS];
+        const gutter = Math.max(6, ...rows.map(r => r.keys.length));
+        return [
+            ...(0, render_1.panel)(`Keys ${(0, render_1.dim)('·')} ${top().screen.title}`, rows.map(r => `${(0, render_1.cyan)(r.keys.padEnd(gutter))}  ${(0, render_1.dim)(r.label)}`), width),
+            '',
+            (0, render_1.dim)('  any key closes this'),
+        ];
+    }
     return {
         ...host,
+        helpOpen: () => help,
         async handleKey(k) {
             if (!k)
                 return;
@@ -47,11 +75,23 @@ function createApp(root, hooks = {}) {
             }
             let capturing = false;
             try {
-                capturing = host.current().capturesKeys?.() === true;
+                capturing = top().screen.capturesKeys?.() === true;
             }
             catch {
                 capturing = false;
             }
+            // Help is a reference card, not a mode: any key dismisses it, and the
+            // keystroke is spent doing so rather than also acting on the screen.
+            if (help && !capturing) {
+                help = false;
+                host.redraw();
+                return;
+            }
+            if (!capturing && (k.name === '?' || k.sequence === '?')) {
+                help = true;
+                host.redraw();
+                return;
+            }
             if (k.name === 'q' && !capturing) {
                 if (stack.length > 1)
                     host.pop();
@@ -61,22 +101,51 @@ function createApp(root, hooks = {}) {
             }
             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}`)];
-            }
+        frame(width, height) {
             const footer = [];
             if (noteMsg)
                 footer.push('', noteMsg);
             if (error)
                 footer.push('', (0, render_1.dim)(`last error: ${error}`));
-            return [...body, ...footer];
+            const room = Math.max(1, height - footer.length);
+            let body;
+            if (help) {
+                body = helpLines(width);
+            }
+            else {
+                try {
+                    body = top().screen.render(width, room);
+                }
+                catch (err) {
+                    error = err.message;
+                    body = [(0, render_1.red)(`screen error: ${err.message}`)];
+                }
+            }
+            return [...body.slice(0, room), ...footer].slice(0, height);
+        },
+        duePoll(now) {
+            const entry = top();
+            let due = 5000;
+            try {
+                due = entry.screen.pollMs?.() ?? 5000;
+            }
+            catch {
+                due = 5000;
+            }
+            if (entry.lastPoll !== 0 && now - entry.lastPoll < due)
+                return null;
+            entry.lastPoll = now;
+            return entry.screen;
         },
         lastError: () => error,
     };
 }
+/** Screens build their footers with this so the grammar is identical
+ *  everywhere: dim, two-space indent, key then label. */
+function footerHint(hints) {
+    return (0, render_1.dim)('  ' + hints.map(h => `${h.keys} ${h.label}`).join('   '));
+}
+/** A screen heading: bold label with dim trailing detail. */
+function heading(label, detail) {
+    return `  ${(0, render_1.bold)(label)}${detail ? `  ${(0, render_1.dim)(detail)}` : ''}`;
+}

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

@@ -7,7 +7,12 @@ export interface ConsoleCapture {
     lines(): CapturedLog[];
     last(): CapturedLog | null;
     count(): number;
-    /** Restore the real console and replay everything captured. */
-    restoreAndReplay(): void;
+    /** Called on every captured line, so the UI can repaint a live log view. */
+    onLine(fn: (line: CapturedLog) => void): void;
+    /** Put the real console back. Does not replay: the lines are already on
+     *  disk, and 500 of them scrolling past on exit helps nobody. */
+    restore(): void;
 }
-export declare function captureConsole(): ConsoleCapture;
+export declare function captureConsole(opts?: {
+    logFile?: string;
+}): ConsoleCapture;