beecork 1.4.11 → 1.6.0

package/dist/session/message-queue.js

@@ -0,0 +1,52 @@
+/**
+ * Per-tab FIFO queue for messages waiting on a busy subprocess.
+ *
+ * Extracted from TabManager so the queue's "max size, enqueue, dequeue,
+ * peek-and-mutate-next, clear-on-stop" semantics are self-contained and
+ * unit-testable without spinning up a real subprocess.
+ */
+export const MAX_QUEUE_SIZE = 10;
+export class MessageQueue {
+    queues = new Map();
+    /** Attempt to enqueue. Returns false if the per-tab queue is full. */
+    enqueue(tabName, msg) {
+        let queue = this.queues.get(tabName);
+        if (!queue) {
+            queue = [];
+            this.queues.set(tabName, queue);
+        }
+        if (queue.length >= MAX_QUEUE_SIZE)
+            return false;
+        queue.push(msg);
+        return true;
+    }
+    /** Remove and return the next message. Drops the per-tab entry when empty. */
+    dequeue(tabName) {
+        const queue = this.queues.get(tabName);
+        if (!queue || queue.length === 0)
+            return undefined;
+        const next = queue.shift();
+        if (queue.length === 0)
+            this.queues.delete(tabName);
+        return next;
+    }
+    /** Peek at the next queued message without removing it (used to inject loop warning prefix). */
+    peek(tabName) {
+        return this.queues.get(tabName)?.[0];
+    }
+    size(tabName) {
+        return this.queues.get(tabName)?.length ?? 0;
+    }
+    /** Drain the queue for a tab, returning the dropped messages so callers can reject them. */
+    clear(tabName) {
+        const queue = this.queues.get(tabName) ?? [];
+        this.queues.delete(tabName);
+        return queue;
+    }
+    /** Drain every queue. Returns the dropped messages grouped by tab. */
+    clearAll() {
+        const all = Array.from(this.queues.values());
+        this.queues.clear();
+        return all;
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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 type { TabManager } from './manager.js';
+import type { ChannelRegistry } from '../channels/registry.js';
+export type NotifyFn = ((text: string) => Promise<void>) | null;
+export declare class PendingMessageDispatcher {
+    private tabManager;
+    private channels;
+    private onNotify;
+    private pollCount;
+    constructor(tabManager: TabManager, channels: ChannelRegistry, onNotify: NotifyFn);
+    /** Reset any rows stuck in 'processing' from a previous daemon run. */
+    recoverOnStart(): void;
+    /** Called on every daemon poll tick. */
+    tick(): void;
+    private dispatch;
+}

package/dist/session/pending-dispatcher.js

@@ -0,0 +1,120 @@
+/**
+ * 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

@@ -0,0 +1,60 @@
+/**
+ * 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

@@ -0,0 +1,118 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,45 @@
+/**
+ * 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,4 +1,6 @@
 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;
@@ -12,6 +14,7 @@ export declare class ClaudeSubprocess {
     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>;

package/dist/session/subprocess.js

@@ -3,14 +3,27 @@ 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_cron_create: Schedule recurring tasks (types: "at" for one-time, "every" for interval like "30m", "cron" for expressions like "0 9 * * 1")
-- beecork_cron_list: List scheduled tasks
-- beecork_cron_delete: Remove a scheduled task
+- 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
@@ -21,7 +34,7 @@ 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_cron_create.
+- When asked for recurring tasks, use beecork_task_create.
 - Use beecork_notify for progress updates during long tasks.`;
 export class ClaudeSubprocess {
     tabName;
@@ -31,6 +44,7 @@ export class ClaudeSubprocess {
     proc = null;
     buffer = '';
     killTimer = null;
+    runtimeTimer = null;
     sessionId;
     constructor(tabName, workingDir, config, sessionId, tabSystemPrompt) {
         this.tabName = tabName;
@@ -72,11 +86,19 @@ export class ClaudeSubprocess {
         this.proc.stderr.on('data', (chunk) => {
             const text = chunk.toString().trim();
             if (text) {
-                logger.debug(`[${this.tabName}] stderr: ${text.slice(0, 500)}`);
+                // 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) => {
@@ -85,9 +107,25 @@ export class ClaudeSubprocess {
                 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)
@@ -99,7 +137,9 @@ export class ClaudeSubprocess {
             try {
                 proc.kill('SIGKILL');
             }
-            catch { /* already dead */ }
+            catch {
+                /* already dead */
+            }
         }, 5000);
     }
     get isRunning() {
@@ -111,14 +151,17 @@ export class ClaudeSubprocess {
     buildArgs(prompt, resume) {
         const args = [
             '-p',
-            '--output-format', 'stream-json',
+            '--output-format',
+            'stream-json',
             '--verbose',
             ...this.config.claudeCode.defaultFlags,
         ];
-        // Only add MCP config if the file exists
-        const mcpConfig = getMcpConfigPath();
-        if (fs.existsSync(mcpConfig)) {
-            args.push('--mcp-config', mcpConfig);
+        // 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) {

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

@@ -0,0 +1,28 @@
+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;
+};