beecork 1.5.0 → 1.7.0

package/dist/mcp/handlers.js

@@ -10,15 +10,23 @@ import { getConfig, validateTabNameOrDefault } from '../config.js';
 import { createTabRecord } from '../db/index.js';
 import { MESSAGE_LIMITS } from '../util/text.js';
 import { TabStore } from '../session/tab-store.js';
-export function ok(text) { return { content: [{ type: 'text', text }] }; }
-export function fail(text) { return { content: [{ type: 'text', text }], isError: true }; }
+import { PendingMessageStore } from '../session/pending-store.js';
+import { logActivity } from '../timeline/index.js';
+export function ok(text) {
+    return { content: [{ type: 'text', text }] };
+}
+export function fail(text) {
+    return { content: [{ type: 'text', text }], isError: true };
+}
 /**
  * Convenience wrapper for tools that return structured data — emits pretty-printed
  * JSON inside the standard `text` content. Use for endpoints whose responses are
  * meant to be parsed programmatically (channels, handoff, export_data). Use plain
  * ok() for human-readable lists/summaries.
  */
-export function jsonOk(data) { return ok(JSON.stringify(data, null, 2)); }
+export function jsonOk(data) {
+    return ok(JSON.stringify(data, null, 2));
+}
 const MAX_CONTENT_LENGTH = MESSAGE_LIMITS.MCP_CONTENT;
 const MAX_NAME_LENGTH = 256;
 const VALID_SCHEDULE_TYPES = ['at', 'every', 'cron'];
