beecork 1.3.11 → 1.4.1

package/dist/session/manager.js

@@ -5,7 +5,6 @@ import { ContextMonitor } from './context-monitor.js';
 import { getDb } from '../db/index.js';
 import { resolveWorkingDir, validateTabName } from '../config.js';
 import { logger } from '../util/logger.js';
-import { extractMemories, getRelevantMemories } from '../memory/extractor.js';
 import { logActivity } from '../timeline/index.js';
 import { getAllKnowledge, formatKnowledgeForContext } from '../knowledge/index.js';
 function rowToTab(row) {
@@ -85,7 +84,7 @@ export class TabManager {
                 logger.info(`[${tabName}] Message queued (queue size: ${this.messageQueues.get(tabName).length})`);
             });
         }
-        return this.executeMessage(tab, prompt, options?.resume ?? false, options?.onTextChunk, options?.skipExtraction, options?.onToolUse, options?._compactionDepth);
+        return this.executeMessage(tab, prompt, options?.resume ?? false, options?.onTextChunk, options?.onToolUse, options?._compactionDepth);
     }
     /** Get all tabs from the database */
     listTabs() {
@@ -147,7 +146,7 @@ export class TabManager {
             }
         }
     }
-    async executeMessage(tab, prompt, resume, onTextChunk, skipExtraction, onToolUse, compactionDepth) {
+    async executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth) {
         const db = getDb();
         logActivity('task_started', 'Processing message', { tabName: tab.name, details: prompt.slice(0, 500) });
         // Budget check before spawning
@@ -163,26 +162,10 @@ export class TabManager {
                 this.onNotify?.(`⚠️ Budget warning: tab "${tab.name}" at $${tabSpend.toFixed(2)} / $${this.config.claudeCode.maxBudgetUsd.toFixed(2)} (80%)`).catch(() => { });
             }
         }
-        // Log approval mode (full interactive approval coming in a future release)
-        const tabConfig = this.config.tabs[tab.name] || this.config.tabs['default'];
-        if (tabConfig?.approvalMode && tabConfig.approvalMode !== 'yolo') {
-            logger.warn(`Tab "${tab.name}" has approvalMode="${tabConfig.approvalMode}" — interactive approval not yet implemented, running in yolo mode`);
-        }
-        // Inject knowledge from all three layers
+        // Inject knowledge (global markdown + project markdown + tab facts)
         const knowledge = getAllKnowledge(tab.workingDir, tab.name);
         const knowledgeContext = formatKnowledgeForContext(knowledge);
