beecork 1.4.11 → 1.6.0

package/dist/projects/router.js

@@ -7,20 +7,41 @@ const CATEGORY_KEYWORDS = {
 };
 // Per-user current context tracking (in-memory, resets on daemon restart)
 const userContext = new Map();
+// Project list cache. listProjects() ran on every inbound message and re-did a
+// full SELECT + ORDER BY across the projects table; with N projects each call
+// then re-lowercased every name. The cache is invalidated explicitly via
+// invalidateProjectCache() at the few sites that mutate the table.
+let projectsCache = null;
+const PROJECTS_CACHE_TTL_MS = 30_000;
+function getUserProjectsCached() {
+    const now = Date.now();
+    if (projectsCache && projectsCache.expiresAt > now)
+        return projectsCache.user;
+    const user = listProjects()
+        .filter((p) => p.type === 'user-project')
+        .map((p) => ({ ...p, nameLower: p.name.toLowerCase() }));
+    projectsCache = { user, expiresAt: now + PROJECTS_CACHE_TTL_MS };
+    return user;
+}
+/** Invalidate the project cache. Call after createProject/discoverProjects/etc. */
+export function invalidateProjectCache() {
+    projectsCache = null;
+}
 /** Route a message to the right project and tab */
 export function routeMessage(message, context) {
-    const projects = listProjects().filter(p => p.type === 'user-project');
+    const projects = getUserProjectsCached();
     const userId = context?.userId || 'default';
+    const messageLower = message.toLowerCase();
     // 1. Check for explicit project mention by name
-    const mentionedProject = findMentionedProject(message, projects);
+    const mentionedProject = findMentionedProject(messageLower, projects);
     if (mentionedProject) {
-        const tabName = resolveTabInProject(mentionedProject, message, context);
+        const { tabName, exists } = resolveTabInProject(mentionedProject);
         touchProject(mentionedProject.name);
         recordRouting(message, mentionedProject.name);
         return {
             project: mentionedProject,
             tabName,
-            isNewTab: !tabExists(tabName),
+            isNewTab: !exists,
             confidence: 0.95,
             needsConfirmation: false,
             reason: `Message mentions project "${mentionedProject.name}"`,
@@ -28,7 +49,8 @@ export function routeMessage(message, context) {
     }
     // 2. Check if continuing current context
     const currentCtx = userContext.get(userId);
-    if (currentCtx && Date.now() - currentCtx.updatedAt < 10 * 60 * 1000) { // 10 min window
+    if (currentCtx && Date.now() - currentCtx.updatedAt < 10 * 60 * 1000) {
+        // 10 min window
         const project = getProject(currentCtx.projectName);
         if (project) {
             touchProject(project.name);
@@ -43,16 +65,16 @@ export function routeMessage(message, context) {
         }
     }
     // 3. Check routing preferences (learned patterns)
-    const learned = checkLearnedRouting(message);
+    const learned = checkLearnedRouting(messageLower);
     if (learned) {
         const project = getProject(learned.projectName);
         if (project && learned.confidence >= 0.9) {
-            const tabName = resolveTabInProject(project, message, context);
+            const { tabName, exists } = resolveTabInProject(project);
             touchProject(project.name);
             return {
                 project,
                 tabName,
-                isNewTab: !tabExists(tabName),
+                isNewTab: !exists,
                 confidence: learned.confidence,
                 needsConfirmation: false,
                 reason: `Learned pattern → "${project.name}"`,
@@ -60,7 +82,7 @@ export function routeMessage(message, context) {
         }
     }
     // 4. Multiple projects could match — ask user
-    const possibleMatches = findPossibleMatches(message, projects);
+    const possibleMatches = findPossibleMatches(messageLower, projects);
     if (possibleMatches.length > 1) {
         return {
             project: possibleMatches[0],
@@ -68,11 +90,11 @@ export function routeMessage(message, context) {
             isNewTab: false,
             confidence: 0.5,
             needsConfirmation: true,
-            reason: `Multiple projects could match: ${possibleMatches.map(p => p.name).join(', ')}`,
+            reason: `Multiple projects could match: ${possibleMatches.map((p) => p.name).join(', ')}`,
         };
     }
     // 5. Check for category keywords (non-project)
-    const category = detectCategory(message);
+    const category = detectCategory(messageLower);
     if (category) {
         const project = ensureCategory(category);
         const tabName = category;
@@ -113,37 +135,34 @@ export function setUserContext(userId, projectName, tabName) {
             userContext.delete(oldestKey);
     }
 }
-/** Find a project explicitly mentioned by name in the message */
-function findMentionedProject(message, projects) {
-    const lower = message.toLowerCase();
-    // Check for exact project name mentions
+/** Find a project explicitly mentioned by name in the message (messageLower already lower-cased) */
+function findMentionedProject(messageLower, projects) {
     for (const project of projects) {
-        if (lower.includes(project.name.toLowerCase())) {
+        if (messageLower.includes(project.nameLower))
             return project;
-        }
     }
     return null;
 }
 /** Find possible project matches (for ambiguity) */
-function findPossibleMatches(message, projects) {
-    const lower = message.toLowerCase();
-    const words = lower.split(/\s+/);
-    return projects.filter(p => {
-        const nameParts = p.name.toLowerCase().split(/[-_]/);
-        return nameParts.some(part => words.includes(part));
+function findPossibleMatches(messageLower, projects) {
+    const words = messageLower.split(/\s+/);
+    return projects.filter((p) => {
+        const nameParts = p.nameLower.split(/[-_]/);
+        return nameParts.some((part) => words.includes(part));
     });
 }
-/** Resolve which tab to use within a project */
-function resolveTabInProject(project, _message, _context) {
+/**
+ * Resolve which tab to use within a project. Coalesces the previous
+ * "find tabs + tabExists" into one query — the caller used to fire both
+ * back-to-back, and the working_dir scan had no covering index.
+ * (Index added by migration v28; see src/db/migrations.ts.)
+ */
+function resolveTabInProject(project) {
     const db = getDb();
-    // Find existing tabs for this project
-    const tabs = db.prepare('SELECT name, last_activity_at FROM tabs WHERE working_dir = ? ORDER BY last_activity_at DESC').all(project.path);
-    if (tabs.length === 0) {
-        // No tabs yet — use project name as tab name
-        return project.name;
-    }
-    // Use most recently active tab in this project
-    return tabs[0].name;
+    const row = db
+        .prepare('SELECT name FROM tabs WHERE working_dir = ? ORDER BY last_activity_at DESC LIMIT 1')
+        .get(project.path);
+    return row ? { tabName: row.name, exists: true } : { tabName: project.name, exists: false };
 }
 /** Check if a tab exists in the database */
 function tabExists(tabName) {
@@ -151,13 +170,11 @@ function tabExists(tabName) {
     const row = db.prepare('SELECT 1 FROM tabs WHERE name = ?').get(tabName);
     return !!row;
 }
-/** Detect a category from keywords */
-function detectCategory(message) {
-    const lower = message.toLowerCase();
+/** Detect a category from keywords (messageLower already lower-cased) */
+function detectCategory(messageLower) {
     for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
-        if (keywords.some(kw => lower.includes(kw))) {
+        if (keywords.some((kw) => messageLower.includes(kw)))
             return category;
-        }
     }
     return null;
 }
@@ -165,7 +182,11 @@ function detectCategory(message) {
 function recordRouting(message, projectName) {
     const db = getDb();
     // Extract key words from message for pattern matching
-    const words = message.toLowerCase().split(/\s+/).filter(w => w.length > 3).slice(0, 5);
+    const words = message
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 3)
+        .slice(0, 5);
     const pattern = words.join(' ');
     if (!pattern)
         return;
@@ -175,19 +196,51 @@ function recordRouting(message, projectName) {
     ON CONFLICT(pattern, project_name) DO UPDATE SET hit_count = hit_count + 1
   `).run(pattern, projectName);
 }
-/** Check learned routing preferences */
-function checkLearnedRouting(message) {
+/** Check learned routing preferences (messageLower already lower-cased) */
+function checkLearnedRouting(messageLower) {
     const db = getDb();
-    const words = message.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+    const words = messageLower.split(/\s+/).filter((w) => w.length > 3);
     if (words.length === 0)
         return null;
     // Fetch all preferences in a single query and match in JS
-    const allPrefs = db.prepare('SELECT pattern, project_name, confidence, hit_count FROM routing_preferences WHERE hit_count >= 3 ORDER BY hit_count DESC LIMIT 200').all();
+    const allPrefs = db
+        .prepare('SELECT pattern, project_name, confidence, hit_count FROM routing_preferences WHERE hit_count >= 3 ORDER BY hit_count DESC LIMIT 200')
+        .all();
     for (const pref of allPrefs) {
-        const patternLower = pref.pattern.toLowerCase();
-        if (words.some(word => patternLower.includes(word) || word.includes(patternLower))) {
+        // pref.pattern was written via .toLowerCase() in recordRouting(), so no
+        // re-lowercase here (saves N allocations per inbound message).
+        const patternLower = pref.pattern;
+        if (words.some((word) => patternLower.includes(word) || word.includes(patternLower))) {
             return { projectName: pref.project_name, confidence: Math.min(pref.confidence, 0.9) };
         }
     }
     return null;
 }
+/**
+ * Shared project routing logic — resolves which tab/project to use for a message.
+ * Pulled out of channels/ so all routing decisions live in one place.
+ */
+export async function resolveProjectRoute(rawPrompt, tabName, text, userId) {
+    if (tabName !== 'default' || text.startsWith('/tab ')) {
+        return { effectiveTabName: tabName };
+    }
+    try {
+        const decision = routeMessage(rawPrompt, { userId });
+        if (decision.needsConfirmation) {
+            const projects = listProjects().filter((p) => p.type === 'user-project');
+            const options = projects.map((p, i) => `${i + 1}) ${p.name}`).join('\n');
+            return {
+                effectiveTabName: tabName,
+                confirmationMessage: `Which project?\n${options}\n\nReply with the number, or just send your message with /project <name> first.`,
+            };
+        }
+        setUserContext(userId, decision.project.name, decision.tabName);
+        return {
+            effectiveTabName: decision.tabName,
+            projectPath: decision.project.path,
+        };
+    }
+    catch {
+        return { effectiveTabName: tabName };
+    }
+}

package/dist/service/install.js

@@ -82,13 +82,17 @@ export function stopService() {
         try {
             execSync(`launchctl unload "${plistPath}"`, { stdio: 'inherit' });
         }
-        catch { /* not loaded */ }
+        catch {
+            /* not loaded */
+        }
     }
     else {
         try {
             execSync('systemctl --user stop beecork', { stdio: 'inherit' });
         }
-        catch { /* not running */ }
+        catch {
+            /* not running */
+        }
     }
 }
 function installLaunchd(nodePath, daemonPath) {
@@ -104,7 +108,9 @@ function uninstallLaunchd() {
     try {
         execSync(`launchctl unload "${plistPath}"`, { stdio: 'pipe' });
     }
-    catch { /* ok */ }
+    catch {
+        /* ok */
+    }
     if (fs.existsSync(plistPath))
         fs.unlinkSync(plistPath);
     return plistPath;
@@ -124,11 +130,15 @@ function uninstallSystemd() {
     try {
         execSync('systemctl --user disable beecork', { stdio: 'pipe' });
     }
-    catch { /* ok */ }
+    catch {
+        /* ok */
+    }
     try {
         execSync('systemctl --user stop beecork', { stdio: 'pipe' });
     }
-    catch { /* ok */ }
+    catch {
+        /* ok */
+    }
     if (fs.existsSync(unitPath))
         fs.unlinkSync(unitPath);
     execSync('systemctl --user daemon-reload', { stdio: 'pipe' });

package/dist/service/windows.js

@@ -29,7 +29,7 @@ export function startWindowsService() {
         execSync(`schtasks /Run /TN "${TASK_NAME}"`, { stdio: 'inherit' });
         console.log('Beecork daemon started.');
     }
-    catch (err) {
+    catch {
         console.error('Failed to start. Run manually: beecork daemon');
     }
 }

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

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

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

@@ -2,11 +2,13 @@ import type { CircuitBreakerConfig, StreamContentToolUse } from '../types.js';
 export type CircuitBreakerAction = 'ok' | 'warn' | 'notify' | 'break';
 export declare class CircuitBreaker {
     private tabName;
-    private recentCalls;
+    private ring;
+    private ringHead;
+    private ringSize;
     private config;
     private tripped;
-    private warnedAt;
-    private notifiedAt;
+    private warned;
+    private notified;
     private readonly WARN_THRESHOLD;
     private readonly NOTIFY_THRESHOLD;
     constructor(tabName: string, config?: Partial<CircuitBreakerConfig>);

package/dist/session/circuit-breaker.js

@@ -3,34 +3,57 @@ 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;
-    recentCalls = [];
+    // Ring buffer to avoid per-call array reslice
+    ring;
+    ringHead = 0;
+    ringSize = 0;
     config;
     tripped = false;
-    warnedAt = 0;
-    notifiedAt = 0;
+    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 = `${toolUse.name}:${JSON.stringify(toolUse.input)}`;
-        this.recentCalls.push(signature);
-        // Keep only the last windowSize calls
-        if (this.recentCalls.length > this.config.windowSize) {
-            this.recentCalls = this.recentCalls.slice(-this.config.windowSize);
-        }
-        // Count consecutive identical calls from the end
-        const lastCall = this.recentCalls[this.recentCalls.length - 1];
+        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 = this.recentCalls.length - 1; i >= 0; i--) {
-            if (this.recentCalls[i] === lastCall) {
+        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 {
@@ -42,23 +65,25 @@ export class CircuitBreaker {
             this.tripped = true;
             return 'break';
         }
-        if (repeatCount >= this.NOTIFY_THRESHOLD && this.notifiedAt < this.NOTIFY_THRESHOLD) {
+        if (repeatCount >= this.NOTIFY_THRESHOLD && !this.notified) {
             logger.warn(`[${this.tabName}] Loop detected: ${toolUse.name} repeated ${repeatCount} times — notifying user`);
-            this.notifiedAt = repeatCount;
+            this.notified = true;
             return 'notify';
         }
-        if (repeatCount >= this.WARN_THRESHOLD && this.warnedAt < this.WARN_THRESHOLD) {
+        if (repeatCount >= this.WARN_THRESHOLD && !this.warned) {
             logger.info(`[${this.tabName}] Loop detected: ${toolUse.name} repeated ${repeatCount} times — warning`);
-            this.warnedAt = repeatCount;
+            this.warned = true;
             return 'warn';
         }
         return 'ok';
     }
     reset() {
-        this.recentCalls = [];
+        this.ring.fill(undefined);
+        this.ringHead = 0;
+        this.ringSize = 0;
         this.tripped = false;
-        this.warnedAt = 0;
-        this.notifiedAt = 0;
+        this.warned = false;
+        this.notified = false;
     }
     get isTripped() {
         return this.tripped;

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

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

@@ -0,0 +1,45 @@
+/**
+ * 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.js

@@ -1,7 +1,7 @@
 import { logger } from '../util/logger.js';
 const DEFAULT_CONTEXT_WINDOW = 200_000; // Claude's context window in tokens
-const WARNING_THRESHOLD = 0.80;
-const CHECKPOINT_THRESHOLD = 0.90;
+const WARNING_THRESHOLD = 0.8;
+const CHECKPOINT_THRESHOLD = 0.9;
 export class ContextMonitor {
     tabName;
     cumulativeTokens = 0;

package/dist/session/handoff.d.ts

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

package/dist/session/handoff.js

@@ -0,0 +1,50 @@
+/**
+ * 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`.
+ */
+import { getDb } from '../db/index.js';
+import { TabStore } from './tab-store.js';
+export function exportTab(tabName) {
+    const tab = TabStore.findByName(tabName);
+    if (!tab)
+        return null;
+    const messages = getDb()
+        .prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5')
+        .all(tab.id);
+    return {
+        name: tab.name,
+        sessionId: tab.sessionId,
+        workingDir: tab.workingDir,
+        status: tab.status,
+        lastActivity: tab.lastActivityAt,
+        recentMessages: messages.reverse(),
+    };
+}
+export function formatHandoffInfo(info) {
+    const lines = [
+        `Session Handoff — tab "${info.name}"`,
+        '',
+        `Session ID: ${info.sessionId}`,
+        `Working dir: ${info.workingDir}`,
+        `Status: ${info.status}`,
+        `Last activity: ${info.lastActivity}`,
+        '',
+        'To resume in terminal:',
+        `  beecork attach ${info.name}`,
+        '',
+        'Or manually:',
+        `  cd ${info.workingDir}`,
+        `  claude --session-id ${info.sessionId} --resume`,
+    ];
+    if (info.recentMessages.length > 0) {
+        lines.push('', 'Recent context:');
+        for (const msg of info.recentMessages) {
+            lines.push(`  [${msg.role}] ${msg.content.slice(0, 150)}${msg.content.length > 150 ? '...' : ''}`);
+        }
+    }
+    return lines.join('\n');
+}