beecork 1.2.0 → 1.3.1

package/dist/dashboard/server.js

@@ -1,6 +1,7 @@
 import http from 'node:http';
 import crypto from 'node:crypto';
-import { execFile } from 'node:child_process';
+import { execFile, exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { platform } from 'node:os';
 import Database from 'better-sqlite3';
 import { getDbPath } from '../util/paths.js';
@@ -8,6 +9,7 @@ import { getDashboardHtml } from './html.js';
 import { VERSION } from '../version.js';
 import { getDaemonPid } from '../cli/helpers.js';
 import { validateTabName } from '../config.js';
+import { createTabRecord } from '../db/index.js';
 let cachedDashDb = null;
 function getDashDb() {
     if (!cachedDashDb) {
@@ -16,22 +18,32 @@ function getDashDb() {
     }
     return cachedDashDb;
 }
-function withWriteDb(fn) {
-    const db = new Database(getDbPath());
-    try {
-        return fn(db);
-    }
-    finally {
-        db.close();
+let cachedWriteDb = null;
+function getWriteDb() {
+    if (!cachedWriteDb) {
+        cachedWriteDb = new Database(getDbPath());
+        cachedWriteDb.pragma('journal_mode = WAL');
     }
+    return cachedWriteDb;
+}
+function withWriteDb(fn) {
+    return fn(getWriteDb());
 }
 function json(res, data, status = 200) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
 }
 function openBrowser(url) {
-    const cmd = platform() === 'darwin' ? 'open' : 'xdg-open';
-    execFile(cmd, [url]);
+    const p = platform();
+    if (p === 'darwin') {
+        execFile('open', [url]);
+    }
+    else if (p === 'win32') {
+        execFile('cmd', ['/c', 'start', url]);
+    }
+    else {
+        execFile('xdg-open', [url]);
+    }
 }
 export function startDashboardServer(port = 0) {
     // Generate auth token at server start
@@ -53,7 +65,11 @@ export function startDashboardServer(port = 0) {
                 res.end('Forbidden');
                 return;
             }
-            res.writeHead(200, { 'Content-Type': 'text/html', 'Referrer-Policy': 'no-referrer' });
+            res.writeHead(200, {
+                'Content-Type': 'text/html',
+                'Referrer-Policy': 'no-referrer',
+                'Set-Cookie': `beecork_dash=${authToken}; HttpOnly; SameSite=Strict; Path=/`,
+            });
             res.end(getDashboardHtml(authToken));
             return;
         }
@@ -61,7 +77,8 @@ export function startDashboardServer(port = 0) {
         if (path.startsWith('/api/')) {
             const authHeader = req.headers.authorization;
             const queryToken = url.searchParams.get('token');
-            const providedToken = authHeader?.replace('Bearer ', '') || queryToken;
+            const cookieToken = req.headers.cookie?.split(';').map(c => c.trim()).find(c => c.startsWith('beecork_dash='))?.split('=')[1];
+            const providedToken = authHeader?.replace('Bearer ', '') || queryToken || cookieToken;
             if (providedToken !== authToken) {
                 json(res, { error: 'Unauthorized' }, 401);
                 return;
@@ -115,8 +132,9 @@ export function startDashboardServer(port = 0) {
                     return;
                 }
                 const tabName = decodeURIComponent(path.split('/')[3]);
-                if (!validateTabName(tabName)) {
-                    json(res, { error: 'Invalid tab name' }, 400);
+                const tabErr = validateTabName(tabName);
+                if (tabErr) {
+                    json(res, { error: tabErr }, 400);
                     return;
                 }
                 withWriteDb(db => db.prepare('INSERT INTO pending_messages (tab_name, message, type) VALUES (?, ?, ?)').run(tabName, message, 'user'));
@@ -146,12 +164,12 @@ export function startDashboardServer(port = 0) {
                     json(res, { error: 'Missing tab name' }, 400);
                     return;
                 }
-                if (!validateTabName(name)) {
-                    json(res, { error: 'Invalid tab name' }, 400);
+                const nameErr = validateTabName(name);
+                if (nameErr) {
+                    json(res, { error: nameErr }, 400);
                     return;
                 }
-                const id = crypto.randomUUID();
-                withWriteDb(db => db.prepare('INSERT OR IGNORE INTO tabs (id, name, session_id, status, working_dir, system_prompt) VALUES (?, ?, ?, ?, ?, ?)').run(id, name, crypto.randomUUID(), 'idle', workingDir || process.env.HOME || '/', systemPrompt || null));
+                withWriteDb(db => createTabRecord(db, { name, workingDir, systemPrompt }));
                 json(res, { success: true, name });
                 return;
             }
@@ -168,8 +186,8 @@ export function startDashboardServer(port = 0) {
                 json(res, { success: true });
                 return;
             }
-            // POST: Create cron job
-            if (path === '/api/crons' && req.method === 'POST') {
+            // POST: Create task (supports both /api/tasks and /api/crons)
+            if ((path === '/api/tasks' || path === '/api/crons') && req.method === 'POST') {
                 let body = '';
                 for await (const chunk of req) {
                     body += chunk;
@@ -192,19 +210,33 @@ export function startDashboardServer(port = 0) {
                     return;
                 }
                 const effectiveTab = tabName || 'default';
-                if (!validateTabName(effectiveTab)) {
-                    json(res, { error: 'Invalid tab name' }, 400);
+                const cronTabErr = validateTabName(effectiveTab);
+                if (cronTabErr) {
+                    json(res, { error: cronTabErr }, 400);
                     return;
                 }
                 const id = crypto.randomUUID();
-                withWriteDb(db => db.prepare('INSERT INTO cron_jobs (id, name, schedule_type, schedule, tab_name, message, enabled) VALUES (?, ?, ?, ?, ?, ?, 1)').run(id, name, scheduleType || 'every', schedule, effectiveTab, message));
+                withWriteDb(db => db.prepare('INSERT INTO tasks (id, name, schedule_type, schedule, tab_name, message, enabled) VALUES (?, ?, ?, ?, ?, ?, 1)').run(id, name, scheduleType || 'every', schedule, effectiveTab, message));
                 json(res, { success: true, id });
                 return;
             }
-            // DELETE: Delete cron job
-            if (path.match(/^\/api\/crons\/[^/]+$/) && req.method === 'DELETE') {
-                const cronId = decodeURIComponent(path.split('/')[3]);
-                withWriteDb(db => db.prepare('DELETE FROM cron_jobs WHERE id = ?').run(cronId));
+            // DELETE: Delete task (supports both /api/tasks and /api/crons)
+            if ((path.match(/^\/api\/tasks\/[^/]+$/) || path.match(/^\/api\/crons\/[^/]+$/)) && req.method === 'DELETE') {
+                const taskId = decodeURIComponent(path.split('/')[3]);
+                withWriteDb(db => db.prepare('DELETE FROM tasks WHERE id = ?').run(taskId));
+                json(res, { success: true });
+                return;
+            }
+            // GET: List watchers
+            if (path === '/api/watchers' && req.method === 'GET') {
+                const watchers = getDashDb().prepare('SELECT * FROM watchers ORDER BY created_at').all();
+                json(res, watchers);
+                return;
+            }
+            // DELETE: Delete watcher
+            if (path.match(/^\/api\/watchers\/[^/]+$/) && req.method === 'DELETE') {
+                const watcherId = decodeURIComponent(path.split('/')[3]);
+                withWriteDb(db => db.prepare('DELETE FROM watchers WHERE id = ?').run(watcherId));
                 json(res, { success: true });
                 return;
             }
@@ -268,8 +300,13 @@ export function startDashboardServer(port = 0) {
             }
             if (path === '/api/computer-use' && req.method === 'POST') {
                 let body = '';
-                for await (const chunk of req)
+                for await (const chunk of req) {
                     body += chunk;
+                    if (body.length > 1_000_000) {
+                        json(res, { error: 'Payload too large' }, 413);
+                        return;
+                    }
+                }
                 let parsedCU;
                 try {
                     parsedCU = JSON.parse(body);
@@ -292,12 +329,20 @@ export function startDashboardServer(port = 0) {
                 json(res, { enabled: !!config.claudeCode.computerUse });
                 return;
             }
+            if (path === '/api/timeline') {
+                const { getTimeline } = await import('../timeline/index.js');
+                const date = url.searchParams.get('date') || new Date().toISOString().slice(0, 10);
+                const limit = parseInt(url.searchParams.get('limit') || '50');
+                const events = getTimeline({ date, limit });
+                json(res, { events });
+                return;
+            }
             const db = getDashDb();
             if (path === '/api/status') {
                 const pid = getDaemonPid();
                 const tabCount = db.prepare('SELECT COUNT(*) as c FROM tabs').get().c;
                 const activeCount = db.prepare("SELECT COUNT(*) as c FROM tabs WHERE status = 'running'").get().c;
-                const cronCount = db.prepare("SELECT COUNT(*) as c FROM cron_jobs WHERE enabled = 1").get().c;
+                const cronCount = db.prepare("SELECT COUNT(*) as c FROM tasks WHERE enabled = 1").get().c;
                 const memoryCount = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
                 json(res, { version: VERSION, daemonPid: pid, tabs: tabCount, activeTabs: activeCount, cronJobs: cronCount, memories: memoryCount });
                 return;
@@ -343,8 +388,8 @@ export function startDashboardServer(port = 0) {
                 json(res, { memories, total, limit, offset });
                 return;
             }
-            if (path === '/api/crons' && req.method === 'GET') {
-                const crons = db.prepare('SELECT * FROM cron_jobs ORDER BY created_at').all();
+            if ((path === '/api/tasks' || path === '/api/crons') && req.method === 'GET') {
+                const crons = db.prepare('SELECT * FROM tasks ORDER BY created_at').all();
                 json(res, crons);
                 return;
             }
@@ -362,6 +407,80 @@ export function startDashboardServer(port = 0) {
                 json(res, costs);
                 return;
             }
+            // GET /api/update/status — check versions for beecork, claude code, and other packages
+            if (path === '/api/update/status') {
+                const execAsync = promisify(exec);
+                async function checkPackage(name, installCmd) {
+                    const pkg = { name };
+                    try {
+                        const { stdout } = await execAsync(`${installCmd || name} --version`, { timeout: 10000 });
+                        pkg.installed = stdout.trim().replace(/^v/, '');
+                    }
+                    catch {
+                        pkg.installed = null;
+                    }
+                    try {
+                        const { stdout } = await execAsync(`npm view ${name} version`, { timeout: 10000 });
+                        pkg.latest = stdout.trim();
+                    }
+                    catch {
+                        pkg.latest = null;
+                    }
+                    pkg.updateAvailable = !!(pkg.installed && pkg.latest && pkg.installed !== pkg.latest);
+                    return pkg;
+                }
+                const packages = await Promise.all([
+                    (async () => {
+                        const p = await checkPackage('beecork');
+                        p.installed = VERSION; // use our known version, more reliable
+                        p.updateAvailable = !!(p.latest && p.installed !== p.latest);
+                        return p;
+                    })(),
+                    (async () => {
+                        const p = { name: '@anthropic-ai/claude-code' };
+                        try {
+                            const { stdout } = await execAsync('claude --version', { timeout: 10000 });
+                            p.installed = stdout.trim().replace(/^.*?(\d+\.\d+\.\d+).*$/, '$1');
+                        }
+                        catch {
+                            p.installed = null;
+                        }
+                        try {
+                            const { stdout } = await execAsync('npm view @anthropic-ai/claude-code version', { timeout: 10000 });
+                            p.latest = stdout.trim();
+                        }
+                        catch {
+                            p.latest = null;
+                        }
+                        p.updateAvailable = !!(p.installed && p.latest && p.installed !== p.latest);
+                        return p;
+                    })(),
+                ]);
+                json(res, { packages });
+                return;
+            }
+            // POST /api/update/:package — update a specific package
+            if (path.match(/^\/api\/update\/[^/]+$/) && req.method === 'POST') {
+                const pkgName = decodeURIComponent(path.split('/')[3]);
+                const execAsync = promisify(exec);
+                const allowedPackages = {
+                    'beecork': 'npm install -g beecork@latest',
+                    '@anthropic-ai/claude-code': 'npm install -g @anthropic-ai/claude-code@latest',
+                };
+                const cmd = allowedPackages[pkgName];
+                if (!cmd) {
+                    json(res, { error: `Package "${pkgName}" is not in the allowed update list.` }, 400);
+                    return;
+                }
+                try {
+                    const { stdout } = await execAsync(cmd, { timeout: 120000 });
+                    json(res, { success: true, package: pkgName, output: stdout.trim() });
+                }
+                catch (err) {
+                    json(res, { error: err instanceof Error ? err.message : String(err) }, 500);
+                }
+                return;
+            }
             // GET /api/capabilities — list all packs + enabled status
             if (path === '/api/capabilities') {
                 const { getAvailablePacks, isEnabled } = await import('../capabilities/index.js');
@@ -378,16 +497,29 @@ export function startDashboardServer(port = 0) {
             if (path.match(/^\/api\/capabilities\/[^/]+\/enable$/) && req.method === 'POST') {
                 const packId = path.split('/')[3];
                 let body = '';
-                for await (const chunk of req)
+                for await (const chunk of req) {
                     body += chunk;
-                const { apiKey } = JSON.parse(body);
+                    if (body.length > 1_000_000) {
+                        json(res, { error: 'Payload too large' }, 413);
+                        return;
+                    }
+                }
+                let parsedCap;
+                try {
+                    parsedCap = JSON.parse(body);
+                }
+                catch {
+                    json(res, { error: 'Invalid JSON' }, 400);
+                    return;
+                }
+                const { apiKey } = parsedCap;
                 const { enablePack } = await import('../capabilities/index.js');
                 try {
                     enablePack(packId, apiKey);
                     json(res, { success: true, message: 'Restart daemon to activate.' });
                 }
                 catch (err) {
-                    json(res, { error: err.message }, 400);
+                    json(res, { error: err instanceof Error ? err.message : String(err) }, 400);
                 }
                 return;
             }
@@ -421,4 +553,3 @@ export function startDashboardServer(port = 0) {
         process.exit(0);
     });
 }
-//# sourceMappingURL=server.js.map

package/dist/db/index.d.ts

@@ -1,4 +1,14 @@
 import Database from 'better-sqlite3';
 export declare function getDb(): Database.Database;
+export interface CreateTabOptions {
+    name: string;
+    workingDir?: string;
+    systemPrompt?: string | null;
+}
+/** Shared tab record creation — used by dashboard, MCP, and TabManager */
+export declare function createTabRecord(db: Database.Database, opts: CreateTabOptions): {
+    id: string;
+    name: string;
+    created: boolean;
+};
 export declare function closeDb(): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/db/index.js

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import Database from 'better-sqlite3';
 import { getDbPath, ensureBeecorkDirs } from '../util/paths.js';
 import { runMigrations } from './migrations.js';
@@ -65,6 +66,7 @@ export function getDb() {
             // Prune old routing/permission history (keep last 1000 entries)
             db?.exec('DELETE FROM routing_history WHERE created_at < (SELECT created_at FROM routing_history ORDER BY created_at DESC LIMIT 1 OFFSET 999)');
             db?.exec('DELETE FROM permission_history WHERE created_at < (SELECT created_at FROM permission_history ORDER BY created_at DESC LIMIT 1 OFFSET 999)');
+            db?.exec("DELETE FROM activity_log WHERE created_at < datetime('now', '-90 days')");
         }
         catch (err) {
             logger.warn('WAL checkpoint/cleanup error:', err);
@@ -72,6 +74,16 @@ export function getDb() {
     }, 30 * 60 * 1000); // every 30 minutes
     return db;
 }
+/** Shared tab record creation — used by dashboard, MCP, and TabManager */
+export function createTabRecord(db, opts) {
+    const existing = db.prepare('SELECT name FROM tabs WHERE name = ?').get(opts.name);
+    if (existing)
+        return { id: '', name: opts.name, created: false };
+    const id = crypto.randomUUID();
+    const dir = opts.workingDir || process.env.HOME || '/';
+    db.prepare('INSERT INTO tabs (id, name, session_id, status, working_dir, system_prompt) VALUES (?, ?, ?, ?, ?, ?)').run(id, opts.name, crypto.randomUUID(), 'idle', dir, opts.systemPrompt || null);
+    return { id, name: opts.name, created: true };
+}
 export function closeDb() {
     if (walInterval) {
         clearInterval(walInterval);
@@ -82,4 +94,3 @@ export function closeDb() {
         db = null;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/db/migrations.d.ts

@@ -1,3 +1,2 @@
 import type Database from 'better-sqlite3';
 export declare function runMigrations(db: Database.Database): void;
-//# sourceMappingURL=migrations.d.ts.map

package/dist/db/migrations.js

@@ -195,6 +195,50 @@ const MIGRATIONS = [
         description: 'Add index on messages.created_at for date-range cost queries',
         up: 'CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at)',
     },
+    {
+        version: 18,
+        description: 'Rename cron_jobs table to tasks',
+        up: 'ALTER TABLE cron_jobs RENAME TO tasks',
+    },
+    {
+        version: 19,
+        description: 'Add watchers table',
+        up: `CREATE TABLE IF NOT EXISTS watchers (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT,
+      check_command TEXT NOT NULL,
+      condition TEXT NOT NULL,
+      action TEXT NOT NULL DEFAULT 'notify',
+      action_details TEXT,
+      schedule TEXT NOT NULL,
+      last_check_at TEXT,
+      last_triggered_at TEXT,
+      trigger_count INTEGER DEFAULT 0,
+      enabled INTEGER DEFAULT 1,
+      created_at TEXT DEFAULT (datetime('now'))
+    )`,
+    },
+    {
+        version: 20,
+        description: 'Add activity_log table for timeline',
+        up: `CREATE TABLE IF NOT EXISTS activity_log (
+      id TEXT PRIMARY KEY,
+      event_type TEXT NOT NULL,
+      project_name TEXT,
+      tab_name TEXT,
+      summary TEXT NOT NULL,
+      details TEXT,
+      duration_ms INTEGER,
+      cost_usd REAL,
+      created_at TEXT DEFAULT (datetime('now'))
+    )`,
+    },
+    {
+        version: 21,
+        description: 'Add index on activity_log.created_at',
+        up: 'CREATE INDEX IF NOT EXISTS idx_activity_log_created ON activity_log(created_at)',
+    },
 ];
 export function runMigrations(db) {
     // Ensure schema_version table exists
@@ -247,4 +291,3 @@ export function runMigrations(db) {
         db.prepare('UPDATE schema_version SET version = ?').run(migration.version);
     }
 }
-//# sourceMappingURL=migrations.js.map

package/dist/delegation/manager.d.ts

@@ -12,10 +12,7 @@ export interface Delegation {
 }
 /** Create a new delegation */
 export declare function createDelegation(sourceTab: string, targetTab: string, message: string, returnToTab?: string): Delegation;
-/** Mark a delegation as running */
-export declare function markDelegationRunning(id: string): void;
 /** Complete a delegation with a result */
 export declare function completeDelegation(targetTab: string, result: string): Delegation | null;
 /** Get pending delegations for a tab */
 export declare function getPendingDelegations(tabName?: string): Delegation[];
-//# sourceMappingURL=manager.d.ts.map

package/dist/delegation/manager.js

@@ -33,10 +33,6 @@ export function createDelegation(sourceTab, targetTab, message, returnToTab) {
     logger.info(`Delegation created: ${sourceTab} → ${targetTab} (depth ${delegation.depth})`);
     return delegation;
 }
-/** Mark a delegation as running */
-export function markDelegationRunning(id) {
-    getDb().prepare("UPDATE delegations SET status = 'running' WHERE id = ?").run(id);
-}
 /** Complete a delegation with a result */
 export function completeDelegation(targetTab, result) {
     const db = getDb();
@@ -85,4 +81,3 @@ function getCurrentDepth(tabName) {
     const row = db.prepare("SELECT MAX(depth) as d FROM delegations WHERE source_tab = ? AND status IN ('pending', 'running')").get(tabName);
     return row.d ?? 0;
 }
-//# sourceMappingURL=manager.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -27,7 +27,7 @@ program
     .action(stopDaemon);
 program
     .command('status')
-    .description('Show daemon status, running tabs, and cron jobs')
+    .description('Show daemon status, running tabs, and tasks')
     .action(showStatus);
 program
     .command('tabs')
@@ -37,9 +37,35 @@ program
     .command('logs [tab]')
     .description('Tail logs for a tab (default: daemon logs)')
     .action(tailLogs);
+// Tasks (new name)
+const taskCmd = program
+    .command('tasks')
+    .description('Manage scheduled tasks');
+taskCmd
+    .command('list')
+    .description('List all tasks')
+    .action(listCrons);
+taskCmd
+    .command('delete <id>')
+    .description('Delete a task by ID')
+    .action(deleteCron);
+program
+    .command('task')
+    .description('Alias for tasks')
+    .argument('[subcommand]', 'Subcommand (list, delete)')
+    .argument('[id]', 'Task ID (for delete)')
+    .action(async (sub, id) => {
+    if (sub === 'delete' && id) {
+        await deleteCron(id);
+    }
+    else {
+        await listCrons();
+    }
+});
+// Backward-compatible cron aliases (hidden)
 const cronCmd = program
-    .command('cron')
-    .description('Manage cron jobs');
+    .command('cron', { hidden: true })
+    .description('Manage cron jobs (alias for tasks)');
 cronCmd
     .command('list')
     .description('List all cron jobs')
@@ -48,6 +74,28 @@ cronCmd
     .command('delete <id>')
     .description('Delete a cron job by ID')
     .action(deleteCron);
+// Watcher commands
+program
+    .command('watches')
+    .description('List all watchers')
+    .action(async () => {
+    const { listWatchers } = await import('./cli/commands.js');
+    await listWatchers();
+});
+program
+    .command('watch')
+    .description('Manage watchers')
+    .argument('[subcommand]', 'Subcommand (list, delete)')
+    .argument('[id]', 'Watcher ID (for delete)')
+    .action(async (sub, id) => {
+    const { listWatchers, deleteWatcher } = await import('./cli/commands.js');
+    if (sub === 'delete' && id) {
+        await deleteWatcher(id);
+    }
+    else {
+        await listWatchers();
+    }
+});
 const memoryCmd = program
     .command('memory')
     .description('Manage long-term memories');
@@ -192,7 +240,7 @@ program
         console.log('\nClaude can now control your mouse, keyboard, and screen.');
         console.log('Make sure you have granted permissions:');
         console.log('  macOS: System Settings → Privacy → Screen Recording + Accessibility');
-        console.log('  Guide: https://support.beecork.com/computer-use');
+        console.log('  Guide: https://github.com/beecork/beecork/blob/main/docs/troubleshooting.md');
     }
     console.log('\nRestart daemon to apply: beecork stop && beecork start\n');
 });
@@ -224,7 +272,8 @@ Useful commands:
   beecork logs      \u2014 View daemon logs
   beecork doctor    \u2014 Run diagnostics
   beecork dashboard \u2014 Open web dashboard
-  beecork cron list \u2014 View scheduled tasks
+  beecork tasks list \u2014 View scheduled tasks
+  beecork watches    \u2014 View active watchers
 
 ${os === 'darwin' ? 'On macOS: beecork runs as a launchd service.\n  Check: launchctl list | grep beecork' : ''}${os === 'linux' ? 'On Linux: beecork runs as a systemd service.\n  Check: systemctl --user status beecork' : ''}
     `);
@@ -406,5 +455,74 @@ program
     const { listCapabilities } = await import('./cli/capabilities.js');
     await listCapabilities();
 });
+program
+    .command('history [date]')
+    .description('Show activity timeline (default: today, or "yesterday", or YYYY-MM-DD)')
+    .action(async (dateArg) => {
+    const { getTimeline, formatTimeline } = await import('./timeline/index.js');
+    let date;
+    if (dateArg === 'yesterday') {
+        date = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
+    }
+    else if (dateArg) {
+        date = dateArg;
+    }
+    else {
+        date = new Date().toISOString().slice(0, 10);
+    }
+    const events = getTimeline({ date });
+    console.log(formatTimeline(events));
+});
+program
+    .command('knowledge [scope]')
+    .description('List stored knowledge (global, project <path>, or all)')
+    .action(async (scope) => {
+    const { getGlobalKnowledge, getProjectKnowledge, getAllKnowledge, formatKnowledgeForContext } = await import('./knowledge/index.js');
+    let entries;
+    if (scope === 'global') {
+        entries = getGlobalKnowledge();
+    }
+    else if (scope?.startsWith('project')) {
+        const projectPath = scope.split(' ').slice(1).join(' ') || process.cwd();
+        entries = getProjectKnowledge(projectPath);
+    }
+    else {
+        entries = getAllKnowledge();
+    }
+    if (entries.length === 0) {
+        console.log('No knowledge stored yet.');
+        return;
+    }
+    console.log(formatKnowledgeForContext(entries));
+});
+const storeCmd = program
+    .command('store')
+    .description('Browse and install community extensions');
+storeCmd
+    .command('search <query>')
+    .description('Search for beecork packages on npm')
+    .action(async (query) => {
+    const { storeSearch } = await import('./cli/store.js');
+    await storeSearch(query);
+});
+storeCmd
+    .command('install <package>')
+    .description('Install a community package')
+    .action(async (pkg) => {
+    const { storeInstall } = await import('./cli/store.js');
+    storeInstall(pkg);
+});
+storeCmd
+    .command('info <package>')
+    .description('Show package details')
+    .action(async (pkg) => {
+    const { storeInfo } = await import('./cli/store.js');
+    await storeInfo(pkg);
+});
+program
+    .command('help')
+    .description('Show help')
+    .action(() => {
+    program.outputHelp();
+});
 program.parse();
-//# sourceMappingURL=index.js.map

package/dist/knowledge/index.d.ts

@@ -0,0 +1,2 @@
+export type { KnowledgeEntry, KnowledgeScope } from './types.js';
+export { getGlobalKnowledge, addGlobalKnowledge, getProjectKnowledge, addProjectKnowledge, getTabKnowledge, getAllKnowledge, formatKnowledgeForContext, addKnowledge, searchKnowledge, } from './manager.js';

package/dist/knowledge/index.js

@@ -0,0 +1 @@
+export { getGlobalKnowledge, addGlobalKnowledge, getProjectKnowledge, addProjectKnowledge, getTabKnowledge, getAllKnowledge, formatKnowledgeForContext, addKnowledge, searchKnowledge, } from './manager.js';

package/dist/knowledge/manager.d.ts

@@ -0,0 +1,17 @@
+import type { KnowledgeEntry, KnowledgeScope } from './types.js';
+export declare function getGlobalKnowledge(): KnowledgeEntry[];
+export declare function addGlobalKnowledge(content: string, category?: string): void;
+export declare function getProjectKnowledge(projectPath: string): KnowledgeEntry[];
+export declare function addProjectKnowledge(projectPath: string, content: string): void;
+export declare function getTabKnowledge(tabName: string): KnowledgeEntry[];
+export declare function getAllKnowledge(projectPath?: string, tabName?: string): KnowledgeEntry[];
+/** Format knowledge for injection into Claude's context */
+export declare function formatKnowledgeForContext(entries: KnowledgeEntry[]): string;
+/** Add knowledge to the right scope */
+export declare function addKnowledge(content: string, scope: KnowledgeScope, options?: {
+    projectPath?: string;
+    tabName?: string;
+    category?: string;
+}): void;
+/** Search knowledge across all layers */
+export declare function searchKnowledge(query: string, projectPath?: string, tabName?: string): KnowledgeEntry[];