@@ -28,13 +36,14 @@ async function handleMediaGeneration(ctx, mediaType, args) {
         return fail('Missing prompt');
     const generators = await ctx.getGenerators();
     const gen = provider
-        ? generators.find(g => g.id === provider)
-        : generators.find(g => g.supportedTypes.includes(mediaType));
+        ? generators.find((g) => g.id === provider)
+        : generators.find((g) => g.supportedTypes.includes(mediaType));
     if (!gen)
         return fail(`No ${mediaType} generator configured. Run: beecork media`);
     try {
         const result = await gen.generate(mediaType, prompt, { style, duration });
-        ctx.db.prepare('INSERT INTO pending_messages (tab_name, message, type) VALUES (?, ?, ?)').run('default', JSON.stringify({ type: 'media', filePath: result.filePath, caption: prompt.slice(0, 200) }), 'media');
+        PendingMessageStore.enqueueMedia('default', { type: 'media', filePath: result.filePath, caption: prompt.slice(0, 200) }, ctx.db);
+        logActivity('media_generated', `${mediaType} generated`, { details: result.filePath });
         return ok(`Generated ${mediaType}: ${result.filePath}`);
     }
     catch (err) {
@@ -50,18 +59,25 @@ export const HANDLERS = {
         if (scope && scope !== 'tab' && scope !== 'auto') {
             const { addKnowledge } = await import('../knowledge/index.js');
             const currentTab = TabStore.mostRecent(ctx.db);
-            addKnowledge(content, scope, { category, projectPath: currentTab?.workingDir, tabName: undefined });
+            addKnowledge(content, scope, {
+                category,
+                projectPath: currentTab?.workingDir,
+                tabName: undefined,
+            });
             return ok(`Remembered (${scope}): ${content.slice(0, 100)}`);
         }
         const fullContent = category ? `[${category}] ${content}` : content;
-        const existing = ctx.db.prepare('SELECT id FROM memories WHERE content = ? AND tab_name IS NULL LIMIT 1').get(fullContent);
+        const existing = ctx.db
+            .prepare('SELECT id FROM memories WHERE content = ? AND tab_name IS NULL LIMIT 1')
+            .get(fullContent);
         if (existing)
             return ok(`Already remembered: "${fullContent}"`);
-        ctx.db.prepare('INSERT INTO memories (content, source) VALUES (?, ?)').run(fullContent, 'tool');
+        const { MemoryStore } = await import('../session/memory-store.js');
+        MemoryStore.add(fullContent, { source: 'tool' }, ctx.db);
         return ok(`Remembered: "${fullContent}"`);
     },
     beecork_task_create: async (ctx, args) => {
-        const { name: jobName, scheduleType, schedule, message, tabName } = (args || {});
+        const { name: jobName, scheduleType, schedule, message, tabName, } = (args || {});
         if (!jobName || jobName.length > MAX_NAME_LENGTH) {
             return fail(`Task name is required and must be under ${MAX_NAME_LENGTH} characters.`);
         }
@@ -81,8 +97,20 @@ export const HANDLERS = {
         const scheduleErr = validateSchedule(scheduleType, schedule);
         if (scheduleErr)
             return fail(scheduleErr);
-        ctx.db.prepare(`INSERT INTO tasks (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, 'agentTurn', 1, ?)`).run(id, jobName, scheduleType, schedule, tab, message, new Date().toISOString());
+        const { TaskStore } = await import('../tasks/store.js');
+        new TaskStore().add({
+            id,
+            name: jobName,
+            scheduleType: scheduleType,
+            schedule,
+            tabName: tab,
+            message,
+            payloadType: 'agentTurn',
+            enabled: true,
+            createdAt: new Date().toISOString(),
+            lastRunAt: null,
+            nextRunAt: null,
+        });
         try {
             ctx.signalCronReload();
         }
@@ -95,7 +123,7 @@ export const HANDLERS = {
         const jobs = ctx.db.prepare('SELECT * FROM tasks ORDER BY created_at LIMIT 500').all();
         if (jobs.length === 0)
             return ok('No tasks scheduled.');
-        const lines = jobs.map(j => `- ${j.name} [${j.enabled ? 'enabled' : 'disabled'}] (${j.schedule_type}: ${j.schedule}) -> tab:${j.tab_name} (ID: ${j.id})`);
+        const lines = jobs.map((j) => `- ${j.name} [${j.enabled ? 'enabled' : 'disabled'}] (${j.schedule_type}: ${j.schedule}) -> tab:${j.tab_name} (ID: ${j.id})`);
         return ok(lines.join('\n'));
     },
     beecork_task_delete: async (ctx, args) => {
@@ -106,7 +134,9 @@ export const HANDLERS = {
         try {
             ctx.signalCronReload();
         }
-        catch { /* daemon picks up on restart */ }
+        catch {
+            /* daemon picks up on restart */
+        }
         return ok(`Deleted task: ${id}`);
     },
     beecork_watch_create: async (ctx, args) => {
@@ -127,8 +157,10 @@ export const HANDLERS = {
         if (cronErr && intervalErr)
             return fail(`Invalid schedule "${watchSchedule}" — must be a cron expression or interval like "5m"/"1h"/"1d".`);
         const watchId = uuidv4();
-        ctx.db.prepare(`INSERT INTO watchers (id, name, description, check_command, condition, action, action_details, schedule)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(watchId, watchName, watchDesc || null, checkCommand, condition, action || 'notify', actionDetails || null, watchSchedule);
+        ctx.db
+            .prepare(`INSERT INTO watchers (id, name, description, check_command, condition, action, action_details, schedule)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(watchId, watchName, watchDesc || null, checkCommand, condition, action || 'notify', actionDetails || null, watchSchedule);
         try {
             ctx.signalWatcherReload();
         }
@@ -138,10 +170,12 @@ export const HANDLERS = {
         return ok(`Watcher created: "${watchName}" (${watchSchedule})\nID: ${watchId}`);
     },
     beecork_watch_list: async (ctx) => {
-        const watchers = ctx.db.prepare('SELECT * FROM watchers ORDER BY created_at LIMIT 500').all();
+        const watchers = ctx.db
+            .prepare('SELECT * FROM watchers ORDER BY created_at LIMIT 500')
+            .all();
         if (watchers.length === 0)
             return ok('No watchers configured.');
-        const watchLines = watchers.map(w => `- ${w.name} [${w.enabled ? 'enabled' : 'disabled'}] ${w.schedule} | action: ${w.action} | triggers: ${w.trigger_count} (ID: ${w.id})`);
+        const watchLines = watchers.map((w) => `- ${w.name} [${w.enabled ? 'enabled' : 'disabled'}] ${w.schedule} | action: ${w.action} | triggers: ${w.trigger_count} (ID: ${w.id})`);
         return ok(watchLines.join('\n'));
     },
     beecork_watch_delete: async (ctx, args) => {
@@ -152,11 +186,13 @@ export const HANDLERS = {
         try {
             ctx.signalWatcherReload();
         }
-        catch { /* daemon picks up on restart */ }
+        catch {
+            /* daemon picks up on restart */
+        }
         return ok(`Deleted watcher: ${watchDelId}`);
     },
     beecork_tab_create: async (ctx, args) => {
-        const { name: tabName, workingDir, template: templateName, systemPrompt } = (args || {});
+        const { name: tabName, workingDir, template: templateName, systemPrompt, } = (args || {});
         if (!tabName)
             return fail('Tab name is required.');
         // tab create does NOT allow "default" — that tab is auto-managed by the daemon.
@@ -174,7 +210,11 @@ export const HANDLERS = {
         const tabSystemPrompt = systemPrompt || template?.systemPrompt || null;
         try {
             // createTabRecord validates existence + isDirectory and throws on failure.
-            const result = createTabRecord(ctx.db, { name: tabName, workingDir: dir, systemPrompt: tabSystemPrompt });
+            const result = createTabRecord(ctx.db, {
+                name: tabName,
+                workingDir: dir,
+                systemPrompt: tabSystemPrompt,
+            });
             if (!result.created)
                 return ok(`Tab "${tabName}" already exists.`);
             const parts = [`Created tab: "${tabName}" (working dir: ${dir})`];
@@ -192,7 +232,7 @@ export const HANDLERS = {
         const tabs = TabStore.listAll(ctx.db);
         if (tabs.length === 0)
             return ok('No tabs.');
-        const lines = tabs.map(t => `- ${t.name} [${t.status}] dir:${t.workingDir} last:${t.lastActivityAt}`);
+        const lines = tabs.map((t) => `- ${t.name} [${t.status}] dir:${t.workingDir} last:${t.lastActivityAt}`);
         return ok(lines.join('\n'));
     },
     beecork_send_message: async (ctx, args) => {
@@ -205,18 +245,24 @@ export const HANDLERS = {
         if (message.length > MAX_CONTENT_LENGTH) {
             return fail(`Message must be under ${MAX_CONTENT_LENGTH} characters.`);
         }
-        ctx.db.prepare('INSERT INTO pending_messages (tab_name, message) VALUES (?, ?)').run(tabName, message);
+        PendingMessageStore.enqueueUser(tabName, message, ctx.db);
         return ok(`Message queued for tab "${tabName}".`);
     },
     beecork_recall: async (ctx, args) => {
         const { query, limit } = (args || {});
-        const maxResults = Math.min(limit ?? 10, 50);
-        const memories = ctx.db.prepare('SELECT content, tab_name, source, created_at FROM memories WHERE content LIKE ? ORDER BY created_at DESC LIMIT ?').all(`%${query}%`, maxResults);
+        if (typeof query !== 'string' || query.length === 0)
+            return fail('query is required');
+        if (query.length > 256)
+            return fail('query is too long (max 256 chars)');
+        const maxResults = Math.min(typeof limit === 'number' && limit > 0 ? limit : 10, 50);
+        const memories = ctx.db
+            .prepare('SELECT content, tab_name, source, created_at FROM memories WHERE content LIKE ? ORDER BY created_at DESC LIMIT ?')
+            .all(`%${query}%`, maxResults);
         const { searchKnowledge } = await import('../knowledge/index.js');
         const knowledgeResults = searchKnowledge(query);
         const allResults = [
-            ...knowledgeResults.map(k => k.content),
-            ...memories.map(m => m.content),
+            ...knowledgeResults.map((k) => k.content),
+            ...memories.map((m) => m.content),
         ];
         if (allResults.length === 0)
             return ok(`No relevant knowledge found matching "${query}".`);
@@ -227,7 +273,7 @@ export const HANDLERS = {
         if (!message)
             return fail('Message is required.');
         const prefix = urgent ? '🚨 ' : '';
-        ctx.db.prepare("INSERT INTO pending_messages (tab_name, message, type) VALUES ('_notify', ?, 'notification')").run(prefix + message);
+        PendingMessageStore.enqueueNotification(prefix + message, ctx.db);
         return ok('Notification sent to user.');
     },
     beecork_status: async (ctx) => {
@@ -245,11 +291,21 @@ export const HANDLERS = {
     },
     beecork_send_media: async (ctx, args) => {
         const { filePath, caption, tabName } = (args || {});
-        if (!fs.existsSync(filePath))
-            return fail(`File not found: ${filePath}`);
+        if (!filePath)
+            return fail('filePath is required');
+        let resolved;
+        try {
+            const { assertInsideMediaDir } = await import('../media/store.js');
+            resolved = assertInsideMediaDir(filePath);
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : String(err));
+        }
+        if (!fs.existsSync(resolved))
+            return fail(`File not found: ${resolved}`);
         const tab = tabName || 'default';
-        ctx.db.prepare('INSERT INTO pending_messages (tab_name, message, type) VALUES (?, ?, ?)').run(tab, JSON.stringify({ type: 'media', filePath, caption }), 'media');
-        return ok(`Media queued for sending: ${filePath}`);
+        PendingMessageStore.enqueueMedia(tab, { type: 'media', filePath: resolved, caption }, ctx.db);
+        return ok(`Media queued for sending: ${resolved}`);
     },
     beecork_channels: async () => {
         const config = getConfig();
@@ -269,7 +325,7 @@ export const HANDLERS = {
         const { getCostSummary, formatCostSummary } = await import('../observability/analytics.js');
         const summary = getCostSummary();
         if (tabName) {
-            const tab = summary.perTab.find(t => t.name === tabName);
+            const tab = summary.perTab.find((t) => t.name === tabName);
             if (!tab)
                 return fail(`Tab "${tabName}" not found`);
             return ok(`Tab "${tabName}": $${tab.cost.toFixed(4)} (${tab.messages} messages)`);
@@ -277,10 +333,12 @@ export const HANDLERS = {
         return ok(formatCostSummary(summary));
     },
     beecork_failed_deliveries: async (ctx) => {
-        const failed = ctx.db.prepare("SELECT m.content, m.created_at, m.retry_count, t.name as tab_name FROM messages m JOIN tabs t ON t.id = m.tab_id WHERE m.delivery_status = 'failed' ORDER BY m.created_at DESC LIMIT 20").all();
+        const failed = ctx.db
+            .prepare("SELECT m.content, m.created_at, m.retry_count, t.name as tab_name FROM messages m JOIN tabs t ON t.id = m.tab_id WHERE m.delivery_status = 'failed' ORDER BY m.created_at DESC LIMIT 20")
+            .all();
         if (failed.length === 0)
             return ok('No failed deliveries.');
-        const lines = failed.map(f => `[${f.created_at}] tab:${f.tab_name} retries:${f.retry_count}\n  ${f.content.slice(0, 200)}`);
+        const lines = failed.map((f) => `[${f.created_at}] tab:${f.tab_name} retries:${f.retry_count}\n  ${f.content.slice(0, 200)}`);
         return ok(lines.join('\n\n'));
     },
     beecork_activity: async (_ctx, args) => {
@@ -294,10 +352,14 @@ export const HANDLERS = {
         let data;
         switch (dataType) {
             case 'costs':
-                data = ctx.db.prepare("SELECT date(created_at) as day, SUM(cost_usd) as cost, COUNT(*) as messages FROM messages WHERE role = 'assistant' AND created_at > ? GROUP BY date(created_at) ORDER BY day").all(since);
+                data = ctx.db
+                    .prepare("SELECT date(created_at) as day, SUM(cost_usd) as cost, COUNT(*) as messages FROM messages WHERE role = 'assistant' AND created_at > ? GROUP BY date(created_at) ORDER BY day")
+                    .all(since);
                 break;
             case 'messages':
-                data = ctx.db.prepare("SELECT m.role, m.content, m.cost_usd, m.created_at, t.name as tab FROM messages m JOIN tabs t ON t.id = m.tab_id WHERE m.created_at > ? ORDER BY m.created_at DESC LIMIT 500").all(since);
+                data = ctx.db
+                    .prepare('SELECT m.role, m.content, m.cost_usd, m.created_at, t.name as tab FROM messages m JOIN tabs t ON t.id = m.tab_id WHERE m.created_at > ? ORDER BY m.created_at DESC LIMIT 500')
+                    .all(since);
                 break;
             case 'crons':
                 data = ctx.db.prepare('SELECT * FROM tasks ORDER BY created_at').all();
@@ -307,19 +369,22 @@ export const HANDLERS = {
         }
         return jsonOk(data);
     },
-    beecork_handoff: async (ctx, args) => {
+    beecork_handoff: async (_ctx, args) => {
         const { tabName } = (args || {});
-        const tab = TabStore.findByName(tabName, ctx.db);
-        if (!tab)
+        const { exportTab } = await import('../session/handoff.js');
+        const exported = exportTab(tabName);
+        if (!exported)
             return fail(`Tab "${tabName}" not found`);
-        const messages = ctx.db.prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5').all(tab.id);
         const info = {
-            sessionId: tab.sessionId,
-            workingDir: tab.workingDir,
-            status: tab.status,
+            sessionId: exported.sessionId,
+            workingDir: exported.workingDir,
+            status: exported.status,
             resumeCommand: `beecork attach ${tabName}`,
-            manualCommand: `cd ${tab.workingDir} && claude --session-id ${tab.sessionId} --resume`,
-            recentMessages: messages.reverse().map(m => ({ role: m.role, preview: m.content.slice(0, 200) })),
+            manualCommand: `cd ${exported.workingDir} && claude --session-id ${exported.sessionId} --resume`,
+            recentMessages: exported.recentMessages.map((m) => ({
+                role: m.role,
+                preview: m.content.slice(0, 200),
+            })),
         };
         return jsonOk(info);
     },
@@ -328,7 +393,7 @@ export const HANDLERS = {
         try {
             const { createDelegation } = await import('../delegation/manager.js');
             const delegation = createDelegation(returnToTab || 'default', tabName, message, returnToTab);
-            ctx.db.prepare('INSERT INTO pending_messages (tab_name, message, type) VALUES (?, ?, ?)').run(tabName, message, 'delegation');
+            PendingMessageStore.enqueueDelegation(tabName, message, ctx.db);
             return ok(`Delegated to tab "${tabName}". Result will be sent back to "${delegation.returnToTab}" when complete.\n\nDelegation ID: ${delegation.id}`);
         }
         catch (err) {
@@ -341,7 +406,7 @@ export const HANDLERS = {
         const delegations = getPendingDelegations(tabName);
         if (delegations.length === 0)
             return ok('No pending delegations.');
-        const lines = delegations.map(d => `${d.sourceTab} → ${d.targetTab} [${d.status}] (depth ${d.depth})\n  "${d.message.slice(0, 100)}"`);
+        const lines = delegations.map((d) => `${d.sourceTab} → ${d.targetTab} [${d.status}] (depth ${d.depth})\n  "${d.message.slice(0, 100)}"`);
         return ok(lines.join('\n\n'));
     },
     beecork_project_create: async (_ctx, args) => {
@@ -360,7 +425,7 @@ export const HANDLERS = {
         const projects = listProjects();
         if (projects.length === 0)
             return ok('No folders discovered. Create one with beecork_project_create.');
-        const lines = projects.map(p => `${p.type === 'category' ? '📁' : '📦'} ${p.name} — ${p.path}`);
+        const lines = projects.map((p) => `${p.type === 'category' ? '📁' : '📦'} ${p.name} — ${p.path}`);
         return ok(lines.join('\n'));
     },
     beecork_close_tab: async (ctx, args) => {
@@ -380,12 +445,12 @@ export const HANDLERS = {
         const generators = await ctx.getGenerators();
         if (generators.length === 0)
             return ok('No media generators configured. Add mediaGenerators to config.json.');
-        const lines = generators.map(g => `- ${g.name} (${g.id}): ${g.supportedTypes.join(', ')}`);
+        const lines = generators.map((g) => `- ${g.name} (${g.id}): ${g.supportedTypes.join(', ')}`);
         return ok(lines.join('\n'));
     },
     beecork_knowledge: async (ctx, args) => {
         const { scope: knowledgeScope } = (args || {});
-        const { getGlobalKnowledge, getProjectKnowledge, getTabKnowledge, getAllKnowledge, formatKnowledgeForContext } = await import('../knowledge/index.js');
+        const { getGlobalKnowledge, getProjectKnowledge, getTabKnowledge, getAllKnowledge, formatKnowledgeForContext, } = await import('../knowledge/index.js');
         let entries;
         if (knowledgeScope === 'global') {
             entries = getGlobalKnowledge();
@@ -408,13 +473,17 @@ export const HANDLERS = {
     beecork_capabilities: async () => {
         const { getAvailablePacks, isEnabled } = await import('../capabilities/index.js');
         const packs = getAvailablePacks();
-        const lines = packs.map(p => `${isEnabled(p.id) ? '✓ enabled' : '○ available'} | ${p.id} — ${p.name}: ${p.description}`);
+        const lines = packs.map((p) => `${isEnabled(p.id) ? '✓ enabled' : '○ available'} | ${p.id} — ${p.name}: ${p.description}`);
         return ok(lines.join('\n'));
     },
     beecork_history: async (_ctx, args) => {
         const { date, tabName, limit } = (args || {});
         const { getTimeline, formatTimeline } = await import('../timeline/index.js');
-        const events = getTimeline({ date: date || new Date().toISOString().slice(0, 10), tabName, limit });
+        const events = getTimeline({
+            date: date || new Date().toISOString().slice(0, 10),
+            tabName,
+            limit,
+        });
         return ok(formatTimeline(events));
     },
     beecork_replay: async (ctx, args) => {
@@ -423,7 +492,7 @@ export const HANDLERS = {
         const info = getReplayInfo(eventId);
         if (!info)
             return fail('Event not found or not replayable.');
-        ctx.db.prepare('INSERT INTO pending_messages (tab_name, message, type) VALUES (?, ?, ?)').run(info.tabName, info.message, 'replay');
+        PendingMessageStore.enqueueReplay(info.tabName, info.message, ctx.db);
         return ok(`Replaying in tab "${info.tabName}": ${info.message.slice(0, 200)}`);
     },
     beecork_store_search: async (_ctx, args) => {
@@ -432,11 +501,11 @@ export const HANDLERS = {
             const response = await fetch(`https://registry.npmjs.org/-/v1/search?text=beecork+${encodeURIComponent(query)}&size=10`, { signal: AbortSignal.timeout(10000) });
             if (!response.ok)
                 return fail('npm registry search failed');
-            const data = await response.json();
-            const packages = (data.objects || []).filter(o => o.package.name.startsWith('beecork-'));
+            const data = (await response.json());
+            const packages = (data.objects || []).filter((o) => o.package.name.startsWith('beecork-'));
             if (packages.length === 0)
                 return ok(`No beecork packages found for "${query}". You can create one with: beecork channel create <name> or beecork media create <name>`);
-            const lines = packages.map(o => `${o.package.name}@${o.package.version} — ${o.package.description || 'No description'}`);
+            const lines = packages.map((o) => `${o.package.name}@${o.package.version} — ${o.package.description || 'No description'}`);
             return ok(`${packages.length} package(s):\n${lines.join('\n')}\n\nInstall: npm install -g <package-name>`);
         }
         catch {

package/dist/mcp/server.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import Database from 'better-sqlite3';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import fs from 'node:fs';
-import { getDbPath, getCronReloadSignalPath, getWatcherReloadSignalPath, } from '../util/paths.js';
+import { getDbPath, getCronReloadSignalPath, getWatcherReloadSignalPath } from '../util/paths.js';
+import { openDb } from '../db/connection.js';
 import { VERSION } from '../version.js';
 import { TOOL_DEFINITIONS } from './tool-definitions.js';
 import { HANDLERS, fail } from './handlers.js';
+import { validateToolArgs } from './validate.js';
 // MCP server runs as a child of `claude`, not the Beecork daemon.
 // It communicates with the daemon via shared SQLite + signal files.
 // Path helpers from util/paths.ts so daemon + MCP child always agree on locations,
@@ -16,18 +17,17 @@ const DB_PATH = getDbPath();
 const CRON_RELOAD_SIGNAL = getCronReloadSignalPath();
 const WATCHER_RELOAD_SIGNAL = getWatcherReloadSignalPath();
 // Cached singleton connection (lives for the MCP server's lifetime).
+// Pragma setup lives in openDb() so daemon + MCP child + doctor can't drift.
 let cachedDb = null;
 function getDb() {
     if (cachedDb)
         return cachedDb;
-    const db = new Database(DB_PATH);
-    db.pragma('journal_mode = WAL');
-    db.pragma('foreign_keys = ON');
-    db.pragma('busy_timeout = 5000');
-    cachedDb = db;
-    return db;
+    cachedDb = openDb(DB_PATH);
+    return cachedDb;
 }
-process.on('exit', () => { cachedDb?.close(); });
+process.on('exit', () => {
+    cachedDb?.close();
+});
 // Cached media generators (lazy singleton).
 let cachedGenerators = null;
 async function getGenerators() {
@@ -48,11 +48,21 @@ const server = new Server({ name: 'beecork', version: VERSION }, { capabilities:
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOL_DEFINITIONS,
 }));
+// Pre-build a Map for O(1) tool-definition lookup. A typical agent turn fires
+// 10+ tool calls and each one previously walked the 30-entry array.
+const TOOL_DEFINITION_BY_NAME = new Map(TOOL_DEFINITIONS.map((t) => [t.name, t]));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const handler = HANDLERS[name];
     if (!handler)
         return fail(`Unknown tool: ${name}`);
+    // Validate against the declared inputSchema before dispatch. Without this,
+    // handlers had ad-hoc checks for some fields and silently passed-through bad
+    // inputs (NaN limits, unrecognized enum values) for others.
+    const def = TOOL_DEFINITION_BY_NAME.get(name);
+    const validationError = validateToolArgs(def?.inputSchema, args);
+    if (validationError)
+        return fail(validationError);
     try {
         const ctx = {
             db: getDb(),

package/dist/mcp/tool-definitions.js

@@ -4,13 +4,20 @@
 export const TOOL_DEFINITIONS = [
     {
         name: 'beecork_remember',
-        description: 'Store a fact in Beecork\'s long-term memory. Use this for preferences, decisions, server addresses, outcomes, or anything the user might want recalled in future sessions.',
+        description: "Store a fact in Beecork's long-term memory. Use this for preferences, decisions, server addresses, outcomes, or anything the user might want recalled in future sessions.",
         inputSchema: {
             type: 'object',
             properties: {
                 content: { type: 'string', description: 'The fact or information to remember' },
-                scope: { type: 'string', enum: ['global', 'project', 'tab', 'auto'], description: 'Where to store: global (about the user), project (about this folder), tab (about this conversation), or auto (Claude decides)' },
-                category: { type: 'string', description: 'For global scope: people, preferences, routines, or general' },
+                scope: {
+                    type: 'string',
+                    enum: ['global', 'project', 'tab', 'auto'],
+                    description: 'Where to store: global (about the user), project (about this folder), tab (about this conversation), or auto (Claude decides)',
+                },
+                category: {
+                    type: 'string',
+                    description: 'For global scope: people, preferences, routines, or general',
+                },
             },
             required: ['content'],
         },
@@ -27,9 +34,15 @@ export const TOOL_DEFINITIONS = [
                     enum: ['at', 'every', 'cron'],
                     description: '"at" = one-time ISO datetime, "every" = interval like "30m"/"2h"/"1d", "cron" = cron expression like "0 9 * * 1"',
                 },
-                schedule: { type: 'string', description: 'The schedule value (ISO datetime, interval, or cron expression)' },
+                schedule: {
+                    type: 'string',
+                    description: 'The schedule value (ISO datetime, interval, or cron expression)',
+                },
                 message: { type: 'string', description: 'The prompt/message to send when the task fires' },
-                tabName: { type: 'string', description: 'Which tab to send the message to (default: "default")' },
+                tabName: {
+                    type: 'string',
+                    description: 'Which tab to send the message to (default: "default")',
+                },
             },
             required: ['name', 'scheduleType', 'schedule', 'message'],
         },
@@ -86,10 +99,23 @@ export const TOOL_DEFINITIONS = [
                 name: { type: 'string', description: 'Human-readable name for the watcher' },
                 description: { type: 'string', description: 'What to watch (natural language)' },
                 checkCommand: { type: 'string', description: 'Shell command to run for checking' },
-                condition: { type: 'string', description: 'When to trigger: "contains X", "not contains X", "> N", "< N", "any", "error"' },
-                action: { type: 'string', enum: ['notify', 'fix', 'delegate'], description: 'What to do when triggered (default: notify)' },
-                actionDetails: { type: 'string', description: 'For fix: command to run. For delegate: tab name + message.' },
-                schedule: { type: 'string', description: 'How often to check: cron expression or interval like "5m", "1h"' },
+                condition: {
+                    type: 'string',
+                    description: 'When to trigger: "contains X", "not contains X", "> N", "< N", "any", "error"',
+                },
+                action: {
+                    type: 'string',
+                    enum: ['notify', 'fix', 'delegate'],
+                    description: 'What to do when triggered (default: notify)',
+                },
+                actionDetails: {
+                    type: 'string',
+                    description: 'For fix: command to run. For delegate: tab name + message.',
+                },
+                schedule: {
+                    type: 'string',
+                    description: 'How often to check: cron expression or interval like "5m", "1h"',
+                },
             },
             required: ['name', 'checkCommand', 'condition', 'schedule'],
         },
@@ -114,9 +140,18 @@ export const TOOL_DEFINITIONS = [
         inputSchema: {
             type: 'object',
             properties: {
-                name: { type: 'string', description: 'Tab name (alphanumeric + hyphens, max 32 chars). Cannot be "default".' },
-                workingDir: { type: 'string', description: 'Absolute path or ~/path for the tab\'s working directory' },
-                template: { type: 'string', description: 'Name of a tab template from config (sets workingDir + systemPrompt)' },
+                name: {
+                    type: 'string',
+                    description: 'Tab name (alphanumeric + hyphens, max 32 chars). Cannot be "default".',
+                },
+                workingDir: {
+                    type: 'string',
+                    description: "Absolute path or ~/path for the tab's working directory",
+                },
+                template: {
+                    type: 'string',
+                    description: 'Name of a tab template from config (sets workingDir + systemPrompt)',
+                },
                 systemPrompt: { type: 'string', description: 'Tab-specific system prompt for Claude' },
             },
             required: ['name'],
@@ -129,7 +164,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: 'beecork_send_message',
-        description: 'Send a message to another Beecork tab. The message will be processed asynchronously by that tab\'s Claude subprocess.',
+        description: "Send a message to another Beecork tab. The message will be processed asynchronously by that tab's Claude subprocess.",
         inputSchema: {
             type: 'object',
             properties: {
@@ -141,7 +176,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: 'beecork_recall',
-        description: 'Search Beecork\'s memory and knowledge files for facts matching a query.',
+        description: "Search Beecork's memory and knowledge files for facts matching a query.",
         inputSchema: {
             type: 'object',
             properties: {
@@ -170,13 +205,16 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: 'beecork_send_media',
-        description: 'Send a generated or local media file (image/video/audio) through the user\'s channels.',
+        description: "Send a generated or local media file (image/video/audio) through the user's channels.",
         inputSchema: {
             type: 'object',
             properties: {
                 filePath: { type: 'string', description: 'Absolute path to the media file' },
                 caption: { type: 'string', description: 'Optional caption' },
-                tabName: { type: 'string', description: 'Tab to attribute the send to (default: "default")' },
+                tabName: {
+                    type: 'string',
+                    description: 'Tab to attribute the send to (default: "default")',
+                },
             },
             required: ['filePath'],
         },
@@ -213,7 +251,11 @@ export const TOOL_DEFINITIONS = [
         inputSchema: {
             type: 'object',
             properties: {
-                type: { type: 'string', enum: ['costs', 'messages', 'crons'], description: 'What to export' },
+                type: {
+                    type: 'string',
+                    enum: ['costs', 'messages', 'crons'],
+                    description: 'What to export',
+                },
                 days: { type: 'number', description: 'Lookback window in days (default 30)' },
             },
             required: ['type'],
@@ -221,7 +263,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: 'beecork_handoff',
-        description: 'Get info to resume a tab\'s session in your terminal.',
+        description: "Get info to resume a tab's session in your terminal.",
         inputSchema: {
             type: 'object',
             properties: { tabName: { type: 'string' } },
@@ -236,7 +278,10 @@ export const TOOL_DEFINITIONS = [
             properties: {
                 tabName: { type: 'string', description: 'Tab to delegate to' },
                 message: { type: 'string', description: 'The task description' },
-                returnToTab: { type: 'string', description: 'Tab to notify when complete (default: "default")' },
+                returnToTab: {
+                    type: 'string',
+                    description: 'Tab to notify when complete (default: "default")',
+                },
             },
             required: ['tabName', 'message'],
         },
@@ -256,7 +301,10 @@ export const TOOL_DEFINITIONS = [
             type: 'object',
             properties: {
                 name: { type: 'string', description: 'Project name (also the folder name)' },
-                path: { type: 'string', description: 'Optional parent directory (must be under a scan path)' },
+                path: {
+                    type: 'string',
+                    description: 'Optional parent directory (must be under a scan path)',
+                },
             },
             required: ['name'],
         },