beecork 1.6.0 → 1.7.1

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

@@ -0,0 +1,9 @@
+import type { RouteDecision, Project } from './types.js';
+export declare class PipeAnthropicClient {
+    private client;
+    private routingModel;
+    constructor(apiKey: string, routingModel: string);
+    /** Route a message to the right project/tab (Haiku — fast, cheap) */
+    route(message: string, projects: Project[], recentRouting: string[]): Promise<RouteDecision>;
+    private complete;
+}

package/dist/pipe/anthropic-client.js

@@ -0,0 +1,50 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { logger } from '../util/logger.js';
+import { retryWithBackoff } from '../util/retry.js';
+export class PipeAnthropicClient {
+    client;
+    routingModel;
+    constructor(apiKey, routingModel) {
+        this.client = new Anthropic({ apiKey });
+        this.routingModel = routingModel;
+    }
+    /** 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);
+        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 };
+        }
+    }
+    async complete(systemPrompt, userMessage) {
+        try {
+            const response = await retryWithBackoff(() => this.client.messages.create({
+                model: this.routingModel,
+                max_tokens: 500,
+                system: systemPrompt,
+                messages: [{ role: 'user', content: userMessage }],
+            }, { timeout: 30000 }), [1000, 5000, 15000], `Pipe API call (routing)`);
+            const textBlock = response.content.find(b => b.type === 'text');
+            return textBlock?.text ?? '';
+        }
+        catch (err) {
+            logger.error(`Pipe API call failed (routing):`, err);
+            throw err;
+        }
+    }
+}

package/dist/pipe/brain.d.ts

@@ -0,0 +1,16 @@
+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;
+    constructor(config: BeecorkConfig, tabManager: TabManager);
+    /** Main entry point: route a message to the right tab and send it to Claude. */
+    process(message: string, _context: ChatContext): Promise<PipeResult>;
+    /** Route a message to the right project/tab */
+    private route;
+    /** Discover projects on the filesystem */
+    discoverProjects(): Promise<number>;
+}

package/dist/pipe/brain.js

@@ -0,0 +1,89 @@
+import { PipeAnthropicClient } from './anthropic-client.js';
+import { PipeMemoryStore } from './memory-store.js';
+import { scanForProjects } from './project-scanner.js';
+import { parseTabMessage } from '../util/text.js';
+import { logger } from '../util/logger.js';
+export class PipeBrain {
+    client;
+    memory;
+    config;
+    tabManager;
+    constructor(config, tabManager) {
+        this.config = config;
+        this.tabManager = tabManager;
+        this.client = new PipeAnthropicClient(config.pipe.anthropicApiKey, config.pipe.routingModel);
+        this.memory = new PipeMemoryStore();
+    }
+    /** Main entry point: route a message to the right tab and send it to Claude. */
+    async process(message, _context) {
+        const decisions = [];
+        // Step 1: Route the message to the right tab/project
+        const route = await this.route(message, decisions);
+        // Step 2: Ensure the tab exists with the right working directory
+        if (route.projectPath) {
+            this.tabManager.ensureTab(route.tabName, route.projectPath);
+            this.memory.updateProjectLastUsed(route.projectPath);
+        }
+        // Step 3: Send to Claude Code
+        let result;
+        try {
+            result = await this.tabManager.sendMessage(route.tabName, message, { projectPath: route.projectPath ?? undefined });
+        }
+        catch (err) {
+            return {
+                tabName: route.tabName,
+                response: { text: `Error: ${err instanceof Error ? err.message : err}`, error: true, costUsd: 0, durationMs: 0 },
+                decisions,
+            };
+        }
+        return {
+            tabName: route.tabName,
+            response: { text: result.text, error: result.error, costUsd: result.costUsd, durationMs: result.durationMs },
+            decisions,
+        };
+    }
+    /** Route a message to the right project/tab */
+    async route(message, decisions) {
+        // Check for manual /tab override first
+        if (message.startsWith('/tab ')) {
+            const parsed = parseTabMessage(message);
+            if (parsed.tabName !== 'default') {
+                decisions.push(`📌 Manual routing to "${parsed.tabName}"`);
+                return { tabName: parsed.tabName, projectPath: null, confidence: 1.0, reason: 'Manual override', needsConfirmation: false };
+            }
+        }
+        const projects = this.memory.getProjects();
+        const recentRouting = this.memory.getRecentRouting(5);
+        // If no projects and no API key, just use default
+        if (projects.length === 0 || !this.config.pipe.anthropicApiKey) {
+            decisions.push('📍 Routing to default tab (no projects discovered)');
+            return { tabName: 'default', projectPath: null, confidence: 1.0, reason: 'No projects', needsConfirmation: false };
+        }
+        try {
+            const route = await this.client.route(message, projects, recentRouting);
+            // Record the routing decision
+            this.memory.recordRouting(message, route.tabName, route.projectPath, route.confidence);
+            if (route.confidence >= this.config.pipe.confidenceThreshold) {
+                decisions.push(`🧠 Routing to "${route.tabName}" (${Math.round(route.confidence * 100)}% confidence) — ${route.reason}`);
+            }
+            else {
+                decisions.push(`🤔 Low confidence routing to "${route.tabName}" (${Math.round(route.confidence * 100)}%) — ${route.reason}. Using default.`);
+                route.tabName = 'default';
+            }
+            return route;
+        }
+        catch (err) {
+            logger.error('Pipe routing failed, using default:', err);
+            decisions.push('⚠️ Routing failed, using default tab');
+            return { tabName: 'default', projectPath: null, confidence: 0.5, reason: 'Routing error', needsConfirmation: false };
+        }
+    }
+    /** Discover projects on the filesystem */
+    async discoverProjects() {
+        const projects = scanForProjects(this.config.pipe.projectScanPaths);
+        for (const project of projects) {
+            this.memory.upsertProject(project);
+        }
+        return projects.length;
+    }
+}

