beecork 1.7.1 → 2.0.0

package/dist/projects/types.d.ts

@@ -1,19 +0,0 @@
-export interface Project {
-    id: string;
-    name: string;
-    path: string;
-    type: 'user-project' | 'category';
-    lastUsedAt: string;
-    createdAt: string;
-}
-export interface RouteDecision {
-    project: Project;
-    tabName: string;
-    isNewTab: boolean;
-    confidence: number;
-    needsConfirmation: boolean;
-    reason: string;
-}
-export interface RoutingContext {
-    userId?: string;
-}

package/dist/projects/types.js

@@ -1 +0,0 @@
-export {};

package/dist/service/install.d.ts

@@ -1,4 +0,0 @@
-export declare function installService(): string;
-export declare function uninstallService(): string;
-export declare function startService(): void;
-export declare function stopService(): void;

package/dist/service/install.js

@@ -1,146 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-import { getPlatform } from '../util/platform.js';
-import { ensureBeecorkDirs } from '../util/paths.js';
-import { getLaunchdPlist, getSystemdUnit, getLaunchdPlistPath, getSystemdUnitPath, } from './templates.js';
-import { installWindowsService, startWindowsService, stopWindowsService, uninstallWindowsService, } from './windows.js';
-function findNodePath() {
-    try {
-        const cmd = process.platform === 'win32' ? 'where node' : 'which node';
-        return execSync(cmd, { encoding: 'utf-8' }).trim().split(/\r?\n/)[0];
-    }
-    catch {
-        return process.platform === 'win32' ? 'node' : '/usr/local/bin/node';
-    }
-}
-function findDaemonPath() {
-    // import.meta.url is dist/service/install.js — daemon is at dist/daemon.js (one level up)
-    const thisFileUrl = new URL(import.meta.url);
-    const thisFile = process.platform === 'win32'
-        ? thisFileUrl.pathname.replace(/^\/([A-Za-z]:)/, '$1') // strip leading / on Windows drive paths
-        : thisFileUrl.pathname;
-    const distDir = path.dirname(path.dirname(thisFile)); // go up from service/ to dist/
-    const daemonPath = path.join(distDir, 'daemon.js');
-    if (fs.existsSync(daemonPath))
-        return daemonPath;
-    // Fallback: maybe we're in src/ during development
-    const srcDaemon = path.resolve(distDir, '..', 'dist', 'daemon.js');
-    if (fs.existsSync(srcDaemon))
-        return srcDaemon;
-    throw new Error('Could not find daemon.js. Make sure beecork is built (npm run build).');
-}
-export function installService() {
-    ensureBeecorkDirs();
-    const platform = getPlatform();
-    const nodePath = findNodePath();
-    const daemonPath = findDaemonPath();
-    if (platform === 'windows') {
-        installWindowsService(`${nodePath}" "${daemonPath}`);
-        return 'Windows Task Scheduler';
-    }
-    else if (platform === 'mac') {
-        return installLaunchd(nodePath, daemonPath);
-    }
-    else {
-        return installSystemd(nodePath, daemonPath);
-    }
-}
-export function uninstallService() {
-    const platform = getPlatform();
-    if (platform === 'windows') {
-        uninstallWindowsService();
-        return 'Windows Task Scheduler';
-    }
-    else if (platform === 'mac') {
-        return uninstallLaunchd();
-    }
-    else {
-        return uninstallSystemd();
-    }
-}
-export function startService() {
-    const platform = getPlatform();
-    if (platform === 'windows') {
-        startWindowsService();
-    }
-    else if (platform === 'mac') {
-        const plistPath = getLaunchdPlistPath();
-        execSync(`launchctl load "${plistPath}"`, { stdio: 'inherit' });
-    }
-    else {
-        execSync('systemctl --user start beecork', { stdio: 'inherit' });
-    }
-}
-export function stopService() {
-    const platform = getPlatform();
-    if (platform === 'windows') {
-        stopWindowsService();
-    }
-    else if (platform === 'mac') {
-        const plistPath = getLaunchdPlistPath();
-        try {
-            execSync(`launchctl unload "${plistPath}"`, { stdio: 'inherit' });
-        }
-        catch {
-            /* not loaded */
-        }
-    }
-    else {
-        try {
-            execSync('systemctl --user stop beecork', { stdio: 'inherit' });
-        }
-        catch {
-            /* not running */
-        }
-    }
-}
-function installLaunchd(nodePath, daemonPath) {
-    const plistPath = getLaunchdPlistPath();
-    const plistDir = path.dirname(plistPath);
-    fs.mkdirSync(plistDir, { recursive: true });
-    const content = getLaunchdPlist(nodePath, daemonPath);
-    fs.writeFileSync(plistPath, content);
-    return plistPath;
-}
-function uninstallLaunchd() {
-    const plistPath = getLaunchdPlistPath();
-    try {
-        execSync(`launchctl unload "${plistPath}"`, { stdio: 'pipe' });
-    }
-    catch {
-        /* ok */
-    }
-    if (fs.existsSync(plistPath))
-        fs.unlinkSync(plistPath);
-    return plistPath;
-}
-function installSystemd(nodePath, daemonPath) {
-    const unitPath = getSystemdUnitPath();
-    const unitDir = path.dirname(unitPath);
-    fs.mkdirSync(unitDir, { recursive: true });
-    const content = getSystemdUnit(nodePath, daemonPath);
-    fs.writeFileSync(unitPath, content);
-    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
-    execSync('systemctl --user enable beecork', { stdio: 'pipe' });
-    return unitPath;
-}
-function uninstallSystemd() {
-    const unitPath = getSystemdUnitPath();
-    try {
-        execSync('systemctl --user disable beecork', { stdio: 'pipe' });
-    }
-    catch {
-        /* ok */
-    }
-    try {
-        execSync('systemctl --user stop beecork', { stdio: 'pipe' });
-    }
-    catch {
-        /* ok */
-    }
-    if (fs.existsSync(unitPath))
-        fs.unlinkSync(unitPath);
-    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
-    return unitPath;
-}

