beecork 1.3.10 → 1.4.0

package/dist/index.js

@@ -166,12 +166,13 @@ program
     .description('Set up WhatsApp — enter phone number, then scan QR code to pair')
     .action(async () => {
     const readline = await import('node:readline');
+    const fs = await import('node:fs');
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q, def) => new Promise(r => rl.question(def ? `${q} [${def}]: ` : `${q}: `, a => r(a.trim() || def || '')));
     console.log('\nWhatsApp Setup\n');
     console.log('  WhatsApp connects via QR code scanning (like WhatsApp Web).');
-    console.log('  After setup, run "beecork start" and the QR code will appear');
-    console.log('  in your terminal. Scan it with your phone to pair.\n');
+    console.log('  After entering your phone number, a QR code will appear.');
+    console.log('  Scan it with your phone to pair.\n');
     const number = await ask('Your WhatsApp phone number (e.g., 14155551234)');
     if (!number) {
         console.log('No number provided. Cancelled.');
@@ -181,18 +182,49 @@ program
     const { getConfig, saveConfig } = await import('./config.js');
     const { getBeecorkHome } = await import('./util/paths.js');
     const config = getConfig();
+    const sessionPath = `${getBeecorkHome()}/whatsapp-session`;
     config.whatsapp = {
         enabled: true,
         mode: 'baileys',
-        sessionPath: `${getBeecorkHome()}/whatsapp-session`,
+        sessionPath,
         allowedNumbers: [number],
     };
     saveConfig(config);
-    console.log('\n✓ WhatsApp configured.');
-    console.log('  Next: run "beecork start" — the QR code will appear in your terminal.');
-    console.log('  Scan it with your phone to pair. Once paired, press Ctrl+C and');
-    console.log('  run "beecork start" again for background operation.\n');
+    console.log('\n✓ Config saved. Connecting to WhatsApp...\n');
     rl.close();
+    // Pair immediately — show QR code in this terminal
+    try {
+        const { default: makeWASocket, useMultiFileAuthState, DisconnectReason } = await import('@whiskeysockets/baileys');
+        fs.mkdirSync(sessionPath, { recursive: true, mode: 0o700 });
+        const { state, saveCreds } = await useMultiFileAuthState(sessionPath);
+        const sock = makeWASocket({
+            auth: state,
+            printQRInTerminal: true,
+        });
+        sock.ev.on('creds.update', saveCreds);
+        sock.ev.on('connection.update', (update) => {
+            if (update.connection === 'open') {
+                console.log('\n✓ WhatsApp paired successfully!');
+                console.log('  You can now start the daemon: beecork start\n');
+                sock.end(undefined);
+                process.exit(0);
+            }
+            if (update.connection === 'close') {
+                const reason = update.lastDisconnect?.error?.output?.statusCode;
+                if (reason === DisconnectReason.loggedOut) {
+                    console.log('\n✗ WhatsApp logged out. Please try again.\n');
+                    process.exit(1);
+                }
+            }
+        });
+        console.log('Scan the QR code above with your phone (WhatsApp → Linked Devices → Link a Device)');
+        console.log('Waiting for pairing... (Ctrl+C to cancel)\n');
+    }
+    catch (err) {
+        console.error('Failed to connect to WhatsApp:', err instanceof Error ? err.message : err);
+        console.log('\nConfig is saved. You can try pairing later by running: beecork whatsapp');
+        process.exit(1);
+    }
 });
 program
     .command('webhook')
@@ -304,8 +336,6 @@ program
             console.log(`    workingDir: ${tmpl.workingDir}`);
         if (tmpl.systemPrompt)
             console.log(`    systemPrompt: "${tmpl.systemPrompt.slice(0, 80)}${tmpl.systemPrompt.length > 80 ? '...' : ''}"`);
-        if (tmpl.approvalMode)
-            console.log(`    approvalMode: ${tmpl.approvalMode}`);
     }
     console.log('');
 });
@@ -375,27 +405,6 @@ program
     const { getActivitySummary, formatActivitySummary } = await import('./observability/analytics.js');
     console.log(formatActivitySummary(getActivitySummary(h)));
 });
-program
-    .command('machines')
-    .description('List registered machines')
-    .action(async () => {
-    const { listMachines } = await import('./machines/index.js');
-    const machines = listMachines();
-    if (machines.length === 0) {
-        console.log('No machines registered. Start the daemon to register this machine.');
-        return;
-    }
-    console.log(`\n${machines.length} machine(s):\n`);
-    for (const m of machines) {
-        const primary = m.isPrimary ? ' (primary)' : '';
-        const remote = m.host ? ` — ${m.sshUser}@${m.host}` : ' — local';
-        console.log(`  ${m.name}${primary}${remote}`);
-        for (const p of m.projectPaths) {
-            console.log(`    ${p}`);
-        }
-    }
-    console.log('');
-});
 program
     .command('folders')
     .alias('projects')

package/dist/mcp/server.js

@@ -322,11 +322,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['tabName'],
             },
         },
-        {
-            name: 'beecork_machines',
-            description: 'List registered machines and their folder paths. Shows which machine handles which folders.',
-            inputSchema: { type: 'object', properties: {} },
-        },
         {
             name: 'beecork_delegate',
             description: 'Delegate a task to another tab. The target tab runs independently and the result is automatically sent back to the source tab when complete. Use this for tasks that need their own working directory or context.',
@@ -493,6 +488,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 // Default: existing tab memory behavior
                 const fullContent = category ? `[${category}] ${content}` : content;
+                // Dedup: skip insert if an identical fact already exists
+                const existing = db.prepare('SELECT id FROM memories WHERE content = ? AND tab_name IS NULL LIMIT 1').get(fullContent);
+                if (existing) {
+                    return ok(`Already remembered: "${fullContent}"`);
+                }
                 db.prepare('INSERT INTO memories (content, source) VALUES (?, ?)').run(fullContent, 'tool');
                 return ok(`Remembered: "${fullContent}"`);
             }
@@ -761,11 +761,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
                 return ok(JSON.stringify(info, null, 2));
             }
-            case 'beecork_machines': {
-                const { listMachines } = await import('../machines/index.js');
-                const machines = listMachines();
-                return ok(JSON.stringify(machines, null, 2));
-            }
             case 'beecork_delegate': {
                 const { tabName, message, returnToTab } = args;
                 try {

package/dist/session/manager.d.ts

@@ -23,7 +23,6 @@ export declare class TabManager {
         resume?: boolean;
         onTextChunk?: (text: string) => void;
         onToolUse?: (toolName: string, toolInput: Record<string, unknown>) => void;
-        skipExtraction?: boolean;
         projectPath?: string;
         _compactionDepth?: number;
     }): Promise<SendResult>;

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,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.3.10",
+  "version": "1.4.0",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {
@@ -19,7 +19,6 @@
     "prepublishOnly": "npm test && npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
     "@modelcontextprotocol/sdk": "^1.28.0",
     "@whiskeysockets/baileys": "^6.7.0",
     "better-sqlite3": "^12.8.0",

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