package/dist/pipe/memory-store.d.ts

@@ -0,0 +1,8 @@
+import type { Project } from './types.js';
+export declare class PipeMemoryStore {
+    getProjects(): Project[];
+    upsertProject(project: Project): void;
+    updateProjectLastUsed(path: string): void;
+    getRecentRouting(limit?: number): string[];
+    recordRouting(messagePreview: string, tabName: string, projectPath: string | null, confidence: number): void;
+}

package/dist/pipe/memory-store.js

@@ -0,0 +1,39 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+export class PipeMemoryStore {
+    // ─── Projects ───
+    getProjects() {
+        const db = getDb();
+        const rows = db.prepare('SELECT * FROM projects ORDER BY last_used_at DESC NULLS LAST').all();
+        return rows.map(r => ({
+            id: r.id,
+            name: r.name,
+            path: r.path,
+            type: r.type || 'user-project',
+            lastUsedAt: r.last_used_at,
+            createdAt: r.created_at,
+        }));
+    }
+    upsertProject(project) {
+        const db = getDb();
+        db.prepare(`INSERT INTO projects (id, name, path, type)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET
+        path=excluded.path, type=excluded.type, last_used_at=datetime('now')
+    `).run(project.id || uuidv4(), project.name, project.path, project.type || 'user-project');
+    }
+    updateProjectLastUsed(path) {
+        const db = getDb();
+        db.prepare('UPDATE projects SET last_used_at = datetime("now") WHERE path = ?').run(path);
+    }
+    // ─── Routing History ───
+    getRecentRouting(limit = 10) {
+        const db = getDb();
+        const rows = db.prepare('SELECT message_preview, tab_name, confidence FROM routing_history ORDER BY created_at DESC LIMIT ?').all(limit);
+        return rows.map(r => `"${r.message_preview}" → ${r.tab_name} (${Math.round(r.confidence * 100)}%)`);
+    }
+    recordRouting(messagePreview, tabName, projectPath, confidence) {
+        const db = getDb();
+        db.prepare('INSERT INTO routing_history (message_preview, tab_name, project_path, confidence) VALUES (?, ?, ?, ?)').run(messagePreview.slice(0, 200), tabName, projectPath, confidence);
+    }
+}

package/dist/pipe/project-scanner.d.ts