package/dist/service/templates.d.ts

@@ -1,4 +0,0 @@
-export declare function getLaunchdPlist(nodePath: string, daemonPath: string): string;
-export declare function getSystemdUnit(nodePath: string, daemonPath: string): string;
-export declare function getLaunchdPlistPath(): string;
-export declare function getSystemdUnitPath(): string;

package/dist/service/templates.js

@@ -1,52 +0,0 @@
-import os from 'node:os';
-export function getLaunchdPlist(nodePath, daemonPath) {
-    const home = os.homedir();
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>com.beecork.daemon</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>${nodePath}</string>
-        <string>${daemonPath}</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>StandardOutPath</key>
-    <string>${home}/.beecork/logs/daemon.stdout.log</string>
-    <key>StandardErrorPath</key>
-    <string>${home}/.beecork/logs/daemon.stderr.log</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin:${home}/.local/bin:${home}/.nvm/versions/node/current/bin</string>
-        <key>HOME</key>
-        <string>${home}</string>
-    </dict>
-</dict>
-</plist>`;
-}
-export function getSystemdUnit(nodePath, daemonPath) {
-    return `[Unit]
-Description=Beecork - Claude Code always-on infrastructure
-After=network.target
-
-[Service]
-ExecStart=${nodePath} ${daemonPath}
-Restart=always
-RestartSec=5
-Environment=PATH=/usr/local/bin:/usr/bin:/bin:%h/.local/bin
-
-[Install]
-WantedBy=default.target`;
-}
-export function getLaunchdPlistPath() {
-    return `${os.homedir()}/Library/LaunchAgents/com.beecork.daemon.plist`;
-}
-export function getSystemdUnitPath() {
-    return `${os.homedir()}/.config/systemd/user/beecork.service`;
-}

package/dist/service/windows.d.ts

@@ -1,8 +0,0 @@
-/** Install Beecork as a Windows Task Scheduler task */
-export declare function installWindowsService(binPath: string): void;
-/** Start the Windows service */
-export declare function startWindowsService(): void;
-/** Stop the Windows service */
-export declare function stopWindowsService(): void;
-/** Uninstall the Windows service */
-export declare function uninstallWindowsService(): void;

package/dist/service/windows.js

@@ -1,59 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execSync } from 'node:child_process';
-const TASK_NAME = 'BeecorkDaemon';
-/** Install Beecork as a Windows Task Scheduler task */
-export function installWindowsService(binPath) {
-    const appData = process.env.APPDATA || path.join(process.env.USERPROFILE || '', 'AppData', 'Roaming');
-    const logPath = path.join(appData, '.beecork', 'logs', 'daemon.log');
-    // Ensure log directory exists
-    fs.mkdirSync(path.dirname(logPath), { recursive: true });
-    // Create a wrapper script that runs beecork daemon
-    const wrapperPath = path.join(appData, '.beecork', 'start-daemon.bat');
-    fs.writeFileSync(wrapperPath, `@echo off\r\n"${binPath}" daemon >> "${logPath}" 2>&1\r\n`);
-    try {
-        // Remove existing task if any
-        execSync(`schtasks /Delete /TN "${TASK_NAME}" /F 2>nul`, { stdio: 'ignore' });
-    }
-    catch { }
-    // Create scheduled task that runs at logon
-    execSync(`schtasks /Create /TN "${TASK_NAME}" /TR "${wrapperPath}" /SC ONLOGON /RL HIGHEST /F`, {
-        stdio: 'inherit',
-    });
-    console.log(`Windows service installed: ${TASK_NAME}`);
-    console.log('The daemon will start automatically when you log in.');
-}
-/** Start the Windows service */
-export function startWindowsService() {
-    try {
-        execSync(`schtasks /Run /TN "${TASK_NAME}"`, { stdio: 'inherit' });
-        console.log('Beecork daemon started.');
-    }
-    catch {
-        console.error('Failed to start. Run manually: beecork daemon');
-    }
-}
-/** Stop the Windows service */
-export function stopWindowsService() {
-    try {
-        execSync(`schtasks /End /TN "${TASK_NAME}"`, { stdio: 'inherit' });
-        console.log('Beecork daemon stopped.');
-    }
-    catch {
-        // Try killing the process directly
-        try {
-            execSync('taskkill /F /IM node.exe /FI "WINDOWTITLE eq beecork*"', { stdio: 'ignore' });
-        }
-        catch { }
-    }
-}
-/** Uninstall the Windows service */
-export function uninstallWindowsService() {
-    try {
-        execSync(`schtasks /Delete /TN "${TASK_NAME}" /F`, { stdio: 'inherit' });
-        console.log('Beecork service uninstalled.');
-    }
-    catch {
-        console.error('Failed to uninstall service.');
-    }
-}

package/dist/session/budget-guard.d.ts

@@ -1,20 +0,0 @@
-/**
- * Per-tab spend budget enforcement, extracted from TabManager.
- *
- * Pure function (with a tiny stateful wrapper) so it can be unit-tested without
- * a database or a running subprocess: feed in current spend + tab name, get a
- * decision back. The caller (TabManager.executeMessage) handles the side
- * effects (notify + early return).
- */
-export interface BudgetDecision {
-    allowed: boolean;
-    /** When allowed=false, the message to surface to the caller. */
-    reason?: string;
-    /** When the tab has crossed the 80% threshold, the warning text to notify. */
-    warning?: string;
-}
-export declare class BudgetGuard {
-    private maxBudgetUsd;
-    constructor(maxBudgetUsd: number | undefined);
-    check(currentSpend: number, tabName: string): BudgetDecision;
-}

package/dist/session/budget-guard.js

@@ -1,31 +0,0 @@
-/**
- * Per-tab spend budget enforcement, extracted from TabManager.
- *
- * Pure function (with a tiny stateful wrapper) so it can be unit-tested without
- * a database or a running subprocess: feed in current spend + tab name, get a
- * decision back. The caller (TabManager.executeMessage) handles the side
- * effects (notify + early return).
- */
-export class BudgetGuard {
-    maxBudgetUsd;
-    constructor(maxBudgetUsd) {
-        this.maxBudgetUsd = maxBudgetUsd;
-    }
-    check(currentSpend, tabName) {
-        if (!this.maxBudgetUsd)
-            return { allowed: true };
-        if (currentSpend >= this.maxBudgetUsd) {
-            return {
-                allowed: false,
-                reason: `Budget limit reached for tab "${tabName}": $${currentSpend.toFixed(2)} / $${this.maxBudgetUsd.toFixed(2)}`,
-            };
-        }
-        if (currentSpend >= this.maxBudgetUsd * 0.8) {
-            return {
-                allowed: true,
-                warning: `⚠️ Budget warning: tab "${tabName}" at $${currentSpend.toFixed(2)} / $${this.maxBudgetUsd.toFixed(2)} (80%)`,
-            };
-        }
-        return { allowed: true };
-    }
-}

package/dist/session/circuit-breaker.d.ts

@@ -1,19 +0,0 @@
-import type { CircuitBreakerConfig, StreamContentToolUse } from '../types.js';
-export type CircuitBreakerAction = 'ok' | 'warn' | 'notify' | 'break';
-export declare class CircuitBreaker {
-    private tabName;
-    private ring;
-    private ringHead;
-    private ringSize;
-    private config;
-    private tripped;
-    private warned;
-    private notified;
-    private readonly WARN_THRESHOLD;
-    private readonly NOTIFY_THRESHOLD;
-    constructor(tabName: string, config?: Partial<CircuitBreakerConfig>);
-    /** Record a tool call. Returns the action to take. */
-    recordToolCall(toolUse: StreamContentToolUse): CircuitBreakerAction;
-    reset(): void;
-    get isTripped(): boolean;
-}

package/dist/session/circuit-breaker.js

@@ -1,91 +0,0 @@
-import { logger } from '../util/logger.js';
-const DEFAULT_CONFIG = {
-    maxRepeats: 20,
-    windowSize: 30,
-};
-/**
- * Detects loops in claude tool-use streams using consecutive-identical-call
- * counting. The signature is a hash of the tool name + input — JSON.stringify
- * would be O(input-size) per call and a 50KB Write tool input would allocate
- * 50KB just to compare equality, so we use a quick-hash strategy that's
- * length-independent.
- */
-function hashSignature(toolUse) {
-    // FNV-1a 32-bit hash of the JSON repr — fast, collision-rare for short inputs.
-    // For correctness we only need equality (was this the same call as before),
-    // not reversibility, so a hash is sufficient.
-    const s = `${toolUse.name}:${JSON.stringify(toolUse.input)}`;
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) {
-        h ^= s.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return `${toolUse.name}#${(h >>> 0).toString(36)}`;
-}
-export class CircuitBreaker {
-    tabName;
-    // Ring buffer to avoid per-call array reslice
-    ring;
-    ringHead = 0;
-    ringSize = 0;
-    config;
-    tripped = false;
-    warned = false;
-    notified = false;
-    WARN_THRESHOLD = 5;
-    NOTIFY_THRESHOLD = 10;
-    constructor(tabName, config) {
-        this.tabName = tabName;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.ring = new Array(this.config.windowSize);
-    }
-    /** Record a tool call. Returns the action to take. */
-    recordToolCall(toolUse) {
-        if (this.tripped)
-            return 'break';
-        const signature = hashSignature(toolUse);
-        this.ring[this.ringHead] = signature;
-        this.ringHead = (this.ringHead + 1) % this.config.windowSize;
-        if (this.ringSize < this.config.windowSize)
-            this.ringSize++;
-        // Count consecutive identical signatures walking backwards from the last
-        // write. (ringHead points at the NEXT slot, so the most-recent is head-1.)
-        let repeatCount = 0;
-        for (let i = 0; i < this.ringSize; i++) {
-            const idx = (this.ringHead - 1 - i + this.config.windowSize) % this.config.windowSize;
-            if (this.ring[idx] === signature) {
-                repeatCount++;
-            }
-            else {
-                break;
-            }
-        }
-        if (repeatCount >= this.config.maxRepeats) {
-            logger.warn(`[${this.tabName}] Circuit breaker tripped: ${toolUse.name} repeated ${repeatCount} times`);
-            this.tripped = true;
-            return 'break';
-        }
-        if (repeatCount >= this.NOTIFY_THRESHOLD && !this.notified) {
-            logger.warn(`[${this.tabName}] Loop detected: ${toolUse.name} repeated ${repeatCount} times — notifying user`);
-            this.notified = true;
-            return 'notify';
-        }
-        if (repeatCount >= this.WARN_THRESHOLD && !this.warned) {
-            logger.info(`[${this.tabName}] Loop detected: ${toolUse.name} repeated ${repeatCount} times — warning`);
-            this.warned = true;
-            return 'warn';
-        }
-        return 'ok';
-    }
-    reset() {
-        this.ring.fill(undefined);
-        this.ringHead = 0;
-        this.ringSize = 0;
-        this.tripped = false;
-        this.warned = false;
-        this.notified = false;
-    }
-    get isTripped() {
-        return this.tripped;
-    }
-}