-        let enrichedPrompt = prompt;
-        if (knowledgeContext) {
-            enrichedPrompt = `${knowledgeContext}\n\n${prompt}`;
-        }
-        // Also inject relevant memories as fallback (additive)
-        const memories = getRelevantMemories(tab.name);
-        if (memories.length > 0) {
-            const memoryContext = memories.map(m => `- ${m}`).join('\n');
-            if (!knowledgeContext) {
-                enrichedPrompt = `[Context from memory:\n${memoryContext}\n]\n\n${prompt}`;
-            }
-        }
+        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);
@@ -289,14 +272,11 @@ export class TabManager {
                         // Ask Claude for a structured summary
                         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.';
                         this.sendMessage(tab.name, summaryPrompt, { _compactionDepth: currentDepth + 1 }).then(summaryResult => {
-                            // Store summary as checkpoint memory
-                            db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)')
-                                .run(`[checkpoint] ${summaryResult.text}`, tab.name, 'auto');
                             // Reset session: new session ID so next message starts fresh with summary context
                             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)}...`);
-                            // Continue with original goal using the summary as context
+                            // Continue with original goal using the summary as in-prompt context (not persisted)
                             const continuationPrompt = `[CONTEXT RESTORED FROM PREVIOUS SESSION]\n${summaryResult.text}\n\n[Continue the original task: "${enrichedPrompt.slice(0, 500)}"]`;
                             this.sendMessage(tab.name, continuationPrompt, { onTextChunk, _compactionDepth: currentDepth + 1 }).then(resolve).catch(reject);
                         }).catch(err => {
@@ -318,13 +298,6 @@ export class TabManager {
                         logger.warn('Delegation completion check failed:', err);
                     });
                     resolve(result);
-                    // Auto-extract memories from completed sessions (fire and forget)
-                    // Skip if pipe brain already handles extraction via PipeBrain.learn()
-                    if (!result.error && result.text && !skipExtraction) {
-                        extractMemories(this.config, tab.name, result.text, result.durationMs).catch(err => {
-                            logger.error(`[${tab.name}] Memory extraction error:`, err);
-                        });
-                    }
                     // 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];

package/dist/tasks/scheduler.js

@@ -171,9 +171,6 @@ export class TaskScheduler {
                     await this.onNotify('Beecork health check: all systems operational');
                 }
                 break;
-            case 'memory_compaction':
-                logger.info('System event: memory compaction (not yet implemented)');
-                break;
             default:
                 logger.warn(`Unknown system event: ${job.message}`);
         }

package/dist/types.d.ts

@@ -10,22 +10,15 @@ export interface ClaudeCodeConfig {
     computerUse?: boolean;
 }
 export interface MemoryConfig {
-    enabled: boolean;
     dbPath: string;
     maxLongTermEntries: number;
 }
 export interface TabConfig {
     workingDir: string;
-    /** Reserved for future use. Currently has no effect — all sessions run in 'yolo' mode. */
-    approvalMode: ApprovalMode;
-    /** Reserved for future use. Currently has no effect. */
-    approvalTimeoutMinutes: number;
 }
-export type ApprovalMode = 'yolo' | 'ask' | 'auto-safe';
 export interface TabTemplate {
     workingDir?: string;
     systemPrompt?: string;
-    approvalMode?: ApprovalMode;
 }
 export interface WhatsAppConfig {
     enabled: boolean;
@@ -33,15 +26,6 @@ export interface WhatsAppConfig {
     sessionPath: string;
     allowedNumbers: string[];
 }
-export interface PipeConfig {
-    enabled: boolean;
-    anthropicApiKey: string;
-    routingModel: string;
-    complexModel: string;
-    confidenceThreshold: number;
-    projectScanPaths: string[];
-    maxFollowUps: number;
-}
 export interface VoiceConfig {
     sttProvider: 'whisper-api' | 'none';
     sttApiKey?: string;
@@ -90,7 +74,8 @@ export interface BeecorkConfig {
     tabs: Record<string, TabConfig>;
     tabTemplates?: Record<string, TabTemplate>;
     memory: MemoryConfig;
-    pipe: PipeConfig;
+    /** Directories to scan for projects on startup (defaults to ~/Coding, ~/Projects, etc.) */
+    projectScanPaths: string[];
     voice?: VoiceConfig;
     groups?: GroupConfig;
     notifications?: NotificationConfig[];

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "beecork",
-  "version": "1.3.11",
+  "version": "1.4.1",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {
     "beecork": "dist/index.js"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node -e \"require('fs').chmodSync('dist/index.js', 0o755)\"",
@@ -19,29 +19,27 @@
     "prepublishOnly": "npm test && npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
-    "@modelcontextprotocol/sdk": "^1.28.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@whiskeysockets/baileys": "^6.7.0",
     "better-sqlite3": "^12.8.0",
-    "commander": "^13.0.0",
-    "discord.js": "^14.25.1",
-    "node-cron": "^4.0.0",
+    "commander": "^14.0.3",
+    "discord.js": "^14.26.2",
+    "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.67.0",
-    "uuid": "^11.0.0"
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@tailwindcss/cli": "^4.2.2",
-    "@types/better-sqlite3": "^7.6.0",
-    "@types/node": "^22.0.0",
-    "@types/node-cron": "^3.0.0",
-    "@types/node-telegram-bot-api": "^0.64.0",
-    "@types/uuid": "^10.0.0",
-    "eslint": "^10.1.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.0.0",
+    "@types/node-cron": "^3.0.11",
+    "@types/node-telegram-bot-api": "^0.64.14",
+    "eslint": "^10.2.0",
     "tailwindcss": "^4.2.2",
-    "tsx": "^4.0.0",
-    "typescript": "^5.7.0",
-    "typescript-eslint": "^8.58.0",
-    "vitest": "^3.0.0"
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1",
+    "vitest": "^4.1.4"
   },
   "files": [
     "dist/"

package/dist/machines/index.d.ts

@@ -1 +0,0 @@
-export { getMachineId, registerThisMachine, listMachines, type Machine } from './registry.js';

package/dist/machines/index.js

@@ -1 +0,0 @@
-export { getMachineId, registerThisMachine, listMachines } from './registry.js';

package/dist/machines/registry.d.ts

@@ -1,15 +0,0 @@
-export interface Machine {
-    id: string;
-    name: string;
-    host: string | null;
-    sshUser: string | null;
-    projectPaths: string[];
-    isPrimary: boolean;
-    lastSeenAt: string;
-}
-/** Get or create this machine's unique ID */
-export declare function getMachineId(): string;
-/** Register this machine in the database */
-export declare function registerThisMachine(projectPaths: string[]): Machine;
-/** List all machines */
-export declare function listMachines(): Machine[];

package/dist/machines/registry.js

@@ -1,46 +0,0 @@
-import os from 'node:os';
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.js';
-import { getBeecorkHome } from '../util/paths.js';
-import { logger } from '../util/logger.js';
-import fs from 'node:fs';
-const MACHINE_ID_PATH = `${getBeecorkHome()}/machine-id`;
-/** Get or create this machine's unique ID */
-export function getMachineId() {
-    if (fs.existsSync(MACHINE_ID_PATH)) {
-        return fs.readFileSync(MACHINE_ID_PATH, 'utf-8').trim();
-    }
-    const id = uuidv4();
-    fs.writeFileSync(MACHINE_ID_PATH, id, { mode: 0o600 });
-    return id;
-}
-/** Register this machine in the database */
-export function registerThisMachine(projectPaths) {
-    const db = getDb();
-    const id = getMachineId();
-    const name = os.hostname();
-    db.prepare(`
-    INSERT INTO machines (id, name, project_paths, last_seen_at)
-    VALUES (?, ?, ?, datetime('now'))
-    ON CONFLICT(id) DO UPDATE SET
-      name = excluded.name,
-      project_paths = excluded.project_paths,
-      last_seen_at = datetime('now')
-  `).run(id, name, JSON.stringify(projectPaths));
-    logger.info(`Machine registered: ${name} (${id.slice(0, 8)}) with ${projectPaths.length} project paths`);
-    return { id, name, host: null, sshUser: null, projectPaths, isPrimary: false, lastSeenAt: new Date().toISOString() };
-}
-/** List all machines */
-export function listMachines() {
-    const db = getDb();
-    const rows = db.prepare('SELECT * FROM machines ORDER BY is_primary DESC, name').all();
-    return rows.map(r => ({
-        id: r.id,
-        name: r.name,
-        host: r.host,
-        sshUser: r.ssh_user,
-        projectPaths: JSON.parse(r.project_paths || '[]'),
-        isPrimary: !!r.is_primary,
-        lastSeenAt: r.last_seen_at,
-    }));
-}

package/dist/memory/extractor.d.ts

@@ -1,5 +0,0 @@
-import type { BeecorkConfig } from '../types.js';
-/** Auto-extract memories from a completed session */
-export declare function extractMemories(config: BeecorkConfig, tabName: string, sessionText: string, durationMs: number): Promise<void>;
-/** Inject relevant memories into a prompt */
-export declare function getRelevantMemories(tabName: string): string[];

package/dist/memory/extractor.js

@@ -1,157 +0,0 @@
-import { spawn } from 'node:child_process';
-import { getDb } from '../db/index.js';
-import { logger } from '../util/logger.js';
-const EXTRACTION_PROMPT = `Extract 0-5 key facts, decisions, or outcomes from this session transcript that would be useful in future sessions. Output ONLY a JSON array of strings. If nothing is worth remembering, output an empty array [].
-
-Examples of what to extract:
-- Server addresses, credentials, file paths
-- User preferences ("prefers deployments after 11pm")
-- Decisions made ("chose PostgreSQL over MySQL for X reason")
-- Outcomes ("deploy succeeded", "bug was in auth middleware")
-
-Session transcript:
-`;
-/** Auto-extract memories from a completed session */
-export async function extractMemories(config, tabName, sessionText, durationMs) {
-    // Only extract from non-trivial sessions
-    if (durationMs < 10000 || sessionText.length < 200)
-        return;
-    // Rate limit: check if we extracted recently for this tab
-    const db = getDb();
-    const recent = db.prepare(`SELECT COUNT(*) as count FROM memories
-     WHERE tab_name = ? AND source = 'auto'
-     AND created_at > datetime('now', '-5 minutes')`).get(tabName);
-    if (recent.count > 0) {
-        logger.debug(`[${tabName}] Skipping memory extraction — too recent`);
-        return;
-    }
-    try {
-        const prompt = EXTRACTION_PROMPT + sessionText.slice(0, 5000); // Limit transcript size
-        const facts = await runExtractionSession(config, prompt);
-        if (facts.length === 0)
-            return;
-        for (const fact of facts) {
-            db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(fact, tabName, 'auto');
-        }
-        // Enforce maxLongTermEntries limit
-        const maxEntries = config.memory.maxLongTermEntries ?? 1000;
-        const count = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
-        if (count > maxEntries) {
-            const excess = count - maxEntries;
-            db.prepare('DELETE FROM memories WHERE rowid IN (SELECT rowid FROM memories ORDER BY created_at ASC LIMIT ?)').run(excess);
-            logger.info(`[${tabName}] Evicted ${excess} oldest memories (limit: ${maxEntries})`);
-        }
-        logger.info(`[${tabName}] Auto-extracted ${facts.length} memories`);
-    }
-    catch (err) {
-        logger.error(`[${tabName}] Memory extraction failed:`, err);
-    }
-}
-/** Inject relevant memories into a prompt */
-export function getRelevantMemories(tabName) {
-    const db = getDb();
-    // Get recent global memories + tab-specific memories
-    const memories = db.prepare(`SELECT content FROM memories
-     WHERE tab_name IS NULL OR tab_name = ?
-     ORDER BY created_at DESC LIMIT 20`).all(tabName);
-    return memories.map(m => m.content);
-}
-async function runExtractionSession(config, prompt) {
-    // Prefer direct API call (cheaper, faster) when API key is available
-    if (config.pipe?.anthropicApiKey) {
-        return runExtractionViaApi(config.pipe.anthropicApiKey, config.pipe.routingModel, prompt);
-    }
-    // Fallback: spawn Claude Code subprocess
-    return runExtractionViaSubprocess(config, prompt);
-}
-function parseFactsFromText(text) {
-    const jsonMatch = text.match(/\[[\s\S]*?\]/);
-    if (jsonMatch) {
-        const facts = JSON.parse(jsonMatch[0]);
-        if (Array.isArray(facts) && facts.every(f => typeof f === 'string')) {
-            return facts.slice(0, 5);
-        }
-    }
-    return [];
-}
-let cachedClient = null;
-let cachedApiKey = '';
-async function runExtractionViaApi(apiKey, model, prompt) {
-    const { default: Anthropic } = await import('@anthropic-ai/sdk');
-    if (!cachedClient || cachedApiKey !== apiKey) {
-        cachedClient = new Anthropic({ apiKey });
-        cachedApiKey = apiKey;
-    }
-    const client = cachedClient;
-    try {
-        const response = await client.messages.create({
-            model,
-            max_tokens: 500,
-            system: 'Extract 0-5 key facts from this session transcript worth remembering across sessions. Output ONLY a JSON array of strings. If nothing is worth remembering, output [].',
-            messages: [{ role: 'user', content: prompt }],
-        }, { timeout: 15000 });
-        const text = response.content.find((b) => b.type === 'text')?.text ?? '[]';
-        return parseFactsFromText(text);
-    }
-    catch (err) {
-        logger.warn('API-based memory extraction failed, falling back to subprocess:', err);
-        return [];
-    }
-}
-async function runExtractionViaSubprocess(config, prompt) {
-    return new Promise((resolve, reject) => {
-        let resolved = false;
-        const safeResolve = (val) => { if (!resolved) {
-            resolved = true;
-            resolve(val);
-        } };
-        const safeReject = (err) => { if (!resolved) {
-            resolved = true;
-            reject(err);
-        } };
-        const args = [
-            '-p',
-            '--output-format', 'stream-json',
-            '--verbose',
-            ...config.claudeCode.defaultFlags,
-            '--no-session-persistence',
-            prompt,
-        ];
-        const proc = spawn(config.claudeCode.bin, args, {
-            cwd: process.cwd(),
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        let output = '';
-        let stdoutBuffer = '';
-        proc.stdout.on('data', (chunk) => {
-            stdoutBuffer += chunk.toString();
-            const lines = stdoutBuffer.split('\n');
-            stdoutBuffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const event = JSON.parse(line);
-                    if (event.type === 'result' && event.result) {
-                        output = event.result;
-                    }
-                }
-                catch { /* skip non-JSON */ }
-            }
-        });
-        proc.on('exit', () => {
-            clearTimeout(timer);
-            try {
-                safeResolve(parseFactsFromText(output));
-            }
-            catch {
-                safeResolve([]);
-            }
-        });
-        proc.on('error', safeReject);
-        const timer = setTimeout(() => {
-            proc.kill('SIGTERM');
-            safeResolve([]);
-        }, 30000);
-    });
-}

package/dist/pipe/anthropic-client.d.ts

@@ -1,14 +0,0 @@
-import type { RouteDecision, GoalEvaluation, KnowledgeEntry, Project } from './types.js';
-export declare class PipeAnthropicClient {
-    private client;
-    private routingModel;
-    private complexModel;
-    constructor(apiKey: string, routingModel: string, complexModel: string);
-    /** Route a message to the right project/tab (Haiku — fast, cheap) */
-    route(message: string, projects: Project[], recentRouting: string[]): Promise<RouteDecision>;
-    /** Evaluate if a goal was achieved (Sonnet — needs reasoning) */
-    evaluateGoal(originalGoal: string, response: string): Promise<GoalEvaluation>;
-    /** Extract knowledge from a conversation (Haiku — fast) */
-    extractKnowledge(conversation: string, existingFacts: string[]): Promise<KnowledgeEntry[]>;
-    private complete;
-}

package/dist/pipe/anthropic-client.js

@@ -1,98 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { logger } from '../util/logger.js';
-import { retryWithBackoff } from '../util/retry.js';
-export class PipeAnthropicClient {
-    client;
-    routingModel;
-    complexModel;
-    constructor(apiKey, routingModel, complexModel) {
-        this.client = new Anthropic({ apiKey });
-        this.routingModel = routingModel;
-        this.complexModel = complexModel;
-    }
-    /** Route a message to the right project/tab (Haiku — fast, cheap) */
-    async route(message, projects, recentRouting) {
-        const projectList = projects.map(p => `- ${p.name}: ${p.path}${p.languages?.length ? ` (${p.languages.join(', ')})` : ''}${p.description ? ` — ${p.description}` : ''}`).join('\n');
-        const response = await this.complete(`You are a message router. Given a user message, determine which project it relates to.
-
-Available projects:
-${projectList || '(no projects discovered yet)'}
-
-Recent routing decisions:
-${recentRouting.slice(0, 5).join('\n') || '(none)'}
-
-Respond with ONLY valid JSON: {"tabName": "project-name", "projectPath": "/path", "confidence": 0.0-1.0, "reason": "brief explanation", "needsConfirmation": false}
-
-If the message is a general question not related to any project, use tabName "default" with the user's home directory.
-If unsure which project, set confidence below 0.5 and needsConfirmation to true.`, message, 'haiku');
-        try {
-            return JSON.parse(response);
-        }
-        catch {
-            logger.warn('Failed to parse routing response:', response);
-            return { tabName: 'default', projectPath: null, confidence: 0.3, reason: 'Could not parse routing', needsConfirmation: true };
-        }
-    }
-    /** Evaluate if a goal was achieved (Sonnet — needs reasoning) */
-    async evaluateGoal(originalGoal, response) {
-        const result = await this.complete(`You evaluate whether a coding assistant achieved a user's goal.
-
-Respond with ONLY valid JSON: {"status": "done|partial|failed", "reason": "brief explanation", "followUp": "what to do next" or null}
-
-Consider:
-- Did it actually make changes, or just describe what to do?
-- Did it complete the full task or just one step?
-- Are there obvious remaining steps?
-
-If the response is a simple answer to a question (not a task), status is "done".`, `Original goal: "${originalGoal}"\n\nAssistant's response:\n${response.slice(0, 3000)}`, 'sonnet');
-        try {
-            return JSON.parse(result);
-        }
-        catch {
-            logger.warn('Failed to parse routing response:', result);
-            return { status: 'done', reason: 'Could not evaluate', followUp: null };
-        }
-    }
-    /** Extract knowledge from a conversation (Haiku — fast) */
-    async extractKnowledge(conversation, existingFacts) {
-        const response = await this.complete(`Extract structured knowledge from this conversation worth remembering across sessions.
-
-Already known facts:
-${existingFacts.slice(0, 10).join('\n') || '(none)'}
-
-Respond with ONLY a valid JSON array: [{"content": "...", "category": "project|preference|decision|fact"}]
-Return [] if nothing new is worth remembering. Max 5 entries.`, conversation.slice(0, 5000), 'haiku');
-        try {
-            const entries = JSON.parse(response);
-            if (Array.isArray(entries)) {
-                return entries.slice(0, 5).map((e) => ({
-                    content: e.content,
-                    category: (e.category || 'fact'),
-                    tabName: null,
-                    source: 'pipe',
-                }));
-            }
-            return [];
-        }
-        catch {
-            return [];
-        }
-    }
-    async complete(systemPrompt, userMessage, model) {
-        const modelId = model === 'haiku' ? this.routingModel : this.complexModel;
-        try {
-            const response = await retryWithBackoff(() => this.client.messages.create({
-                model: modelId,
-                max_tokens: 500,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: userMessage }],
-            }, { timeout: 30000 }), [1000, 5000, 15000], `Pipe API call (${model})`);
-            const textBlock = response.content.find(b => b.type === 'text');
-            return textBlock?.text ?? '';
-        }
-        catch (err) {
-            logger.error(`Pipe API call failed (${model}):`, err);
-            throw err;
-        }
-    }
-}

package/dist/pipe/brain.d.ts

@@ -1,22 +0,0 @@
-import type { TabManager } from '../session/manager.js';
-import type { BeecorkConfig } from '../types.js';
-import type { ChatContext, PipeResult } from './types.js';
-export declare class PipeBrain {
-    private client;
-    private memory;
-    private config;
-    private tabManager;
-    private notifyCallback;
-    constructor(config: BeecorkConfig, tabManager: TabManager);
-    setNotifyCallback(cb: (text: string) => Promise<void>): void;
-    /** Main entry point: process a user message with intelligence */
-    process(message: string, context: ChatContext): Promise<PipeResult>;
-    /** Route a message to the right project/tab */
-    private route;
-    /** Evaluate if the goal was achieved and send follow-ups if needed */
-    private evaluateAndFollowUp;
-    /** Learn from a completed conversation */
-    private learn;
-    /** Discover projects on the filesystem */
-    discoverProjects(): Promise<number>;
-}