@@ -0,0 +1,6 @@
+import type { Project } from './types.js';
+/**
+ * Read projects from the database (populated by discoverProjects() at daemon startup).
+ * Falls back to an empty list if the DB is not yet initialized.
+ */
+export declare function scanForProjects(_scanPaths: string[]): Project[];

package/dist/pipe/project-scanner.js

@@ -0,0 +1,26 @@
+import { getDb } from '../db/index.js';
+import { logger } from '../util/logger.js';
+/**
+ * Read projects from the database (populated by discoverProjects() at daemon startup).
+ * Falls back to an empty list if the DB is not yet initialized.
+ */
+export function scanForProjects(_scanPaths) {
+    try {
+        const db = getDb();
+        const rows = db.prepare('SELECT * FROM projects ORDER BY last_used_at DESC').all();
+        const projects = rows.map(r => ({
+            id: r.id,
+            name: r.name,
+            path: r.path,
+            type: r.type,
+            lastUsedAt: r.last_used_at,
+            createdAt: r.created_at,
+        }));
+        logger.info(`Project scanner: found ${projects.length} projects from DB`);
+        return projects;
+    }
+    catch (err) {
+        logger.warn('Project scanner: failed to read from DB, returning empty list:', err);
+        return [];
+    }
+}

package/dist/pipe/types.d.ts

@@ -0,0 +1,34 @@
+export interface Project {
+    id: string;
+    name: string;
+    path: string;
+    type: string;
+    lastUsedAt: string;
+    createdAt: string;
+    /** Populated at scan time, not persisted in DB */
+    description?: string;
+    /** Populated at scan time, not persisted in DB */
+    languages?: string[];
+}
+export interface RouteDecision {
+    tabName: string;
+    projectPath: string | null;
+    confidence: number;
+    reason: string;
+    needsConfirmation: boolean;
+}
+export interface ChatContext {
+    chatId: number;
+    userId: number;
+    messageId: number;
+}
+export interface PipeResult {
+    tabName: string;
+    response: {
+        text: string;
+        error: boolean;
+        costUsd: number;
+        durationMs: number;
+    };
+    decisions: string[];
+}

package/dist/pipe/types.js

@@ -0,0 +1 @@
+export {};

package/dist/session/manager.js

@@ -273,6 +273,43 @@ export class TabManager {
                             .catch(reject);
                         return;
                     }