package/dist/session/context-compactor.d.ts

@@ -1,32 +0,0 @@
-/**
- * Context-window compaction: when Claude's context fills, summarize the
- * conversation, rotate to a fresh session, and continue with the summary as
- * the new system seed.
- *
- * Extracted from TabManager.executeMessage. Owns the recursion-depth limit
- * (MAX_DEPTH = 2) and the "fall back to original result" failure mode so
- * compaction errors degrade gracefully instead of orphaning the message.
- */
-import type Database from 'better-sqlite3';
-import type { SendResult } from './manager.js';
-import type { Tab } from '../types.js';
-export type NotifyFn = ((text: string) => Promise<void>) | null;
-export interface SendMessageFn {
-    (tabName: string, prompt: string, options?: {
-        onTextChunk?: (text: string) => void;
-        _compactionDepth?: number;
-    }): Promise<SendResult>;
-}
-export declare const ContextCompactor: {
-    MAX_DEPTH: number;
-    /**
-     * Compact and continue the session. Returns the continuation result if
-     * compaction succeeds, or the original result if anything goes wrong so the
-     * user always gets *something* back.
-     *
-     * Important: callers should always run `processNextInQueue` (or equivalent)
-     * after this resolves regardless of which path it took — the queue drain
-     * obligation does not depend on compaction success.
-     */
-    compact(tab: Tab, enrichedPrompt: string, originalResult: SendResult, onTextChunk: ((text: string) => void) | undefined, currentDepth: number, sendMessage: SendMessageFn, notify: NotifyFn, db: Database.Database): Promise<SendResult>;
-};

