beecork 1.5.0 → 1.6.0

package/dist/projects/manager.js

@@ -3,19 +3,28 @@ import path from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.js';
 import { getConfig } from '../config.js';
+import { expandHome } from '../util/paths.js';
 import { logger } from '../util/logger.js';
+import { invalidateProjectCache } from './router.js';
 function rowToProject(r) {
-    return { id: r.id, name: r.name, path: r.path, type: r.type, lastUsedAt: r.last_used_at, createdAt: r.created_at };
+    return {
+        id: r.id,
+        name: r.name,
+        path: r.path,
+        type: r.type,
+        lastUsedAt: r.last_used_at,
+        createdAt: r.created_at,
+    };
 }
-/** Get the workspace root from config */
-export function getWorkspaceRoot() {
+/** Get the workspace root from config (module-local) */
+function getWorkspaceRoot() {
     const config = getConfig();
     // Use the default tab's workingDir as workspace root
     const root = config.tabs?.default?.workingDir || process.env.HOME || '';
-    return root.startsWith('~') ? root.replace('~', process.env.HOME || '') : root;
+    return expandHome(root);
 }
-/** Get the managed workspace path (.beecork/ under workspace root) */
-export function getManagedWorkspace() {
+/** Get the managed workspace path (.beecork/ under workspace root) (module-local) */
+function getManagedWorkspace() {
     return path.join(getWorkspaceRoot(), '.beecork');
 }
 /** Discover projects in scan paths (look for git repos, package.json, etc.) */
@@ -24,7 +33,7 @@ export function discoverProjects(scanPaths) {
     const projects = [];
     const db = getDb();
     for (let scanPath of paths) {
-        scanPath = scanPath.startsWith('~') ? scanPath.replace('~', process.env.HOME || '') : scanPath;
+        scanPath = expandHome(scanPath);
         if (!fs.existsSync(scanPath))
             continue;
         try {
@@ -38,13 +47,13 @@ export function discoverProjects(scanPaths) {
                     continue;
                 const dirPath = path.join(scanPath, entry.name);
                 // Check if it looks like a project (has .git, package.json, or similar)
-                const isProject = fs.existsSync(path.join(dirPath, '.git'))
-                    || fs.existsSync(path.join(dirPath, 'package.json'))
-                    || fs.existsSync(path.join(dirPath, 'Cargo.toml'))
-                    || fs.existsSync(path.join(dirPath, 'go.mod'))
-                    || fs.existsSync(path.join(dirPath, 'requirements.txt'))
-                    || fs.existsSync(path.join(dirPath, 'pyproject.toml'))
-                    || fs.existsSync(path.join(dirPath, 'CLAUDE.md'));
+                const isProject = fs.existsSync(path.join(dirPath, '.git')) ||
+                    fs.existsSync(path.join(dirPath, 'package.json')) ||
+                    fs.existsSync(path.join(dirPath, 'Cargo.toml')) ||
+                    fs.existsSync(path.join(dirPath, 'go.mod')) ||
+                    fs.existsSync(path.join(dirPath, 'requirements.txt')) ||
+                    fs.existsSync(path.join(dirPath, 'pyproject.toml')) ||
+                    fs.existsSync(path.join(dirPath, 'CLAUDE.md'));
                 if (isProject) {
                     projects.push({
                         id: uuidv4(),
@@ -68,21 +77,17 @@ export function discoverProjects(scanPaths) {
       ON CONFLICT(name) DO UPDATE SET path = excluded.path, last_used_at = datetime('now')
     `).run(project.id, project.name, project.path, project.type);
     }
+    invalidateProjectCache();
     return projects;
 }
 /** Create a new project. parentDir must resolve under an allowed root. */
 export function createProject(name, parentDir) {
     const requestedParent = parentDir || getWorkspaceRoot();
-    const resolvedParent = path.resolve(requestedParent.startsWith('~')
-        ? requestedParent.replace('~', process.env.HOME || '')
-        : requestedParent);
+    const resolvedParent = path.resolve(expandHome(requestedParent));
     // Allowlist: parent must resolve under workspace root or one of the configured scan paths.
     const config = getConfig();
-    const allowedRoots = [
-        getWorkspaceRoot(),
-        ...(config.projectScanPaths ?? []),
-    ].map(r => path.resolve(r.startsWith('~') ? r.replace('~', process.env.HOME || '') : r));
-    const isAllowed = allowedRoots.some(root => resolvedParent === root || resolvedParent.startsWith(root + path.sep));
+    const allowedRoots = [getWorkspaceRoot(), ...(config.projectScanPaths ?? [])].map((r) => path.resolve(expandHome(r)));
+    const isAllowed = allowedRoots.some((root) => resolvedParent === root || resolvedParent.startsWith(root + path.sep));
     if (!isAllowed) {
         throw new Error(`Project parent directory must be under workspace root or a configured scan path. Allowed: ${allowedRoots.join(', ')}`);
     }
@@ -109,24 +114,44 @@ export function createProject(name, parentDir) {
     INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)
     ON CONFLICT(name) DO UPDATE SET path = excluded.path
   `).run(id, name, projectPath, 'user-project');
-    return { id, name, path: projectPath, type: 'user-project', lastUsedAt: new Date().toISOString(), createdAt: new Date().toISOString() };
+    invalidateProjectCache();
+    return {
+        id,
+        name,
+        path: projectPath,
+        type: 'user-project',
+        lastUsedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+    };
 }
 /** Ensure a managed category exists (lazy creation) */
 export function ensureCategory(name) {
     const categoryPath = path.join(getManagedWorkspace(), name);
     fs.mkdirSync(categoryPath, { recursive: true });
     const db = getDb();
-    const existing = db.prepare('SELECT * FROM projects WHERE name = ? AND type = ?').get(name, 'category');
+    const existing = db
+        .prepare('SELECT * FROM projects WHERE name = ? AND type = ?')
+        .get(name, 'category');
     if (existing)
         return rowToProject(existing);
     const id = uuidv4();
     db.prepare('INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)').run(id, name, categoryPath, 'category');
-    return { id, name, path: categoryPath, type: 'category', lastUsedAt: new Date().toISOString(), createdAt: new Date().toISOString() };
+    invalidateProjectCache();
+    return {
+        id,
+        name,
+        path: categoryPath,
+        type: 'category',
+        lastUsedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+    };
 }
 /** List all projects */
 export function listProjects() {
     const db = getDb();
-    const rows = db.prepare('SELECT * FROM projects ORDER BY type, last_used_at DESC').all();
+    const rows = db
+        .prepare('SELECT * FROM projects ORDER BY type, last_used_at DESC')
+        .all();
     return rows.map(rowToProject);
 }
 /** Get a project by name */
@@ -139,5 +164,3 @@ export function getProject(name) {
 export function touchProject(name) {
     getDb().prepare("UPDATE projects SET last_used_at = datetime('now') WHERE name = ?").run(name);
 }
-// closeTab moved to TabManager.closeTab — see src/session/manager.ts. It now kills
-// the subprocess and deletes the rows in one place rather than the caller doing both.

package/dist/projects/router.d.ts

@@ -1,4 +1,6 @@
 import type { RouteDecision, RoutingContext } from './types.js';
+/** Invalidate the project cache. Call after createProject/discoverProjects/etc. */
+export declare function invalidateProjectCache(): void;
 /** Route a message to the right project and tab */
 export declare function routeMessage(message: string, context?: RoutingContext): RouteDecision;
 /** Update current context for a user */

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,17 +196,21 @@ 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) };
         }
     }

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