+                    // Silent network-stall recovery. The startup watchdog killed a
+                    // subprocess that never emitted a single event — almost always a
+                    // transient overnight DNS/connection blip that recovers within
+                    // seconds. Mirror the stale-session retry above (capped by retryDepth)
+                    // so a blip recovers inside a single fire instead of burning the full
+                    // maxRuntime and counting toward the 5-failure auto-disable.
+                    if (subprocess.killReason === 'silent') {
+                        if (retryDepth === 0) {
+                            logger.warn(`[${tab.name}] Subprocess produced no output (suspected transient network stall) — retrying once.`);
+                            // Don't touch the session — the subprocess may never have
+                            // initialized one. Retry with identical args.
+                            this.executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth, forceFresh, retryDepth + 1)
+                                .then(resolve)
+                                .catch(reject);
+                            return;
+                        }
+                        // Retry already attempted and it stalled again — surface a
+                        // network-specific failure instead of an empty "(no output)" so the
+                        // user checks connectivity, not their auth/subscription. Resolve
+                        // (not reject) with error:true; the scheduler counts this toward
+                        // auto-disable exactly like the maxRuntime path, and reports it via
+                        // the existing task-failure notification.
+                        logger.warn(`[${tab.name}] Still no output after retry — surfacing suspected network stall.`);
+                        db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?').run('idle', new Date().toISOString(), tab.name);
+                        logActivity('task_failed', 'Subprocess silent stall (retry exhausted)', {
+                            tabName: tab.name,
+                        });
+                        resolve({
+                            text: 'Subprocess produced no output, even after a retry — suspected network/DNS stall. Check connectivity.',
+                            costUsd: 0,
+                            durationMs: 0,
+                            sessionId: subprocess.sessionId,
+                            error: true,
+                        });
+                        this.processNextInQueue(tab.name);
+                        return;
+                    }
                     // Store assistant response. Skip empty content (typically failed/error runs) so
                     // it doesn't trigger the hasDbHistory shouldResume override on future calls.
                     if (result.text.trim() !== '') {

package/dist/session/subprocess.d.ts

@@ -15,6 +15,13 @@ export declare class ClaudeSubprocess {
     private buffer;
     private killTimer;
     private runtimeTimer;
+    private startupTimer;
+    /**
+     * Set when the startup watchdog kills a subprocess that never emitted a
+     * single event — distinguishes a transient network/connection stall from a
+     * normal exit or a real wall-clock overrun, so the manager can retry once.
+     */
+    killReason: 'silent' | null;
     readonly sessionId: string;
     constructor(tabName: string, workingDir: string, config: BeecorkConfig, sessionId?: string, tabSystemPrompt?: string | null | undefined);
     send(prompt: string, callbacks: SubprocessCallbacks, resume?: boolean): Promise<void>;

package/dist/session/subprocess.js

@@ -45,6 +45,13 @@ export class ClaudeSubprocess {
     buffer = '';
     killTimer = null;
     runtimeTimer = null;
+    startupTimer = null;
+    /**
+     * Set when the startup watchdog kills a subprocess that never emitted a
+     * single event — distinguishes a transient network/connection stall from a
+     * normal exit or a real wall-clock overrun, so the manager can retry once.
+     */
+    killReason = null;
     sessionId;
     constructor(tabName, workingDir, config, sessionId, tabSystemPrompt) {
         this.tabName = tabName;
@@ -75,6 +82,14 @@ export class ClaudeSubprocess {
                     continue;
                 try {
                     const event = JSON.parse(line);
+                    // First real event proves claude initialized and the socket is alive
+                    // — the startup-stall window is over, so disarm the watchdog for good.
+                    // It never re-arms, so legitimate multi-minute tool runs (which emit
+                    // nothing on stdout until the tool returns) are never killed.
+                    if (this.startupTimer) {
+                        clearTimeout(this.startupTimer);
+                        this.startupTimer = null;
+                    }
                     callbacks.onEvent(event);
                 }
                 catch {
@@ -99,6 +114,10 @@ export class ClaudeSubprocess {
                 clearTimeout(this.runtimeTimer);
                 this.runtimeTimer = null;
             }
+            if (this.startupTimer) {
+                clearTimeout(this.startupTimer);
+                this.startupTimer = null;
+            }
             callbacks.onError(err);
         });
         this.proc.on('exit', (code) => {
@@ -111,6 +130,10 @@ export class ClaudeSubprocess {
                 clearTimeout(this.runtimeTimer);
                 this.runtimeTimer = null;
             }
+            if (this.startupTimer) {
+                clearTimeout(this.startupTimer);
+                this.startupTimer = null;
+            }
             logger.info(`[${this.tabName}] Claude subprocess exited (code: ${code})`);
             callbacks.onExit(code);
         });
@@ -126,6 +149,24 @@ export class ClaudeSubprocess {
                 this.kill();
             }, maxRuntimeMs);
         }
+        // Startup watchdog. A healthy claude emits its init event within seconds of
+        // spawn. Total silence this long means it wedged on a stalled network socket
+        // (DNS/connection blip with no client-side timeout) and would otherwise sit
+        // idle until the 30-min maxRuntime kill. Unlike maxRuntime, this routes
+        // through onExit (kill only, no onError) so the manager retries once. It is
+        // disarmed on the first event, so it can only fire before claude initializes
+        // — long-running tools, which emit nothing on stdout until they return, are
+        // never affected.
+        const silentTimeoutMs = this.config.claudeCode.silentTimeoutMs ?? 120_000;
+        if (silentTimeoutMs > 0) {
+            this.startupTimer = setTimeout(() => {
+                if (!this.proc)
+                    return;
+                logger.warn(`[${this.tabName}] No output ${silentTimeoutMs}ms after spawn — killing as silent network stall`);
+                this.killReason = 'silent';
+                this.kill();
+            }, silentTimeoutMs);
+        }
     }
     kill() {
         if (!this.proc)

package/dist/session/tool-classifier.d.ts

@@ -0,0 +1,4 @@
+/** Reserved for future approval mode implementation. Not currently wired into the runtime. */
+export type ToolRisk = 'safe' | 'dangerous';
+/** Classify a tool call as safe or dangerous */
+export declare function classifyTool(toolName: string, input: Record<string, unknown>): ToolRisk;

package/dist/session/tool-classifier.js

@@ -0,0 +1,56 @@
+const SAFE_TOOLS = new Set([
+    'Read', 'Glob', 'Grep', 'LSP', 'WebFetch', 'WebSearch',
+    'ToolSearch', 'TaskGet', 'TaskList',
+]);
+const DANGEROUS_TOOLS = new Set([
+    'Write', 'Edit', 'NotebookEdit',
+    'TaskCreate', 'TaskUpdate', 'TaskStop',
+]);
+const SAFE_BASH_PATTERNS = [
+    /^(ls|cat|head|tail|wc|file|stat|which|type|echo|printf)\b/,
+    /^git\s+(status|log|diff|show|branch|tag|remote)\b/,
+    /^(pwd|whoami|hostname|date|uname|env|printenv)\b/,
+    /^(find|grep|rg|fd|ag)\b/,
+    /^(node|python|ruby|go)\s+--?(version|help)/,
+    /^npm\s+(list|ls|view|info|outdated|audit)\b/,
+    /^curl\s.*-X\s*GET\b/,
+    /^curl\s+(?!.*-X\s*(POST|PUT|DELETE|PATCH))(?!.*--data)(?!.*-d\s)/,
+];
+const DANGEROUS_BASH_PATTERNS = [
+    /^rm\b/,
+    /^(mv|cp)\b.*--?(force|f)\b/,
+    /^chmod\b/,
+    /^chown\b/,
+    /^git\s+(push|reset|rebase|merge|checkout\s+--)\b/,
+    /^(docker|kubectl|terraform|ansible)\b/,
+    /^(sudo|su)\b/,
+    /^npm\s+(publish|install|uninstall|link)\b/,
+    /^(kill|killall|pkill)\b/,
+    /^curl\s.*-X\s*(POST|PUT|DELETE|PATCH)\b/,
+];
+/** Classify a tool call as safe or dangerous */
+export function classifyTool(toolName, input) {
+    if (SAFE_TOOLS.has(toolName))
+        return 'safe';
+    if (DANGEROUS_TOOLS.has(toolName))
+        return 'dangerous';
+    // Bash tool: inspect the command
+    if (toolName === 'Bash') {
+        const command = String(input.command || '').trim();
+        for (const pattern of SAFE_BASH_PATTERNS) {
+            if (pattern.test(command))
+                return 'safe';
+        }
+        for (const pattern of DANGEROUS_BASH_PATTERNS) {
+            if (pattern.test(command))
+                return 'dangerous';
+        }
+        // Default: unknown bash commands are dangerous
+        return 'dangerous';
+    }
+    // MCP tools from external servers: default to dangerous
+    if (toolName.startsWith('mcp__'))
+        return 'dangerous';
+    // Unknown tools: default to dangerous
+    return 'dangerous';
+}

package/dist/types.d.ts

@@ -10,6 +10,15 @@ export interface ClaudeCodeConfig {
     computerUse?: boolean;
     /** Hard timeout per subprocess turn. Default 30 min. Set to 0 to disable. */
     maxRuntimeMs?: number;
+    /**
+     * Startup watchdog: kill (and retry once) a subprocess that produces ZERO
+     * events this long after spawn. A healthy claude emits its init event within
+     * seconds; prolonged total silence means it wedged on a stalled network
+     * socket (DNS/connection blip with no client-side timeout). Default 2 min.
+     * Set to 0 to disable. Disarms on the first event, so it never fires
+     * mid-task — long-running tools are unaffected.
+     */
+    silentTimeoutMs?: number;
 }
 export interface MemoryConfig {
     dbPath: string;

package/dist/users/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';
+export type { User } from './service.js';

package/dist/users/index.js

@@ -0,0 +1 @@
+export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';

package/dist/users/service.d.ts

@@ -0,0 +1,17 @@
+export interface User {
+    id: string;
+    name: string;
+    role: 'admin' | 'user';
+    budgetUsd: number | null;
+    createdAt: string;
+}
+/** Get or create a user from a channel identity */
+export declare function resolveUser(channelId: string, peerId: string): User | null;
+/** Register a new user */
+export declare function registerUser(name: string, channelId: string, peerId: string, role?: 'admin' | 'user'): User;
+/** Link an additional channel identity to an existing user */
+export declare function linkIdentity(userId: string, channelId: string, peerId: string): boolean;
+/** Get all users */
+export declare function listUsers(): User[];
+/** Check if any admin exists */
+export declare function hasAdmin(): boolean;

package/dist/users/service.js

@@ -0,0 +1,46 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+import { logger } from '../util/logger.js';
+function rowToUser(row) {
+    return { id: row.id, name: row.name, role: row.role, budgetUsd: row.budget_usd, createdAt: row.created_at };
+}
+/** Get or create a user from a channel identity */
+export function resolveUser(channelId, peerId) {
+    const db = getDb();
+    const identity = db.prepare('SELECT user_id FROM identities WHERE channel_id = ? AND peer_id = ?').get(channelId, peerId);
+    if (!identity)
+        return null;
+    const row = db.prepare('SELECT * FROM users WHERE id = ?').get(identity.user_id);
+    return row ? rowToUser(row) : null;
+}
+/** Register a new user */
+export function registerUser(name, channelId, peerId, role = 'user') {
+    const db = getDb();
+    const id = uuidv4();
+    db.prepare('INSERT INTO users (id, name, role) VALUES (?, ?, ?)').run(id, name, role);
+    db.prepare('INSERT INTO identities (user_id, channel_id, peer_id) VALUES (?, ?, ?)').run(id, channelId, peerId);
+    logger.info(`User registered: ${name} (${role}) via ${channelId}:${peerId}`);
+    return { id, name, role, budgetUsd: null, createdAt: new Date().toISOString() };
+}
+/** Link an additional channel identity to an existing user */
+export function linkIdentity(userId, channelId, peerId) {
+    const db = getDb();
+    try {
+        db.prepare('INSERT INTO identities (user_id, channel_id, peer_id) VALUES (?, ?, ?)').run(userId, channelId, peerId);
+        return true;
+    }
+    catch {
+        return false; // Already linked or conflict
+    }
+}
+/** Get all users */
+export function listUsers() {
+    const db = getDb();
+    return db.prepare('SELECT * FROM users ORDER BY created_at').all().map(rowToUser);
+}
+/** Check if any admin exists */
+export function hasAdmin() {
+    const db = getDb();
+    const row = db.prepare("SELECT COUNT(*) as c FROM users WHERE role = 'admin'").get();
+    return row.c > 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {
@@ -23,29 +23,29 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@whiskeysockets/baileys": "^6.7.0",
-    "better-sqlite3": "^12.8.0",
+    "@whiskeysockets/baileys": "^7.0.0-rc11",
+    "better-sqlite3": "^12.10.0",
     "commander": "^14.0.3",
     "cron-parser": "^5.5.0",
-    "discord.js": "^14.26.2",
+    "discord.js": "^14.26.4",
     "node-telegram-bot-api": "^0.67.0",
-    "pino": "^9.5.0",
+    "pino": "^10.3.1",
     "qrcode-terminal": "^0.12.0",
-    "uuid": "^13.0.0"
+    "uuid": "^14.0.0"
   },
   "devDependencies": {
-    "@tailwindcss/cli": "^4.2.2",
+    "@tailwindcss/cli": "^4.3.0",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^24.0.0",
+    "@types/node": "^24.12.4",
     "@types/node-telegram-bot-api": "^0.64.14",
-    "eslint": "^10.2.0",
+    "eslint": "^10.4.0",
     "eslint-config-prettier": "^10.1.8",
     "prettier": "^3.8.3",
-    "tailwindcss": "^4.2.2",
-    "tsx": "^4.21.0",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.1",
-    "vitest": "^4.1.4"
+    "tailwindcss": "^4.3.0",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^4.1.6"
   },
   "files": [
     "dist/",