beecork 1.5.0 → 1.6.0

package/dist/session/manager.js

@@ -3,21 +3,45 @@ import { ClaudeSubprocess } from './subprocess.js';
 import { CircuitBreaker } from './circuit-breaker.js';
 import { ContextMonitor } from './context-monitor.js';
 import { TabStore } from './tab-store.js';
+import { MessageQueue } from './message-queue.js';
+import { BudgetGuard } from './budget-guard.js';
+import { StaleSessionDetector } from './stale-session.js';
+import { ContextCompactor } from './context-compactor.js';
+import { PendingMessageStore } from './pending-store.js';
+import { completeDelegation } from '../delegation/manager.js';
 import { getDb } from '../db/index.js';
 import { resolveWorkingDir, validateTabName } from '../config.js';
 import { logger } from '../util/logger.js';
 import { logActivity } from '../timeline/index.js';
 import { getAllKnowledge, formatKnowledgeForContext } from '../knowledge/index.js';
-const MAX_QUEUE_SIZE = 10;
-let pendingPollCount = 0;
+/**
+ * TabManager orchestrates per-tab Claude subprocess lifecycles. Heavy lifting
+ * (queueing, budget enforcement, stale-session recovery, context compaction,
+ * pending-message dispatch) is delegated to collaborators in this directory
+ * so this class stays focused on:
+ *
+ *   - tab CRUD (ensureTab, listTabs, stopTab, closeTab, stopAll)
+ *   - subprocess orchestration (executeMessage)
+ *   - wiring the collaborators together
+ *
+ * The split happened in the 2026-05-15 audit fix; see the audit file for the
+ * rationale. Before the split this file was 467 lines and 10 responsibilities.
+ */
 export class TabManager {
     config;
     subprocesses = new Map();
-    circuitBreakers = new Map();
-    messageQueues = new Map();
+    queue = new MessageQueue();
+    budget;
+    // In-memory cache of per-tab cumulative cost. Lazily seeded with a single
+    // SUM query when a tab is first checked; thereafter updated incrementally
+    // from the assistant-message insert. Saves an O(N messages) SUM scan on
+    // every inbound message — the previous code re-aggregated the entire tab
+    // history just to gate budget.
+    tabCostCache = new Map();
     onNotify = null;
     constructor(config) {
         this.config = config;
+        this.budget = new BudgetGuard(config.claudeCode.maxBudgetUsd);
     }
     /** Set a callback for sending notifications (e.g., via Telegram) */
     setNotifyCallback(cb) {
@@ -26,7 +50,7 @@ export class TabManager {
     /** Ensure a tab exists in the database. Creates it if missing. */
     ensureTab(tabName, workingDirOverride) {
         const db = getDb();
-        const existing = this.queryTab(db, tabName);
+        const existing = TabStore.findByName(tabName);
         if (existing)
             return existing;
         // Validate tab name before creating (centralized for all channels + MCP)
@@ -60,16 +84,13 @@ export class TabManager {
         const tab = this.ensureTab(tabName, options?.projectPath);
         // If a subprocess is already running on this tab, queue the message
         if (this.subprocesses.get(tabName)?.isRunning) {
-            const queue = this.messageQueues.get(tabName) ?? [];
-            if (queue.length >= MAX_QUEUE_SIZE) {
-                return Promise.reject(new Error(`Queue full for tab "${tabName}" (max ${MAX_QUEUE_SIZE}). Try again later.`));
-            }
             return new Promise((resolve, reject) => {
-                if (!this.messageQueues.has(tabName)) {
-                    this.messageQueues.set(tabName, []);
+                const accepted = this.queue.enqueue(tabName, { prompt, resolve, reject });
+                if (!accepted) {
+                    reject(new Error(`Queue full for tab "${tabName}". Try again later.`));
+                    return;
                 }
-                this.messageQueues.get(tabName).push({ prompt, resolve, reject });
-                logger.info(`[${tabName}] Message queued (queue size: ${this.messageQueues.get(tabName).length})`);
+                logger.info(`[${tabName}] Message queued (queue size: ${this.queue.size(tabName)})`);
             });
         }
         return this.executeMessage(tab, prompt, options?.resume ?? false, options?.onTextChunk, options?.onToolUse, options?._compactionDepth);
@@ -82,15 +103,11 @@ export class TabManager {
     getTab(tabName) {
         return TabStore.findByName(tabName);
     }
-    queryTab(_db, tabName) {
-        return TabStore.findByName(tabName);
-    }
     /** Stop a tab's running subprocess */
     stopTab(tabName) {
         const sub = this.subprocesses.get(tabName);
-        if (sub?.isRunning) {
+        if (sub?.isRunning)
             sub.kill();
-        }
         this.updateTabStatus(tabName, 'stopped');
         this.clearQueue(tabName);
     }
@@ -100,67 +117,54 @@ export class TabManager {
     }
     /** Close a tab — stop subprocess and delete its rows. Returns true if the tab existed. */
     closeTab(tabName) {
+        const tab = TabStore.findByName(tabName);
         this.stopTab(tabName);
+        if (tab)
+            this.tabCostCache.delete(tab.id);
         return TabStore.deleteWithMessages(tabName);
     }
     /** Stop all running subprocesses (clean shutdown) */
     stopAll() {
         for (const [tabName, sub] of this.subprocesses) {
-            if (sub.isRunning) {
+            if (sub.isRunning)
                 sub.kill();
-            }
             this.updateTabStatus(tabName, 'stopped');
         }
         this.subprocesses.clear();
-        this.circuitBreakers.clear();
-        this.messageQueues.clear();
-    }
-    /** Process pending messages from MCP server IPC */
-    processPendingMessages() {
-        const db = getDb();
-        // Periodic cleanup: delete old processed messages every ~100 polls (~8 minutes at 5s interval)
-        pendingPollCount++;
-        if (pendingPollCount % 100 === 0) {
-            db.prepare("DELETE FROM pending_messages WHERE processed = 1 AND created_at < datetime('now', '-1 day')").run();
-        }
-        const pending = db.prepare('SELECT * FROM pending_messages WHERE processed = 0 ORDER BY created_at ASC LIMIT 50').all();
-        if (pending.length === 0)
-            return;
-        const markProcessed = db.prepare('UPDATE pending_messages SET processed = 1 WHERE id = ?');
-        for (const msg of pending) {
-            // Mark processed AFTER delivery resolves (success OR failure) so a crash
-            // mid-loop doesn't leave the row both unprocessed in the DB and dropped
-            // from the in-memory iteration. Failures still mark processed — we don't
-            // want infinite retries — but the failure path also logs and notifies.
-            if (msg.type === 'notification') {
-                this.onNotify?.(msg.message)
-                    .catch(err => logger.warn('Notify failed:', err))
-                    .finally(() => markProcessed.run(msg.id));
-            }
-            else {
-                this.sendMessage(msg.tab_name, msg.message)
-                    .catch(err => {
-                    logger.error(`Failed to process pending message for tab ${msg.tab_name}:`, err);
-                    this.onNotify?.(`Pending message for tab "${msg.tab_name}" failed: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
-                })
-                    .finally(() => markProcessed.run(msg.id));
+        for (const dropped of this.queue.clearAll()) {
+            for (const item of dropped) {
+                item.reject(new Error('Daemon shutting down'));
             }
         }
     }
     async executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth, forceFresh = false, retryDepth = 0) {
         const db = getDb();
-        logActivity('task_started', 'Processing message', { tabName: tab.name, details: prompt.slice(0, 500) });
+        logActivity('task_started', 'Processing message', {
+            tabName: tab.name,
+            details: prompt.slice(0, 500),
+        });
         // Budget check before spawning
         if (this.config.claudeCode.maxBudgetUsd) {
-            const tabSpend = db.prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE tab_id = ?').get(tab.id).total;
-            if (tabSpend >= this.config.claudeCode.maxBudgetUsd) {
-                const msg = `Budget limit reached for tab "${tab.name}": $${tabSpend.toFixed(2)} / $${this.config.claudeCode.maxBudgetUsd.toFixed(2)}`;
-                this.onNotify?.(msg).catch(() => { });
-                return { text: msg, costUsd: 0, durationMs: 0, sessionId: tab.sessionId, error: true };
+            let tabSpend = this.tabCostCache.get(tab.id);
+            if (tabSpend === undefined) {
+                tabSpend = db
+                    .prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE tab_id = ?')
+                    .get(tab.id).total;
+                this.tabCostCache.set(tab.id, tabSpend);
             }
-            // Warn at 80%
-            if (tabSpend >= this.config.claudeCode.maxBudgetUsd * 0.8) {
-                this.onNotify?.(`⚠️ Budget warning: tab "${tab.name}" at $${tabSpend.toFixed(2)} / $${this.config.claudeCode.maxBudgetUsd.toFixed(2)} (80%)`).catch(() => { });
+            const decision = this.budget.check(tabSpend, tab.name);
+            if (!decision.allowed) {
+                this.onNotify?.(decision.reason).catch(() => { });
+                return {
+                    text: decision.reason,
+                    costUsd: 0,
+                    durationMs: 0,
+                    sessionId: tab.sessionId,
+                    error: true,
+                };
+            }
+            if (decision.warning) {
+                this.onNotify?.(decision.warning).catch(() => { });
             }
         }
         // Inject knowledge (global markdown + project markdown + tab facts)
@@ -168,33 +172,42 @@ export class TabManager {
         const knowledgeContext = formatKnowledgeForContext(knowledge);
         const enrichedPrompt = knowledgeContext ? `${knowledgeContext}\n\n${prompt}` : prompt;
         // Store user message
-        db.prepare('INSERT INTO messages (tab_id, role, content) VALUES (?, ?, ?)')
-            .run(tab.id, 'user', prompt);
+        db.prepare('INSERT INTO messages (tab_id, role, content) VALUES (?, ?, ?)').run(tab.id, 'user', prompt);
         this.updateTabStatus(tab.name, 'running');
         // Get fresh tab to pick up system_prompt
-        const freshTab = this.queryTab(db, tab.name) || tab;
+        const freshTab = TabStore.findByName(tab.name) || tab;
         const subprocess = new ClaudeSubprocess(tab.name, tab.workingDir, this.config, tab.sessionId, freshTab.systemPrompt);
         this.subprocesses.set(tab.name, subprocess);
+        // Circuit breaker is per-call state — its lifetime is exactly the
+        // subprocess's lifetime. Keep it as a local const; the previous
+        // circuitBreakers Map suggested cross-call state but nothing read it
+        // outside this scope.
         const breaker = new CircuitBreaker(tab.name);
-        this.circuitBreakers.set(tab.name, breaker);
         const contextMonitor = new ContextMonitor(tab.name);
         // Resume if: explicitly requested or DB has prior successful responses for this tab.
         // forceFresh overrides both — used after a stale-session retry to guarantee --session-id, not --resume.
-        const hasDbHistory = db.prepare('SELECT COUNT(*) as count FROM messages WHERE tab_id = ? AND role = ? AND content != ?').get(tab.id, 'assistant', '');
-        const shouldResume = !forceFresh && (resume || hasDbHistory.count > 0);
+        // LIMIT 1 short-circuits on the first matching row — a long-running tab with
+        // 10k messages used to walk the whole index for a boolean answer.
+        const hasDbHistory = db
+            .prepare("SELECT 1 FROM messages WHERE tab_id = ? AND role = 'assistant' AND content != '' LIMIT 1")
+            .get(tab.id) !== undefined;
+        const shouldResume = !forceFresh && (resume || hasDbHistory);
         return new Promise((resolve, reject) => {
             let resultText = '';
             let resultEvent = null;
             let loopWarningPending = false;
             let checkpointTriggered = false;
+            // Prevent the SIGTERM-then-exit double dispatch: when onError already
+            // routed the failure through reject() + processNextInQueue, suppress
+            // the inevitable subsequent onExit so the queue doesn't shift twice.
+            let errored = false;
             const callbacks = {
                 onEvent: (event) => {
                     // Capture session_id from StreamInit and update tab record
                     if (event.type === 'system' && 'subtype' in event && event.subtype === 'init') {
                         const initEvent = event;
                         if (initEvent.session_id) {
-                            db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?')
-                                .run(initEvent.session_id, tab.id);
+                            db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?').run(initEvent.session_id, tab.id);
                         }
                     }
                     if (event.type === 'assistant') {
@@ -203,7 +216,6 @@ export class TabManager {
                         if (assistant.message.usage) {
                             const contextAction = contextMonitor.recordUsage(assistant.message.usage);
                             if (contextAction === 'warn') {
-                                // Will inject warning on next message
                                 logger.info(`[${tab.name}] Context window warning — will summarize on next turn`);
                             }
                             else if (contextAction === 'checkpoint') {
@@ -225,7 +237,7 @@ export class TabManager {
                                     subprocess.kill();
                                 }
                                 else if (action === 'notify') {
-                                    this.onNotify?.(`Loop detected in tab "${tab.name}": ${toolUse.name} repeated 10+ times. Send /stop ${tab.name} to kill it.`).catch(err => logger.warn('Notify failed:', err));
+                                    this.onNotify?.(`Loop detected in tab "${tab.name}": ${toolUse.name} repeated 10+ times. Send /stop ${tab.name} to kill it.`).catch((err) => logger.warn('Notify failed:', err));
                                 }
                                 else if (action === 'warn') {
                                     loopWarningPending = true;
@@ -238,116 +250,116 @@ export class TabManager {
                     }
                 },
                 onExit: (code) => {
+                    if (errored) {
+                        // onError already rejected and drained the queue; don't double-dispatch.
+                        return;
+                    }
                     this.subprocesses.delete(tab.name);
-                    this.circuitBreakers.delete(tab.name);
                     const result = {
                         text: resultEvent?.result ?? resultText,
                         costUsd: resultEvent?.total_cost_usd ?? 0,
                         durationMs: resultEvent?.duration_ms ?? 0,
                         sessionId: subprocess.sessionId,
-                        error: resultEvent?.is_error ?? (code !== 0),
+                        error: resultEvent?.is_error ?? code !== 0,
                     };
                     // Handle resume failure (Claude Code session cache rotated / never existed / expired).
-                    // Detection covers both legacy text-based errors and the modern error_during_execution
-                    // event shape ({"subtype":"error_during_execution","errors":["No conversation found..."]}).
-                    // retryDepth guards against any pathological loop.
-                    const staleSession = result.error && shouldResume && retryDepth === 0 && (result.text.match(/session (not found|expired|invalid)/i) !== null ||
-                        (resultEvent?.subtype === 'error_during_execution' &&
-                            resultEvent.errors?.some(e => /no conversation found|session.*not found|session.*expired|session.*invalid/i.test(e))));
-                    if (staleSession) {
+                    if (StaleSessionDetector.isStale(result, resultEvent, shouldResume, retryDepth)) {
                         const detail = resultEvent?.errors?.[0] ?? result.text.split('\n')[0];
                         logger.warn(`[${tab.name}] Resume session ${tab.sessionId} unavailable in Claude Code cache (${detail}). Retrying with fresh session.`);
-                        const recentMsgs = db.prepare("SELECT role, content FROM messages WHERE tab_id = ? AND content != '' ORDER BY created_at DESC LIMIT 5").all(tab.id);
-                        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;
-                        // Reset session ID for fresh start. Use --session-id (forceFresh) to bypass the
-                        // hasDbHistory shouldResume override that would otherwise --resume the new UUID
-                        // against an equally-empty Claude Code cache.
-                        const newSessionId = uuidv4();
-                        db.prepare('UPDATE tabs SET session_id = ?, status = ? WHERE id = ?').run(newSessionId, 'idle', tab.id);
-                        this.executeMessage({ ...tab, sessionId: newSessionId }, contextPrompt, false, onTextChunk, onToolUse, compactionDepth, true, retryDepth + 1)
-                            .then(resolve).catch(reject);
+                        const recovery = StaleSessionDetector.buildRecovery(tab.id, enrichedPrompt, db);
+                        db.prepare('UPDATE tabs SET session_id = ?, status = ? WHERE id = ?').run(recovery.newSessionId, 'idle', tab.id);
+                        this.executeMessage({ ...tab, sessionId: recovery.newSessionId }, recovery.contextPrompt, false, onTextChunk, onToolUse, compactionDepth, true, retryDepth + 1)
+                            .then(resolve)
+                            .catch(reject);
                         return;
                     }
                     // Store assistant response. Skip empty content (typically failed/error runs) so
                     // it doesn't trigger the hasDbHistory shouldResume override on future calls.
                     if (result.text.trim() !== '') {
                         db.prepare('INSERT INTO messages (tab_id, role, content, cost_usd, tokens_in, tokens_out) VALUES (?, ?, ?, ?, ?, ?)').run(tab.id, 'assistant', result.text, result.costUsd, resultEvent?.usage?.input_tokens ?? null, resultEvent?.usage?.output_tokens ?? null);
+                        // Keep the budget cache in sync with the row we just inserted —
+                        // avoids the per-message SUM scan in the next budget check.
+                        if (this.tabCostCache.has(tab.id)) {
+                            this.tabCostCache.set(tab.id, (this.tabCostCache.get(tab.id) ?? 0) + (result.costUsd || 0));
+                        }
                     }
                     // Update tab
-                    db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?')
-                        .run('idle', new Date().toISOString(), tab.name);
-                    logActivity('task_completed', 'Message processed', { tabName: tab.name, durationMs: result.durationMs, costUsd: result.costUsd, details: result.text.slice(0, 500) });
+                    db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?').run('idle', new Date().toISOString(), tab.name);
+                    logActivity('task_completed', 'Message processed', {
+                        tabName: tab.name,
+                        durationMs: result.durationMs,
+                        costUsd: result.costUsd,
+                        details: result.text.slice(0, 500),
+                    });
                     // Context window compaction: if checkpoint was triggered, restart with summary.
                     const currentDepth = compactionDepth ?? 0;
-                    if (checkpointTriggered && !result.error && result.text && currentDepth < 2) {
-                        logger.info(`[${tab.name}] Compacting context (depth ${currentDepth + 1}/2) — requesting summary then restarting session`);
-                        this.onNotify?.(`🔄 [${tab.name}] Context window full — compacting and continuing...`).catch(err => logger.warn('Notify failed:', err));
-                        // Async/await so any thrown error (from DB or sendMessage) routes through
-                        // a single catch instead of the previous nested .then().catch() chain
-                        // where a sync throw inside the inner .then could orphan the promise.
-                        (async () => {
-                            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 this.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)}"]`;
-                                const continuation = await this.sendMessage(tab.name, continuationPrompt, { onTextChunk, _compactionDepth: currentDepth + 1 });
-                                resolve(continuation);
-                            }
-                            catch (err) {
-                                logger.error(`[${tab.name}] Compaction failed:`, err);
-                                resolve(result); // Fall back to original result so the user gets *something*.
-                            }
-                        })();
-                        return; // Don't resolve here — the async compaction flow resolves.
+                    if (checkpointTriggered &&
+                        !result.error &&
+                        result.text &&
+                        currentDepth < ContextCompactor.MAX_DEPTH) {
+                        // Compactor handles its own try/catch and always returns a SendResult.
+                        // The queue drain MUST happen regardless of compaction outcome — the
+                        // previous pattern omitted it in this branch, so a queued message
+                        // could wait indefinitely while compaction recursion was in flight.
+                        ContextCompactor.compact(tab, enrichedPrompt, result, onTextChunk, currentDepth, (tabName, p, opts) => this.sendMessage(tabName, p, opts), this.onNotify, db)
+                            .then(resolve)
+                            .finally(() => this.processNextInQueue(tab.name));
+                        return;
                     }
                     // Check for delegation completion
-                    import('../delegation/manager.js').then(({ completeDelegation }) => {
+                    try {
                         const delegation = completeDelegation(tab.name, result.text);
                         if (delegation && delegation.returnToTab) {
-                            // Queue result message back to the source tab
-                            db.prepare('INSERT INTO pending_messages (tab_name, message, type) VALUES (?, ?, ?)').run(delegation.returnToTab, `[Result from tab:${tab.name}]: ${result.text.slice(0, 10000)}`, 'delegation_result');
+                            PendingMessageStore.enqueueDelegationResult(delegation.returnToTab, `[Result from tab:${tab.name}]: ${result.text.slice(0, 10000)}`);
+                            logActivity('delegation_completed', `Delegation ${tab.name} → ${delegation.returnToTab}`, {
+                                tabName: tab.name,
+                                details: result.text.slice(0, 500),
+                            });
                             this.onNotify?.(`Delegation complete: ${tab.name} → result sent back to ${delegation.returnToTab}`).catch(() => { });
                             logger.info(`Delegation result sent: ${tab.name} → ${delegation.returnToTab}`);
                         }
-                    }).catch(err => {
+                    }
+                    catch (err) {
                         logger.warn('Delegation completion check failed:', err);
-                    });
+                    }
                     resolve(result);
                     // Process next queued message (prepend loop warning if needed)
-                    if (loopWarningPending && this.messageQueues.get(tab.name)?.length) {
-                        const next = this.messageQueues.get(tab.name)[0];
-                        next.prompt = `[WARNING: You appear to be repeating the same action. Reassess your approach.]\n\n${next.prompt}`;
-                        loopWarningPending = false;
+                    if (loopWarningPending) {
+                        const next = this.queue.peek(tab.name);
+                        if (next) {
+                            next.prompt = `[WARNING: You appear to be repeating the same action. Reassess your approach.]\n\n${next.prompt}`;
+                            loopWarningPending = false;
+                        }
                     }
                     this.processNextInQueue(tab.name);
                 },
                 onError: (err) => {
+                    errored = true;
                     this.subprocesses.delete(tab.name);
-                    this.circuitBreakers.delete(tab.name);
                     this.updateTabStatus(tab.name, 'error');
-                    logActivity('task_failed', 'Message failed', { tabName: tab.name, details: err instanceof Error ? err.message : String(err) });
+                    logActivity('task_failed', 'Message failed', {
+                        tabName: tab.name,
+                        details: err instanceof Error ? err.message : String(err),
+                    });
                     reject(err);
                     this.processNextInQueue(tab.name);
                 },
             };
-            subprocess.send(enrichedPrompt, callbacks, shouldResume).catch(reject);
-            // Update tab with PID
-            if (subprocess.pid) {
-                db.prepare('UPDATE tabs SET pid = ? WHERE name = ?').run(subprocess.pid, tab.name);
-            }
+            subprocess.send(enrichedPrompt, callbacks, shouldResume).catch((err) => {
+                if (!errored) {
+                    errored = true;
+                    this.subprocesses.delete(tab.name);
+                    this.updateTabStatus(tab.name, 'error');
+                    reject(err);
+                    this.processNextInQueue(tab.name);
+                }
+            });
         });
     }
     processNextInQueue(tabName) {
-        const queue = this.messageQueues.get(tabName);
-        if (!queue || queue.length === 0)
+        const next = this.queue.dequeue(tabName);
+        if (!next)
             return;
-        const next = queue.shift();
         const tab = this.getTab(tabName);
         if (!tab) {
             next.reject(new Error(`Tab "${tabName}" not found`));
@@ -356,17 +368,12 @@ export class TabManager {
         this.executeMessage(tab, next.prompt, false).then(next.resolve).catch(next.reject);
     }
     updateTabStatus(tabName, status) {
-        const db = getDb();
-        db.prepare('UPDATE tabs SET status = ?, last_activity_at = ? WHERE name = ?')
-            .run(status, new Date().toISOString(), tabName);
+        TabStore.setStatus(tabName, status);
     }
     clearQueue(tabName) {
-        const queue = this.messageQueues.get(tabName);
-        if (queue) {
-            for (const item of queue) {
-                item.reject(new Error(`Tab "${tabName}" was stopped`));
-            }
-            this.messageQueues.delete(tabName);
+        const dropped = this.queue.clear(tabName);
+        for (const item of dropped) {
+            item.reject(new Error(`Tab "${tabName}" was stopped`));
         }
     }
 }

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

@@ -0,0 +1,29 @@
+/**
+ * Small store wrapping the `memories` table. Used by the MCP and dashboard
+ * layers instead of inline `INSERT INTO memories` so schema details stay in
+ * one place.
+ */
+import type Database from 'better-sqlite3';
+export interface MemoryRow {
+    id: number;
+    content: string;
+    tabName: string | null;
+    source: string;
+    createdAt: string;
+}
+export declare const MemoryStore: {
+    add(content: string, opts?: {
+        tabName?: string | null;
+        source?: string;
+    }, db?: Database.Database): void;
+    delete(id: number | string, db?: Database.Database): boolean;
+    count(db?: Database.Database): number;
+    list(opts?: {
+        limit?: number;
+        offset?: number;
+        query?: string;
+    }, db?: Database.Database): {
+        memories: MemoryRow[];
+        total: number;
+    };
+};

package/dist/session/memory-store.js

@@ -0,0 +1,45 @@
+/**
+ * Small store wrapping the `memories` table. Used by the MCP and dashboard
+ * layers instead of inline `INSERT INTO memories` so schema details stay in
+ * one place.
+ */
+import { getDb } from '../db/index.js';
+function rowToMemory(r) {
+    return {
+        id: r.id,
+        content: r.content,
+        tabName: r.tab_name,
+        source: r.source,
+        createdAt: r.created_at,
+    };
+}
+export const MemoryStore = {
+    add(content, opts, db = getDb()) {
+        db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(content, opts?.tabName ?? null, opts?.source ?? 'tool');
+    },
+    delete(id, db = getDb()) {
+        const result = db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+        return result.changes > 0;
+    },
+    count(db = getDb()) {
+        return db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
+    },
+    list(opts = {}, db = getDb()) {
+        const limit = opts.limit ?? 50;
+        const offset = opts.offset ?? 0;
+        if (opts.query) {
+            const rows = db
+                .prepare('SELECT id, content, tab_name, source, created_at FROM memories WHERE content LIKE ? ORDER BY created_at DESC LIMIT ? OFFSET ?')
+                .all(`%${opts.query}%`, limit, offset);
+            const total = db
+                .prepare('SELECT COUNT(*) as c FROM memories WHERE content LIKE ?')
+                .get(`%${opts.query}%`).c;
+            return { memories: rows.map(rowToMemory), total };
+        }
+        const rows = db
+            .prepare('SELECT id, content, tab_name, source, created_at FROM memories ORDER BY created_at DESC LIMIT ? OFFSET ?')
+            .all(limit, offset);
+        const total = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
+        return { memories: rows.map(rowToMemory), total };
+    },
+};

package/dist/session/message-queue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+import type { SendResult } from './manager.js';
+export declare const MAX_QUEUE_SIZE = 10;
+export interface QueuedMessage {
+    prompt: string;
+    resolve: (r: SendResult) => void;
+    reject: (e: Error) => void;
+}
+export declare class MessageQueue {
+    private queues;
+    /** Attempt to enqueue. Returns false if the per-tab queue is full. */
+    enqueue(tabName: string, msg: QueuedMessage): boolean;
+    /** Remove and return the next message. Drops the per-tab entry when empty. */
+    dequeue(tabName: string): QueuedMessage | undefined;
+    /** Peek at the next queued message without removing it (used to inject loop warning prefix). */
+    peek(tabName: string): QueuedMessage | undefined;
+    size(tabName: string): number;
+    /** Drain the queue for a tab, returning the dropped messages so callers can reject them. */
+    clear(tabName: string): QueuedMessage[];
+    /** Drain every queue. Returns the dropped messages grouped by tab. */
+    clearAll(): QueuedMessage[][];
+}

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;
+    }
+}