beecork 1.5.0 → 1.7.0

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

package/dist/session/manager.d.ts

@@ -1,4 +1,5 @@
 import type { BeecorkConfig, Tab } from '../types.js';
+export type { StreamResult } from '../types.js';
 export interface SendResult {
     text: string;
     costUsd: number;
@@ -7,11 +8,25 @@ export interface SendResult {
     error: boolean;
 }
 export type NotifyCallback = (text: string) => Promise<void>;
+/**
+ * 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 declare class TabManager {
     private config;
     private subprocesses;
-    private circuitBreakers;
-    private messageQueues;
+    private queue;
+    private budget;
+    private tabCostCache;
     private onNotify;
     constructor(config: BeecorkConfig);
     /** Set a callback for sending notifications (e.g., via Telegram) */
@@ -30,7 +45,6 @@ export declare class TabManager {
     listTabs(): Tab[];
     /** Get a specific tab */
     getTab(tabName: string): Tab | undefined;
-    private queryTab;
     /** Stop a tab's running subprocess */
     stopTab(tabName: string): void;
     /** Update a tab's system_prompt. Returns true if the tab existed. */
@@ -39,8 +53,6 @@ export declare class TabManager {
     closeTab(tabName: string): boolean;
     /** Stop all running subprocesses (clean shutdown) */
     stopAll(): void;
-    /** Process pending messages from MCP server IPC */
-    processPendingMessages(): void;
     private executeMessage;
     private processNextInQueue;
     private updateTabStatus;