package/dist/session/context-compactor.js

@@ -1,45 +0,0 @@
-/**
- * Context-window compaction: when Claude's context fills, summarize the
- * conversation, rotate to a fresh session, and continue with the summary as
- * the new system seed.
- *
- * Extracted from TabManager.executeMessage. Owns the recursion-depth limit
- * (MAX_DEPTH = 2) and the "fall back to original result" failure mode so
- * compaction errors degrade gracefully instead of orphaning the message.
- */
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../util/logger.js';
-export const ContextCompactor = {
-    MAX_DEPTH: 2,
-    /**
-     * Compact and continue the session. Returns the continuation result if
-     * compaction succeeds, or the original result if anything goes wrong so the
-     * user always gets *something* back.
-     *
-     * Important: callers should always run `processNextInQueue` (or equivalent)
-     * after this resolves regardless of which path it took — the queue drain
-     * obligation does not depend on compaction success.
-     */
-    async compact(tab, enrichedPrompt, originalResult, onTextChunk, currentDepth, sendMessage, notify, db) {
-        logger.info(`[${tab.name}] Compacting context (depth ${currentDepth + 1}/${ContextCompactor.MAX_DEPTH}) — requesting summary then restarting session`);
-        notify?.(`🔄 [${tab.name}] Context window full — compacting and continuing...`).catch((err) => logger.warn('Notify failed:', err));
-        try {
-            const summaryPrompt = 'Summarize your progress in this session concisely: completed steps, current state, remaining steps, and all important identifiers (file paths, URLs, variable names). Output ONLY the summary.';
-            const summaryResult = await sendMessage(tab.name, summaryPrompt, {
-                _compactionDepth: currentDepth + 1,
-            });
-            const newSessionId = uuidv4();
-            db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?').run(newSessionId, tab.id);
-            logger.info(`[${tab.name}] Context compacted — new session ${newSessionId.slice(0, 8)}...`);
-            const continuationPrompt = `[CONTEXT RESTORED FROM PREVIOUS SESSION]\n${summaryResult.text}\n\n[Continue the original task: "${enrichedPrompt.slice(0, 500)}"]`;
-            return await sendMessage(tab.name, continuationPrompt, {
-                onTextChunk,
-                _compactionDepth: currentDepth + 1,
-            });
-        }
-        catch (err) {
-            logger.error(`[${tab.name}] Compaction failed:`, err);
-            return originalResult;
-        }
-    },
-};

