beecork 1.7.0 → 2.0.0

package/dist/session/pending-dispatcher.js

@@ -1,120 +0,0 @@
-/**
- * Polls `pending_messages` and dispatches each row by type.
- *
- * Replaces the inline `processPendingMessages` block that previously lived in
- * TabManager. Two functional changes from that code:
- *
- *  1. Claim-before-dispatch (status='processing' set atomically before send).
- *     The original poll-every-5s code re-picked the same row on every tick
- *     while its dispatch was in flight — long Claude runs could re-fire the
- *     same prompt many times.
- *
- *  2. Branch on type. The original consumer only recognized 'notification' and
- *     fell through to "send as plain user prompt" for everything else, which
- *     meant `type='media'` rows were handed to Claude as raw JSON and never
- *     actually delivered to channels.
- */
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-import { PendingMessageStore } from './pending-store.js';
-const POLL_LIMIT = 50;
-const CLEANUP_EVERY_N_TICKS = 100;
-export class PendingMessageDispatcher {
-    tabManager;
-    channels;
-    onNotify;
-    pollCount = 0;
-    constructor(tabManager, channels, onNotify) {
-        this.tabManager = tabManager;
-        this.channels = channels;
-        this.onNotify = onNotify;
-    }
-    /** Reset any rows stuck in 'processing' from a previous daemon run. */
-    recoverOnStart() {
-        PendingMessageStore.recoverProcessing();
-    }
-    /** Called on every daemon poll tick. */
-    tick() {
-        const db = getDb();
-        this.pollCount++;
-        if (this.pollCount % CLEANUP_EVERY_N_TICKS === 0) {
-            db.prepare("DELETE FROM pending_messages WHERE (status = 'done' OR status = 'failed') AND created_at < datetime('now', '-1 day')").run();
-        }
-        const claimed = PendingMessageStore.claimBatch(POLL_LIMIT, db);
-        for (const row of claimed) {
-            // Fire-and-forget per row — the row is already marked 'processing' so
-            // the next tick won't double-dispatch. The .finally() handles the
-            // terminal transition.
-            void this.dispatch(row);
-        }
-    }
-    async dispatch(row) {
-        try {
-            switch (row.type) {
-                case 'notification':
-                    await this.onNotify?.(row.message);
-                    break;
-                case 'media': {
-                    const payload = PendingMessageStore.parseMediaPayload(row.message);
-                    if (!payload) {
-                        logger.warn(`Pending media row ${row.id} has malformed payload, skipping`);
-                        break;
-                    }
-                    const attachment = inferAttachmentType(payload.filePath, payload.caption);
-                    await this.channels.broadcastMedia(attachment);
-                    break;
-                }
-                case 'user':
-                case 'delegation':
-                case 'delegation_result':
-                case 'replay': {
-                    if (!row.tabName) {
-                        logger.warn(`Pending row ${row.id} (type=${row.type}) has no tab_name, skipping`);
-                        break;
-                    }
-                    await this.tabManager.sendMessage(row.tabName, row.message);
-                    break;
-                }
-                default: {
-                    // Unknown discriminant — log and bail rather than fall through to
-                    // "send as a plain prompt" (which is how H5 ended up shipping).
-                    logger.warn(`Pending row ${row.id} has unknown type "${row.type}", marking failed`);
-                    PendingMessageStore.markFailed(row.id);
-                    return;
-                }
-            }
-            PendingMessageStore.markDone(row.id);
-        }
-        catch (err) {
-            logger.error(`Failed to process pending message ${row.id} (type=${row.type}):`, err);
-            await this.onNotify?.(`Pending message ${row.type === 'notification' ? '' : `for tab "${row.tabName}"`} failed: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
-            PendingMessageStore.markFailed(row.id);
-        }
-    }
-}
-/**
- * Heuristic: derive a MediaAttachment from a file path so the channel's
- * broadcastMedia knows whether to send as voice / image / video / document.
- */
-function inferAttachmentType(filePath, caption) {
-    const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
-    let type = 'document';
-    let mimeType = 'application/octet-stream';
-    if (['png', 'jpg', 'jpeg', 'gif', 'webp'].includes(ext)) {
-        type = 'image';
-        mimeType = `image/${ext === 'jpg' ? 'jpeg' : ext}`;
-    }
-    else if (['mp4', 'mov', 'webm', 'mkv'].includes(ext)) {
-        type = 'video';
-        mimeType = `video/${ext === 'mov' ? 'quicktime' : ext}`;
-    }
-    else if (['ogg', 'opus', 'oga'].includes(ext)) {
-        type = 'voice';
-        mimeType = 'audio/ogg';
-    }
-    else if (['mp3', 'm4a', 'wav', 'flac', 'aac'].includes(ext)) {
-        type = 'audio';
-        mimeType = `audio/${ext}`;
-    }
-    return { type, mimeType, filePath, caption };
-}

package/dist/session/pending-store.d.ts

@@ -1,60 +0,0 @@
-/**
- * Inter-process IPC store for the `pending_messages` table.
- *
- * Beecork uses this table as a shared queue between writers (MCP handlers,
- * dashboard routes, watchers, delegations) and the daemon's poll loop. Before
- * this module the writes were inline `INSERT INTO pending_messages` calls
- * scattered across nine sites; the consumer in TabManager only branched on
- * type='notification' which meant every other type fell through to "send as
- * a plain user prompt" — including `type='media'` rows whose JSON envelope
- * was being handed to Claude as text instead of being rendered.
- *
- * This store owns:
- *   - the typed envelope (`PendingMessageType` union, no more magic strings)
- *   - 3-state status (`pending` → `processing` → `done|failed`) so the 5s
- *     poll loop doesn't re-dispatch long-running rows
- *   - the `_notify` sentinel removal (notifications now use type alone,
- *     tab_name is nullable)
- *   - claim/recover semantics so a daemon crash mid-dispatch resets in-flight
- *     rows back to pending after a 30-minute timeout
- */
-import type Database from 'better-sqlite3';
-export type PendingMessageType = 'user' | 'notification' | 'media' | 'delegation' | 'delegation_result' | 'replay';
-export interface PendingRow {
-    id: number;
-    tabName: string | null;
-    message: string;
-    type: PendingMessageType;
-    status: 'pending' | 'processing' | 'done' | 'failed';
-    createdAt: string;
-}
-interface MediaPayload {
-    type: 'media';
-    filePath: string;
-    caption?: string;
-}
-export declare const PendingMessageStore: {
-    enqueueUser(tabName: string, message: string, db?: Database.Database): void;
-    enqueueNotification(message: string, db?: Database.Database): void;
-    enqueueMedia(tabName: string, payload: MediaPayload, db?: Database.Database): void;
-    enqueueDelegation(tabName: string, message: string, db?: Database.Database): void;
-    enqueueDelegationResult(tabName: string, message: string, db?: Database.Database): void;
-    enqueueReplay(tabName: string, message: string, db?: Database.Database): void;
-    /**
-     * Claim up to `limit` pending rows atomically. The rows are flipped to
-     * status='processing' inside a transaction so a second poll tick can't pick
-     * them up. Returns the claimed rows.
-     */
-    claimBatch(limit: number, db?: Database.Database): PendingRow[];
-    markDone(id: number, db?: Database.Database): void;
-    markFailed(id: number, db?: Database.Database): void;
-    /**
-     * Reset stuck `processing` rows back to `pending`. Run at daemon startup so
-     * a crash mid-dispatch doesn't leave rows permanently in-flight. The 30min
-     * window is well beyond the 30min subprocess runtime cap.
-     */
-    recoverProcessing(db?: Database.Database): number;
-    /** Parse a media row's message JSON. Returns null on malformed JSON. */
-    parseMediaPayload(message: string): MediaPayload | null;
-};
-export {};

package/dist/session/pending-store.js

@@ -1,118 +0,0 @@
-/**
- * Inter-process IPC store for the `pending_messages` table.
- *
- * Beecork uses this table as a shared queue between writers (MCP handlers,
- * dashboard routes, watchers, delegations) and the daemon's poll loop. Before
- * this module the writes were inline `INSERT INTO pending_messages` calls
- * scattered across nine sites; the consumer in TabManager only branched on
- * type='notification' which meant every other type fell through to "send as
- * a plain user prompt" — including `type='media'` rows whose JSON envelope
- * was being handed to Claude as text instead of being rendered.
- *
- * This store owns:
- *   - the typed envelope (`PendingMessageType` union, no more magic strings)
- *   - 3-state status (`pending` → `processing` → `done|failed`) so the 5s
- *     poll loop doesn't re-dispatch long-running rows
- *   - the `_notify` sentinel removal (notifications now use type alone,
- *     tab_name is nullable)
- *   - claim/recover semantics so a daemon crash mid-dispatch resets in-flight
- *     rows back to pending after a 30-minute timeout
- */
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-function rowToPending(r) {
-    return {
-        id: r.id,
-        tabName: r.tab_name,
-        message: r.message,
-        type: r.type || 'user',
-        status: r.status || 'pending',
-        createdAt: r.created_at,
-    };
-}
-const STALE_PROCESSING_MS = 30 * 60 * 1000; // 30 minutes
-// Private INSERT helper — all five enqueue* methods were the same INSERT with
-// different literals. Notification rows use '' for tab_name since the consumer
-// branches on type rather than reading the tab.
-function insertPending(db, tabName, message, type) {
-    db.prepare('INSERT INTO pending_messages (tab_name, message, type, status) VALUES (?, ?, ?, ?)').run(tabName, message, type, 'pending');
-}
-export const PendingMessageStore = {
-    enqueueUser(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'user');
-    },
-    enqueueNotification(message, db = getDb()) {
-        insertPending(db, '', message, 'notification');
-    },
-    enqueueMedia(tabName, payload, db = getDb()) {
-        insertPending(db, tabName, JSON.stringify(payload), 'media');
-    },
-    enqueueDelegation(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'delegation');
-    },
-    enqueueDelegationResult(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'delegation_result');
-    },
-    enqueueReplay(tabName, message, db = getDb()) {
-        insertPending(db, tabName, message, 'replay');
-    },
-    /**
-     * Claim up to `limit` pending rows atomically. The rows are flipped to
-     * status='processing' inside a transaction so a second poll tick can't pick
-     * them up. Returns the claimed rows.
-     */
-    claimBatch(limit, db = getDb()) {
-        const claim = db.transaction((max) => {
-            const rows = db
-                .prepare("SELECT id, tab_name, message, type, status, created_at FROM pending_messages WHERE status = 'pending' ORDER BY created_at ASC LIMIT ?")
-                .all(max);
-            if (rows.length === 0)
-                return [];
-            const stmt = db.prepare("UPDATE pending_messages SET status = 'processing' WHERE id = ? AND status = 'pending'");
-            const claimed = [];
-            for (const r of rows) {
-                const result = stmt.run(r.id);
-                if (result.changes > 0)
-                    claimed.push(rowToPending(r));
-            }
-            return claimed;
-        });
-        return claim(limit);
-    },
-    markDone(id, db = getDb()) {
-        db.prepare("UPDATE pending_messages SET status = 'done', processed = 1 WHERE id = ?").run(id);
-    },
-    markFailed(id, db = getDb()) {
-        // 'failed' rows are kept for diagnostics until the periodic cleanup sweeps
-        // them. They are NOT re-dispatched — preserves the original "no infinite
-        // retries" policy while keeping the row visible for postmortem queries.
-        db.prepare("UPDATE pending_messages SET status = 'failed', processed = 1 WHERE id = ?").run(id);
-    },
-    /**
-     * Reset stuck `processing` rows back to `pending`. Run at daemon startup so
-     * a crash mid-dispatch doesn't leave rows permanently in-flight. The 30min
-     * window is well beyond the 30min subprocess runtime cap.
-     */
-    recoverProcessing(db = getDb()) {
-        const result = db
-            .prepare(`UPDATE pending_messages SET status = 'pending'
-       WHERE status = 'processing' AND created_at < datetime('now', '-' || ? || ' seconds')`)
-            .run(Math.floor(STALE_PROCESSING_MS / 1000));
-        if (result.changes > 0) {
-            logger.warn(`Recovered ${result.changes} stuck pending_messages rows from 'processing' state`);
-        }
-        return result.changes;
-    },
-    /** Parse a media row's message JSON. Returns null on malformed JSON. */
-    parseMediaPayload(message) {
-        try {
-            const parsed = JSON.parse(message);
-            if (parsed?.type === 'media' && typeof parsed.filePath === 'string')
-                return parsed;
-            return null;
-        }
-        catch {
-            return null;
-        }
-    },
-};

package/dist/session/stale-session.d.ts

@@ -1,31 +0,0 @@
-/**
- * Detection + recovery for "Claude Code session not found / expired" errors.
- *
- * Extracted from TabManager.executeMessage so the two responsibilities
- * (recognize the symptom, build the recovery prompt) live in one focused
- * module instead of tangled inline with the subprocess callbacks.
- */
-import type Database from 'better-sqlite3';
-import type { StreamResult } from '../types.js';
-import type { SendResult } from './manager.js';
-export interface StaleSessionRecovery {
-    newSessionId: string;
-    /** A prompt that wraps the original enrichedPrompt with the last few messages
-     * for context, since Claude Code lost the session and won't have any. */
-    contextPrompt: string;
-}
-export declare const StaleSessionDetector: {
-    /**
-     * Was this result an "I can't resume that session" failure?
-     *
-     * Covers both the legacy text-based error and the modern
-     * `error_during_execution` event shape.
-     */
-    isStale(result: SendResult, resultEvent: StreamResult | null, shouldResume: boolean, retryDepth: number): boolean;
-    /**
-     * Build a recovery prompt seeded with the tab's last 5 messages as context,
-     * and allocate a fresh session ID. Caller is responsible for updating the
-     * tab's session_id in the DB before retrying.
-     */
-    buildRecovery(tabId: string, enrichedPrompt: string, db: Database.Database): StaleSessionRecovery;
-};

package/dist/session/stale-session.js

@@ -1,45 +0,0 @@
-/**
- * Detection + recovery for "Claude Code session not found / expired" errors.
- *
- * Extracted from TabManager.executeMessage so the two responsibilities
- * (recognize the symptom, build the recovery prompt) live in one focused
- * module instead of tangled inline with the subprocess callbacks.
- */
-import { v4 as uuidv4 } from 'uuid';
-export const StaleSessionDetector = {
-    /**
-     * Was this result an "I can't resume that session" failure?
-     *
-     * Covers both the legacy text-based error and the modern
-     * `error_during_execution` event shape.
-     */
-    isStale(result, resultEvent, shouldResume, retryDepth) {
-        if (!result.error || !shouldResume || retryDepth !== 0)
-            return false;
-        if (/session (not found|expired|invalid)/i.test(result.text))
-            return true;
-        if (resultEvent?.subtype === 'error_during_execution' &&
-            resultEvent.errors?.some((e) => /no conversation found|session.*not found|session.*expired|session.*invalid/i.test(e))) {
-            return true;
-        }
-        return false;
-    },
-    /**
-     * Build a recovery prompt seeded with the tab's last 5 messages as context,
-     * and allocate a fresh session ID. Caller is responsible for updating the
-     * tab's session_id in the DB before retrying.
-     */
-    buildRecovery(tabId, enrichedPrompt, db) {
-        const recentMsgs = db
-            .prepare("SELECT role, content FROM messages WHERE tab_id = ? AND content != '' ORDER BY created_at DESC LIMIT 5")
-            .all(tabId);
-        const context = recentMsgs
-            .reverse()
-            .map((m) => `${m.role}: ${m.content.slice(0, 200)}`)
-            .join('\n');
-        const contextPrompt = context
-            ? `[Previous conversation context:\n${context}\n]\n\n${enrichedPrompt}`
-            : enrichedPrompt;
-        return { newSessionId: uuidv4(), contextPrompt };
-    },
-};

package/dist/session/subprocess.d.ts

@@ -1,25 +0,0 @@
-import type { BeecorkConfig, StreamEvent } from '../types.js';
-/** Test-only — reset the existsSync cache between test runs that toggle the mock. */
-export declare function _resetMcpConfigExistsCacheForTests(): void;
-export interface SubprocessCallbacks {
-    onEvent: (event: StreamEvent) => void;
-    onExit: (code: number | null) => void;
-    onError: (err: Error) => void;
-}
-export declare class ClaudeSubprocess {
-    private tabName;
-    private workingDir;
-    private config;
-    private tabSystemPrompt?;
-    private proc;
-    private buffer;
-    private killTimer;
-    private runtimeTimer;
-    readonly sessionId: string;
-    constructor(tabName: string, workingDir: string, config: BeecorkConfig, sessionId?: string, tabSystemPrompt?: string | null | undefined);
-    send(prompt: string, callbacks: SubprocessCallbacks, resume?: boolean): Promise<void>;
-    kill(): void;
-    get isRunning(): boolean;
-    get pid(): number | null;
-    private buildArgs;
-}

package/dist/session/subprocess.js

@@ -1,189 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../util/logger.js';
-import { getMcpConfigPath } from '../util/paths.js';
-// Cache the MCP-config existence check. The file is created at setup time and
-// stable for the daemon's lifetime; we don't need to stat() it per spawn.
-let mcpConfigExistsCache = null;
-function mcpConfigExists() {
-    if (mcpConfigExistsCache !== null)
-        return mcpConfigExistsCache;
-    mcpConfigExistsCache = fs.existsSync(getMcpConfigPath());
-    return mcpConfigExistsCache;
-}
-/** Test-only — reset the existsSync cache between test runs that toggle the mock. */
-export function _resetMcpConfigExistsCacheForTests() {
-    mcpConfigExistsCache = null;
-}
-const BEECORK_SYSTEM_PROMPT = `You are running inside Beecork, an always-on infrastructure for Claude Code.
-
-You have these special MCP tools available:
-- beecork_remember: Store important facts for future sessions (preferences, server addresses, decisions, outcomes)
-- beecork_recall: Search stored memories — ALWAYS call this at the start of complex tasks
-- beecork_task_create: Schedule recurring tasks (types: "at" for one-time, "every" for interval like "30m", "cron" for expressions like "0 9 * * 1")
-- beecork_task_list: List scheduled tasks
-- beecork_task_delete: Remove a scheduled task
-- beecork_tab_create: Create a new virtual tab for parallel work
-- beecork_tab_list: List all tabs
-- beecork_send_message: Send a message to another tab
-- beecork_notify: Send the user a notification mid-task without stopping
-- beecork_status: Check system status
-
-Guidelines:
-- You are running unattended. Be thorough and complete tasks fully.
-- Always call beecork_recall at the start of any task to check relevant memories.
-- Always call beecork_remember when you learn something important.
-- When asked for recurring tasks, use beecork_task_create.
-- Use beecork_notify for progress updates during long tasks.`;
-export class ClaudeSubprocess {
-    tabName;
-    workingDir;
-    config;
-    tabSystemPrompt;
-    proc = null;
-    buffer = '';
-    killTimer = null;
-    runtimeTimer = null;
-    sessionId;
-    constructor(tabName, workingDir, config, sessionId, tabSystemPrompt) {
-        this.tabName = tabName;
-        this.workingDir = workingDir;
-        this.config = config;
-        this.tabSystemPrompt = tabSystemPrompt;
-        this.sessionId = sessionId ?? uuidv4();
-    }
-    async send(prompt, callbacks, resume = false) {
-        if (this.proc) {
-            throw new Error(`Subprocess for tab "${this.tabName}" is already running`);
-        }
-        const args = this.buildArgs(prompt, resume);
-        logger.debug(`[${this.tabName}] Spawning: ${this.config.claudeCode.bin} ${args.join(' ')}`);
-        this.proc = spawn(this.config.claudeCode.bin, args, {
-            cwd: this.workingDir,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env },
-        });
-        const pid = this.proc.pid;
-        logger.info(`[${this.tabName}] Claude subprocess started (PID: ${pid})`);
-        this.proc.stdout.on('data', (chunk) => {
-            this.buffer += chunk.toString();
-            const lines = this.buffer.split('\n');
-            this.buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const event = JSON.parse(line);
-                    callbacks.onEvent(event);
-                }
-                catch {
-                    // Non-JSON line (verbose debug output), skip
-                    logger.debug(`[${this.tabName}] non-json: ${line.slice(0, 200)}`);
-                }
-            }
-        });
-        this.proc.stderr.on('data', (chunk) => {
-            const text = chunk.toString().trim();
-            if (text) {
-                // claude prints auth failures, rate limits, license issues, and other
-                // operational errors to stderr. Surface at warn so they reach daemon.log
-                // at the default level — debugging "why did claude exit?" otherwise
-                // requires recompiling with a different log level.
-                logger.warn(`[${this.tabName}] claude stderr: ${text.slice(0, 500)}`);
-            }
-        });
-        this.proc.on('error', (err) => {
-            this.proc = null;
-            if (this.runtimeTimer) {
-                clearTimeout(this.runtimeTimer);
-                this.runtimeTimer = null;
-            }
-            callbacks.onError(err);
-        });
-        this.proc.on('exit', (code) => {
-            this.proc = null;
-            if (this.killTimer) {
-                clearTimeout(this.killTimer);
-                this.killTimer = null;
-            }
-            if (this.runtimeTimer) {
-                clearTimeout(this.runtimeTimer);
-                this.runtimeTimer = null;
-            }
-            logger.info(`[${this.tabName}] Claude subprocess exited (code: ${code})`);
-            callbacks.onExit(code);
-        });
-        // Hard runtime cap so a wedged claude can't pin a tab forever.
-        // Default 30 minutes. Disable by setting maxRuntimeMs to 0.
-        const maxRuntimeMs = this.config.claudeCode.maxRuntimeMs ?? 30 * 60 * 1000;
-        if (maxRuntimeMs > 0) {
-            this.runtimeTimer = setTimeout(() => {
-                if (!this.proc)
-                    return;
-                logger.warn(`[${this.tabName}] Subprocess exceeded maxRuntimeMs (${maxRuntimeMs}ms) — killing`);
-                callbacks.onError(new Error(`Subprocess timed out after ${Math.round(maxRuntimeMs / 1000)}s`));
-                this.kill();
-            }, maxRuntimeMs);
-        }
-    }
-    kill() {
-        if (!this.proc)
-            return;
-        logger.info(`[${this.tabName}] Killing subprocess (PID: ${this.proc.pid})`);
-        this.proc.kill('SIGTERM');
-        const proc = this.proc;
-        this.killTimer = setTimeout(() => {
-            try {
-                proc.kill('SIGKILL');
-            }
-            catch {
-                /* already dead */
-            }
-        }, 5000);
-    }
-    get isRunning() {
-        return this.proc !== null;
-    }
-    get pid() {
-        return this.proc?.pid ?? null;
-    }
-    buildArgs(prompt, resume) {
-        const args = [
-            '-p',
-            '--output-format',
-            'stream-json',
-            '--verbose',
-            ...this.config.claudeCode.defaultFlags,
-        ];
-        // Only add MCP config if the file exists. existsSync result is cached at
-        // module scope — the path is stable for the daemon's lifetime, so doing
-        // this once-per-process saves a syscall per claude spawn (every message,
-        // every task firing, every watcher trigger).
-        if (mcpConfigExists()) {
-            args.push('--mcp-config', getMcpConfigPath());
-        }
-        // Inject Beecork system context so Claude knows about available tools
-        if (!resume) {
-            let systemPrompt = BEECORK_SYSTEM_PROMPT;
-            if (this.tabSystemPrompt) {
-                systemPrompt += `\n\n[Tab-specific instructions for "${this.tabName}"]\n${this.tabSystemPrompt}`;
-            }
-            args.push('--system-prompt', systemPrompt);
-        }
-        if (resume) {
-            args.push('--resume', this.sessionId);
-        }
-        else {
-            args.push('--session-id', this.sessionId);
-        }
-        if (this.config.claudeCode.computerUse) {
-            args.push('--computer-use');
-        }
-        if (this.config.claudeCode.maxBudgetUsd) {
-            args.push('--max-budget-usd', String(this.config.claudeCode.maxBudgetUsd));
-        }
-        args.push(prompt);
-        return args;
-    }
-}

package/dist/session/tab-store.d.ts

@@ -1,28 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Tab, TabStatus } from '../types.js';
-/**
- * SQL helpers for the `tabs` table. Single place for any code that needs to
- * read/write tab rows. TabManager owns subprocess lifecycle; TabStore owns
- * the schema knowledge.
- *
- * All methods accept an optional `db` param so they're testable against an
- * in-memory database. The no-arg form uses the singleton.
- */
-export declare const TabStore: {
-    listAll(db?: Database.Database): Tab[];
-    findByName(name: string, db?: Database.Database): Tab | undefined;
-    getIdByName(name: string, db?: Database.Database): string | undefined;
-    countAll(db?: Database.Database): number;
-    countRunning(db?: Database.Database): number;
-    /** All tabs marked 'running' — used by daemon crash-recovery on startup. */
-    findRunning(db?: Database.Database): Tab[];
-    /** Most-recently-active tab — used by MCP to surface "current" context. */
-    mostRecent(db?: Database.Database): Tab | undefined;
-    setStatus(name: string, status: TabStatus, db?: Database.Database): void;
-    setIdleById(id: string, db?: Database.Database): void;
-    /** Used by MCP close-tab to nudge daemon recovery loop. */
-    markRunningAsStopped(name: string, db?: Database.Database): void;
-    setSystemPrompt(name: string, systemPrompt: string, db?: Database.Database): boolean;
-    /** Delete a tab and all of its messages atomically. Returns true if it existed. */
-    deleteWithMessages(name: string, db?: Database.Database): boolean;
-};