package/dist/session/context-monitor.d.ts

@@ -1,15 +0,0 @@
-import type { StreamUsage } from '../types.js';
-export type ContextAction = 'ok' | 'warn' | 'checkpoint';
-export declare class ContextMonitor {
-    private tabName;
-    private cumulativeTokens;
-    private contextWindow;
-    private warned;
-    private checkpointed;
-    constructor(tabName: string, contextWindow?: number);
-    /** Record token usage from a StreamAssistant or StreamResult event. Returns action needed. */
-    recordUsage(usage: StreamUsage): ContextAction;
-    get tokenCount(): number;
-    get usageRatio(): number;
-    reset(): void;
-}

package/dist/session/context-monitor.js

@@ -1,44 +0,0 @@
-import { logger } from '../util/logger.js';
-const DEFAULT_CONTEXT_WINDOW = 200_000; // Claude's context window in tokens
-const WARNING_THRESHOLD = 0.8;
-const CHECKPOINT_THRESHOLD = 0.9;
-export class ContextMonitor {
-    tabName;
-    cumulativeTokens = 0;
-    contextWindow;
-    warned = false;
-    checkpointed = false;
-    constructor(tabName, contextWindow = DEFAULT_CONTEXT_WINDOW) {
-        this.tabName = tabName;
-        this.contextWindow = contextWindow;
-    }
-    /** Record token usage from a StreamAssistant or StreamResult event. Returns action needed. */
-    recordUsage(usage) {
-        // Only count input_tokens — this already includes cached tokens.
-        // output_tokens don't consume context window; cache subtypes are part of input_tokens.
-        this.cumulativeTokens += usage.input_tokens;
-        const ratio = this.cumulativeTokens / this.contextWindow;
-        if (ratio >= CHECKPOINT_THRESHOLD && !this.checkpointed) {
-            this.checkpointed = true;
-            logger.warn(`[${this.tabName}] Context at ${Math.round(ratio * 100)}% — checkpoint needed`);
-            return 'checkpoint';
-        }
-        if (ratio >= WARNING_THRESHOLD && !this.warned) {
-            this.warned = true;
-            logger.info(`[${this.tabName}] Context at ${Math.round(ratio * 100)}% — warning`);
-            return 'warn';
-        }
-        return 'ok';
-    }
-    get tokenCount() {
-        return this.cumulativeTokens;
-    }
-    get usageRatio() {
-        return this.cumulativeTokens / this.contextWindow;
-    }
-    reset() {
-        this.cumulativeTokens = 0;
-        this.warned = false;
-        this.checkpointed = false;
-    }
-}

package/dist/session/handoff.d.ts

@@ -1,21 +0,0 @@
-/**
- * Session handoff helpers — used by both the CLI (`beecork attach`) and the
- * shared command handler (`/handoff` from any channel).
- *
- * Moved here from `cli/handoff.ts` so daemon-shared code (channels, MCP) can
- * import without reaching into the CLI layer. The CLI-specific `attachTab`
- * (which spawns claude and calls process.exit) stays in `cli/handoff.ts`.
- */
-export interface TabHandoffInfo {
-    name: string;
-    sessionId: string;
-    workingDir: string;
-    status: string;
-    lastActivity: string;
-    recentMessages: Array<{
-        role: string;
-        content: string;
-    }>;
-}
-export declare function exportTab(tabName: string): TabHandoffInfo | null;
-export declare function formatHandoffInfo(info: TabHandoffInfo): string;