beecork 1.2.0 → 1.3.1

package/dist/service/windows.d.ts

@@ -6,6 +6,3 @@ export declare function startWindowsService(): void;
 export declare function stopWindowsService(): void;
 /** Uninstall the Windows service */
 export declare function uninstallWindowsService(): void;
-/** Check if the Windows service is installed */
-export declare function isWindowsServiceInstalled(): boolean;
-//# sourceMappingURL=windows.d.ts.map

package/dist/service/windows.js

@@ -57,14 +57,3 @@ export function uninstallWindowsService() {
         console.error('Failed to uninstall service.');
     }
 }
-/** Check if the Windows service is installed */
-export function isWindowsServiceInstalled() {
-    try {
-        execSync(`schtasks /Query /TN "${TASK_NAME}" 2>nul`, { stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=windows.js.map

package/dist/session/circuit-breaker.d.ts

@@ -15,4 +15,3 @@ export declare class CircuitBreaker {
     reset(): void;
     get isTripped(): boolean;
 }
-//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/session/circuit-breaker.js

@@ -64,4 +64,3 @@ export class CircuitBreaker {
         return this.tripped;
     }
 }
-//# sourceMappingURL=circuit-breaker.js.map

package/dist/session/context-monitor.d.ts

@@ -13,4 +13,3 @@ export declare class ContextMonitor {
     get usageRatio(): number;
     reset(): void;
 }
-//# sourceMappingURL=context-monitor.d.ts.map

package/dist/session/context-monitor.js

@@ -42,4 +42,3 @@ export class ContextMonitor {
         this.checkpointed = false;
     }
 }
-//# sourceMappingURL=context-monitor.js.map

package/dist/session/manager.d.ts

@@ -43,4 +43,3 @@ export declare class TabManager {
     private updateTabStatus;
     private clearQueue;
 }
-//# sourceMappingURL=manager.d.ts.map

package/dist/session/manager.js

@@ -6,6 +6,8 @@ import { getDb } from '../db/index.js';
 import { resolveWorkingDir, validateTabName } from '../config.js';
 import { logger } from '../util/logger.js';
 import { extractMemories, getRelevantMemories } from '../memory/extractor.js';
+import { logActivity } from '../timeline/index.js';
+import { getAllKnowledge, formatKnowledgeForContext } from '../knowledge/index.js';
 function rowToTab(row) {
     return {
         id: row.id,
@@ -128,7 +130,7 @@ export class TabManager {
         if (pendingPollCount % 100 === 0) {
             db.prepare("DELETE FROM pending_messages WHERE processed = 1 AND created_at < datetime('now', '-1 day')").run();
         }
-        const pending = db.prepare('SELECT * FROM pending_messages WHERE processed = 0 ORDER BY created_at ASC').all();
+        const pending = db.prepare('SELECT * FROM pending_messages WHERE processed = 0 ORDER BY created_at ASC LIMIT 50').all();
         if (pending.length === 0)
             return;
         for (const msg of pending) {
@@ -147,6 +149,7 @@ export class TabManager {
     }
     async executeMessage(tab, prompt, resume, onTextChunk, skipExtraction, onToolUse, compactionDepth) {
         const db = getDb();
+        logActivity('task_started', 'Processing message', { tabName: tab.name, details: prompt.slice(0, 500) });
         // Budget check before spawning
         if (this.config.claudeCode.maxBudgetUsd) {
             const tabSpend = db.prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE tab_id = ?').get(tab.id).total;
@@ -165,12 +168,20 @@ export class TabManager {
         if (tabConfig?.approvalMode && tabConfig.approvalMode !== 'yolo') {
             logger.warn(`Tab "${tab.name}" has approvalMode="${tabConfig.approvalMode}" — interactive approval not yet implemented, running in yolo mode`);
         }
-        // Inject relevant memories into the prompt
-        const memories = getRelevantMemories(tab.name);
+        // Inject knowledge from all three layers
+        const knowledge = getAllKnowledge(tab.workingDir, tab.name);
+        const knowledgeContext = formatKnowledgeForContext(knowledge);
         let enrichedPrompt = prompt;
+        if (knowledgeContext) {
+            enrichedPrompt = `${knowledgeContext}\n\n${prompt}`;
+        }
+        // Also inject relevant memories as fallback (additive)
+        const memories = getRelevantMemories(tab.name);
         if (memories.length > 0) {
             const memoryContext = memories.map(m => `- ${m}`).join('\n');
-            enrichedPrompt = `[Context from memory:\n${memoryContext}\n]\n\n${prompt}`;
+            if (!knowledgeContext) {
+                enrichedPrompt = `[Context from memory:\n${memoryContext}\n]\n\n${prompt}`;
+            }
         }
         // Store user message
         db.prepare('INSERT INTO messages (tab_id, role, content) VALUES (?, ?, ?)')
@@ -252,7 +263,7 @@ export class TabManager {
                         error: resultEvent?.is_error ?? (code !== 0),
                     };
                     // Handle resume failure (session expired/not found) — retry with fresh session + context
-                    if (result.error && shouldResume && result.text.includes('session')) {
+                    if (result.error && shouldResume && result.text.match(/session (not found|expired|invalid)/i)) {
                         logger.info(`[${tab.name}] Session resume failed, retrying with context injection`);
                         const recentMsgs = db.prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5').all(tab.id);
                         const context = recentMsgs.reverse().map(m => `${m.role}: ${m.content.slice(0, 200)}`).join('\n');
@@ -269,6 +280,7 @@ export class TabManager {
                     // Update tab
                     db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?')
                         .run('idle', new Date().toISOString(), tab.name);
+                    logActivity('task_completed', 'Message processed', { tabName: tab.name, durationMs: result.durationMs, costUsd: result.costUsd, details: result.text.slice(0, 500) });
                     // Context window compaction: if checkpoint was triggered, restart with summary
                     const currentDepth = compactionDepth ?? 0;
                     if (checkpointTriggered && !result.error && result.text && currentDepth < 2) {
@@ -325,6 +337,7 @@ export class TabManager {
                     this.subprocesses.delete(tab.name);
                     this.circuitBreakers.delete(tab.name);
                     this.updateTabStatus(tab.name, 'error');
+                    logActivity('task_failed', 'Message failed', { tabName: tab.name, details: err instanceof Error ? err.message : String(err) });
                     reject(err);
                     this.processNextInQueue(tab.name);
                 },
@@ -363,4 +376,3 @@ export class TabManager {
         }
     }
 }
-//# sourceMappingURL=manager.js.map

package/dist/session/subprocess.d.ts

@@ -20,4 +20,3 @@ export declare class ClaudeSubprocess {
     get pid(): number | null;
     private buildArgs;
 }
-//# sourceMappingURL=subprocess.d.ts.map

package/dist/session/subprocess.js

@@ -144,4 +144,3 @@ export class ClaudeSubprocess {
         return args;
     }
 }
-//# sourceMappingURL=subprocess.js.map

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

@@ -2,4 +2,3 @@
 export type ToolRisk = 'safe' | 'dangerous';
 /** Classify a tool call as safe or dangerous */
 export declare function classifyTool(toolName: string, input: Record<string, unknown>): ToolRisk;
-//# sourceMappingURL=tool-classifier.d.ts.map

package/dist/session/tool-classifier.js

@@ -54,4 +54,3 @@ export function classifyTool(toolName, input) {
     // Unknown tools: default to dangerous
     return 'dangerous';
 }
-//# sourceMappingURL=tool-classifier.js.map

package/dist/{cron → tasks}/scheduler.d.ts

@@ -1,15 +1,17 @@
+import { exec } from 'node:child_process';
 import type { TabManager, NotifyCallback } from '../session/manager.js';
-export declare class CronScheduler {
+export declare const execAsync: typeof exec.__promisify__;
+export declare class TaskScheduler {
     private tabManager;
     private onNotify;
     private scheduledJobs;
     private store;
     constructor(tabManager: TabManager, onNotify: NotifyCallback | null);
-    /** Load all cron jobs from store and schedule them */
+    /** Load all tasks from store and schedule them */
     loadAndSchedule(): void;
     /** Check for the reload signal file and reload if present */
     checkForReload(): void;
-    /** Stop all scheduled jobs */
+    /** Stop all scheduled tasks */
     stopAll(): void;
     private scheduleJob;
     private fireJob;
@@ -19,4 +21,3 @@ export declare class CronScheduler {
 export declare function intervalToMs(interval: string): number | null;
 /** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
 export declare function intervalToCron(interval: string): string | null;
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/{cron → tasks}/scheduler.js

@@ -1,19 +1,22 @@
 import cron from 'node-cron';
 import fs from 'node:fs';
 import path from 'node:path';
-import { CronStore } from './store.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { TaskStore } from './store.js';
 import { getCronReloadSignalPath, getLogsDir } from '../util/paths.js';
 import { logger } from '../util/logger.js';
-export class CronScheduler {
+export const execAsync = promisify(exec);
+export class TaskScheduler {
     tabManager;
     onNotify;
     scheduledJobs = new Map();
-    store = new CronStore();
+    store = new TaskStore();
     constructor(tabManager, onNotify) {
         this.tabManager = tabManager;
         this.onNotify = onNotify;
     }
-    /** Load all cron jobs from store and schedule them */
+    /** Load all tasks from store and schedule them */
     loadAndSchedule() {
         // Cancel existing
         for (const [, task] of this.scheduledJobs) {
@@ -30,7 +33,7 @@ export class CronScheduler {
             if (job.scheduleType === 'at' && !job.lastRunAt) {
                 const targetTime = new Date(job.schedule).getTime();
                 if (targetTime <= Date.now()) {
-                    logger.warn(`Cron: missed fire detected for "${job.name}" (was scheduled for ${job.schedule}), firing now`);
+                    logger.warn(`Task: missed fire detected for "${job.name}" (was scheduled for ${job.schedule}), firing now`);
                     missedFires++;
                     this.fireJob(job);
                     this.store.update(job.id, { enabled: false }); // Disable after one-time execution
@@ -40,7 +43,7 @@ export class CronScheduler {
             this.scheduleJob(job);
             scheduled++;
         }
-        logger.info(`Cron: loaded ${scheduled} active jobs (${jobs.length} total)${missedFires > 0 ? `, fired ${missedFires} missed` : ''}`);
+        logger.info(`Tasks: loaded ${scheduled} active tasks (${jobs.length} total)${missedFires > 0 ? `, fired ${missedFires} missed` : ''}`);
     }
     /** Check for the reload signal file and reload if present */
     checkForReload() {
@@ -50,11 +53,11 @@ export class CronScheduler {
                 fs.unlinkSync(signalPath);
             }
             catch { /* race condition, ok */ }
-            logger.info('Cron: reload signal detected, reloading schedules');
+            logger.info('Tasks: reload signal detected, reloading schedules');
             this.loadAndSchedule();
         }
     }
-    /** Stop all scheduled jobs */
+    /** Stop all scheduled tasks */
     stopAll() {
         for (const [, task] of this.scheduledJobs) {
             task.stop();
@@ -65,7 +68,7 @@ export class CronScheduler {
         switch (job.scheduleType) {
             case 'cron': {
                 if (!cron.validate(job.schedule)) {
-                    logger.error(`Cron: invalid expression for "${job.name}": ${job.schedule}`);
+                    logger.error(`Task: invalid expression for "${job.name}": ${job.schedule}`);
                     return;
                 }
                 const task = cron.schedule(job.schedule, () => this.fireJob(job));
@@ -76,7 +79,7 @@ export class CronScheduler {
                 const cronExpr = intervalToCron(job.schedule);
                 if (cronExpr) {
                     if (!cron.validate(cronExpr)) {
-                        logger.error(`Cron: invalid cron expression for "${job.name}": ${cronExpr}`);
+                        logger.error(`Task: invalid cron expression for "${job.name}": ${cronExpr}`);
                         return;
                     }
                     const task = cron.schedule(cronExpr, () => this.fireJob(job));
@@ -90,7 +93,7 @@ export class CronScheduler {
                         this.scheduledJobs.set(job.id, { stop: () => clearInterval(timer) });
                     }
                     else {
-                        logger.error(`Cron: invalid interval for "${job.name}": ${job.schedule}`);
+                        logger.error(`Task: invalid interval for "${job.name}": ${job.schedule}`);
                     }
                 }
                 break;
@@ -99,7 +102,7 @@ export class CronScheduler {
                 const targetTime = new Date(job.schedule).getTime();
                 const delay = targetTime - Date.now();
                 if (delay <= 0) {
-                    logger.warn(`Cron: one-time job "${job.name}" is in the past, skipping`);
+                    logger.warn(`Task: one-time task "${job.name}" is in the past, skipping`);
                     return;
                 }
                 const timer = setTimeout(() => {
@@ -112,19 +115,19 @@ export class CronScheduler {
         }
     }
     async fireJob(job) {
-        logger.info(`Cron firing: "${job.name}" (${job.payloadType || 'agentTurn'}) → tab:${job.tabName}`);
-        const logFile = path.join(getLogsDir(), `cron-${job.name}.log`);
-        // Handle systemEvent — internal Beecork actions, not Claude Code
+        logger.info(`Task firing: "${job.name}" (${job.payloadType || 'agentTurn'}) -> tab:${job.tabName}`);
+        const logFile = path.join(getLogsDir(), `task-${job.name}.log`);
+        // Handle systemEvent -- internal Beecork actions, not Claude Code
         if (job.payloadType === 'systemEvent') {
             try {
                 await this.handleSystemEvent(job);
                 this.store.update(job.id, { lastRunAt: new Date().toISOString() });
-                fs.appendFileSync(logFile, `[${new Date().toISOString()}] SYSTEM: ${job.message}\n`);
+                await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] SYSTEM: ${job.message}\n`);
             }
             catch (err) {
                 const errMsg = err instanceof Error ? err.message : String(err);
                 logger.error(`System event "${job.name}" failed:`, err);
-                fs.appendFileSync(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
+                await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
             }
             return;
         }
@@ -134,28 +137,28 @@ export class CronScheduler {
             this.store.update(job.id, { lastRunAt: new Date().toISOString() });
             const firstLine = result.text.split('\n')[0]?.slice(0, 200) || '(no output)';
             // Log result
-            fs.appendFileSync(logFile, `[${new Date().toISOString()}] SUCCESS: ${firstLine}\n`);
-            // Notify (separate try/catch — notification failure shouldn't be reported as job failure)
+            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] SUCCESS: ${firstLine}\n`);
+            // Notify (separate try/catch -- notification failure shouldn't be reported as job failure)
             try {
                 if (this.onNotify) {
                     if (result.error) {
-                        await this.onNotify(`❌ [${job.name}] Failed — ${firstLine}`);
+                        await this.onNotify(`[${job.name}] Failed -- ${firstLine}`);
                     }
                     else {
-                        await this.onNotify(`✅ [${job.name}] Done — ${firstLine}`);
+                        await this.onNotify(`[${job.name}] Done -- ${firstLine}`);
                     }
                 }
             }
             catch (notifyErr) {
-                logger.warn(`Cron job "${job.name}" notification failed:`, notifyErr);
+                logger.warn(`Task "${job.name}" notification failed:`, notifyErr);
             }
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
-            logger.error(`Cron job "${job.name}" failed:`, err);
-            fs.appendFileSync(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
+            logger.error(`Task "${job.name}" failed:`, err);
+            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ERROR: ${errMsg}\n`);
             try {
-                await this.onNotify?.(`❌ [${job.name}] Failed — ${errMsg}`);
+                await this.onNotify?.(`[${job.name}] Failed -- ${errMsg}`);
             }
             catch { /* notification best-effort */ }
         }
@@ -163,9 +166,9 @@ export class CronScheduler {
     async handleSystemEvent(job) {
         switch (job.message) {
             case 'health_check':
-                logger.info('System event: health check — daemon alive');
+                logger.info('System event: health check -- daemon alive');
                 if (this.onNotify) {
-                    await this.onNotify('🟢 Beecork health check: all systems operational');
+                    await this.onNotify('Beecork health check: all systems operational');
                 }
                 break;
             case 'memory_compaction':
@@ -214,7 +217,6 @@ export function intervalToCron(interval) {
     // Weekly intervals
     if (mins === 0 && hours === 0 && days === 0 && weeks > 0)
         return `0 0 * * 0`;
-    // Combined or large intervals — return null, handled by setInterval in scheduleJob
+    // Combined or large intervals -- return null, handled by setInterval in scheduleJob
     return null;
 }
-//# sourceMappingURL=scheduler.js.map

package/dist/tasks/store.d.ts

@@ -0,0 +1,11 @@
+import type { Task } from '../types.js';
+export declare class TaskStore {
+    constructor();
+    list(): Task[];
+    get(id: string): Task | undefined;
+    add(job: Task): void;
+    update(id: string, updates: Partial<Task>): boolean;
+    delete(id: string): boolean;
+    /** One-time migration from crontab.json to SQLite */
+    private migrateFromJson;
+}

package/dist/{cron → tasks}/store.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getDb } from '../db/index.js';
 import { getCrontabPath } from '../util/paths.js';
 import { logger } from '../util/logger.js';
-function rowToJob(row) {
+function rowToTask(row) {
     return {
         id: row.id, name: row.name,
         scheduleType: row.schedule_type,
@@ -12,22 +12,22 @@ function rowToJob(row) {
         lastRunAt: row.last_run_at, nextRunAt: row.next_run_at,
     };
 }
-export class CronStore {
+export class TaskStore {
     constructor() {
         this.migrateFromJson();
     }
     list() {
         const db = getDb();
-        return db.prepare('SELECT * FROM cron_jobs WHERE user_id = ? ORDER BY created_at').all('local').map(rowToJob);
+        return db.prepare('SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at').all('local').map(rowToTask);
     }
     get(id) {
         const db = getDb();
-        const row = db.prepare('SELECT * FROM cron_jobs WHERE id = ?').get(id);
-        return row ? rowToJob(row) : undefined;
+        const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+        return row ? rowToTask(row) : undefined;
     }
     add(job) {
         const db = getDb();
-        db.prepare(`INSERT INTO cron_jobs (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, user_id, created_at, last_run_at, next_run_at)
+        db.prepare(`INSERT INTO tasks (id, name, schedule_type, schedule, tab_name, message, payload_type, enabled, user_id, created_at, last_run_at, next_run_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(job.id, job.name, job.scheduleType, job.schedule, job.tabName, job.message, job.payloadType || 'agentTurn', job.enabled ? 1 : 0, 'local', job.createdAt, job.lastRunAt, job.nextRunAt);
     }
     update(id, updates) {
@@ -36,12 +36,12 @@ export class CronStore {
         if (!existing)
             return false;
         const merged = { ...existing, ...updates };
-        db.prepare(`UPDATE cron_jobs SET name=?, schedule_type=?, schedule=?, tab_name=?, message=?, enabled=?, last_run_at=?, next_run_at=? WHERE id=?`).run(merged.name, merged.scheduleType, merged.schedule, merged.tabName, merged.message, merged.enabled ? 1 : 0, merged.lastRunAt, merged.nextRunAt, id);
+        db.prepare(`UPDATE tasks SET name=?, schedule_type=?, schedule=?, tab_name=?, message=?, enabled=?, last_run_at=?, next_run_at=? WHERE id=?`).run(merged.name, merged.scheduleType, merged.schedule, merged.tabName, merged.message, merged.enabled ? 1 : 0, merged.lastRunAt, merged.nextRunAt, id);
         return true;
     }
     delete(id) {
         const db = getDb();
-        const result = db.prepare('DELETE FROM cron_jobs WHERE id = ?').run(id);
+        const result = db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
         return result.changes > 0;
     }
     /** One-time migration from crontab.json to SQLite */
@@ -50,7 +50,7 @@ export class CronStore {
         if (!fs.existsSync(jsonPath))
             return;
         const db = getDb();
-        const count = db.prepare('SELECT COUNT(*) as count FROM cron_jobs').get();
+        const count = db.prepare('SELECT COUNT(*) as count FROM tasks').get();
         if (count.count > 0) {
             // Already migrated, clean up JSON
             try {
@@ -64,7 +64,7 @@ export class CronStore {
             const jobs = data.jobs || [];
             if (jobs.length === 0)
                 return;
-            const insert = db.prepare(`INSERT OR IGNORE INTO cron_jobs (id, name, schedule_type, schedule, tab_name, message, enabled, user_id, created_at, last_run_at, next_run_at)
+            const insert = db.prepare(`INSERT OR IGNORE INTO tasks (id, name, schedule_type, schedule, tab_name, message, enabled, user_id, created_at, last_run_at, next_run_at)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
             const tx = db.transaction(() => {
                 for (const j of jobs) {
@@ -73,11 +73,10 @@ export class CronStore {
             });
             tx();
             fs.renameSync(jsonPath, jsonPath + '.bak');
-            logger.info(`Migrated ${jobs.length} cron jobs from JSON to SQLite`);
+            logger.info(`Migrated ${jobs.length} tasks from JSON to SQLite`);
         }
         catch (err) {
-            logger.error('Failed to migrate cron jobs from JSON:', err);
+            logger.error('Failed to migrate tasks from JSON:', err);
         }
     }
 }
-//# sourceMappingURL=store.js.map

package/dist/timeline/index.d.ts

@@ -0,0 +1,3 @@
+export type { ActivityEvent, EventType } from './types.js';
+export { logActivity } from './logger.js';
+export { getTimeline, formatTimeline, getReplayInfo } from './query.js';

package/dist/timeline/index.js

@@ -0,0 +1,2 @@
+export { logActivity } from './logger.js';
+export { getTimeline, formatTimeline, getReplayInfo } from './query.js';

package/dist/timeline/logger.d.ts

@@ -0,0 +1,8 @@
+import type { EventType } from './types.js';
+export declare function logActivity(eventType: EventType, summary: string, options?: {
+    projectName?: string;
+    tabName?: string;
+    details?: string;
+    durationMs?: number;
+    costUsd?: number;
+}): void;

package/dist/timeline/logger.js

@@ -0,0 +1,9 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+export function logActivity(eventType, summary, options) {
+    try {
+        const db = getDb();
+        db.prepare('INSERT INTO activity_log (id, event_type, project_name, tab_name, summary, details, duration_ms, cost_usd) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(uuidv4(), eventType, options?.projectName || null, options?.tabName || null, summary, options?.details || null, options?.durationMs || null, options?.costUsd || null);
+    }
+    catch { /* non-critical — don't crash if logging fails */ }
+}

package/dist/timeline/query.d.ts

@@ -0,0 +1,11 @@
+import type { ActivityEvent } from './types.js';
+export declare function getTimeline(options?: {
+    date?: string;
+    tabName?: string;
+    limit?: number;
+}): ActivityEvent[];
+export declare function formatTimeline(events: ActivityEvent[]): string;
+export declare function getReplayInfo(eventId: string): {
+    tabName: string;
+    message: string;
+} | null;

package/dist/timeline/query.js

@@ -0,0 +1,57 @@
+import { getDb } from '../db/index.js';
+function rowToEvent(r) {
+    return {
+        id: r.id, eventType: r.event_type, projectName: r.project_name,
+        tabName: r.tab_name, summary: r.summary, details: r.details,
+        durationMs: r.duration_ms, costUsd: r.cost_usd, createdAt: r.created_at,
+    };
+}
+export function getTimeline(options) {
+    const db = getDb();
+    let query = 'SELECT * FROM activity_log';
+    const conditions = [];
+    const params = [];
+    if (options?.date) {
+        conditions.push('date(created_at) = ?');
+        params.push(options.date);
+    }
+    if (options?.tabName) {
+        conditions.push('tab_name = ?');
+        params.push(options.tabName);
+    }
+    if (conditions.length > 0)
+        query += ' WHERE ' + conditions.join(' AND ');
+    query += ' ORDER BY created_at DESC';
+    query += ' LIMIT ?';
+    params.push(options?.limit || 50);
+    return db.prepare(query).all(...params).map(rowToEvent);
+}
+export function formatTimeline(events) {
+    if (events.length === 0)
+        return 'No activity recorded.';
+    const byDate = new Map();
+    for (const event of events.reverse()) {
+        const date = event.createdAt.slice(0, 10);
+        if (!byDate.has(date))
+            byDate.set(date, []);
+        byDate.get(date).push(event);
+    }
+    const lines = [];
+    for (const [date, dayEvents] of byDate) {
+        lines.push(`\n📅 ${date}`);
+        for (const e of dayEvents) {
+            const time = e.createdAt.slice(11, 16);
+            const tab = e.tabName ? `[${e.tabName}]` : '';
+            const cost = e.costUsd ? ` $${e.costUsd.toFixed(4)}` : '';
+            lines.push(`  ${time}  ${tab} ${e.summary}${cost}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function getReplayInfo(eventId) {
+    const db = getDb();
+    const event = db.prepare('SELECT * FROM activity_log WHERE id = ?').get(eventId);
+    if (!event || !event.tab_name || !event.details)
+        return null;
+    return { tabName: event.tab_name, message: event.details };
+}

package/dist/timeline/types.d.ts

@@ -0,0 +1,12 @@
+export type EventType = 'task_started' | 'task_completed' | 'task_failed' | 'watcher_triggered' | 'media_generated' | 'delegation_completed' | 'user_command' | 'system_event';
+export interface ActivityEvent {
+    id: string;
+    eventType: EventType;
+    projectName: string | null;
+    tabName: string | null;
+    summary: string;
+    details: string | null;
+    durationMs: number | null;
+    costUsd: number | null;
+    createdAt: string;
+}

package/dist/timeline/types.js

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

package/dist/types.d.ts

@@ -95,6 +95,7 @@ export interface BeecorkConfig {
     groups?: GroupConfig;
     notifications?: NotificationConfig[];
     mediaGenerators?: MediaGeneratorConfig[];
+    communityChannels?: string[];
     deployment: 'local' | 'vps';
 }
 export type TabStatus = 'idle' | 'running' | 'error' | 'stopped';
@@ -161,16 +162,16 @@ export interface StreamUsage {
     cache_read_input_tokens: number;
 }
 export type StreamEvent = StreamInit | StreamAssistant | StreamResult;
-export type CronScheduleType = 'at' | 'every' | 'cron';
-export type CronPayloadType = 'agentTurn' | 'systemEvent';
-export interface CronJob {
+export type TaskScheduleType = 'at' | 'every' | 'cron';
+export type TaskPayloadType = 'agentTurn' | 'systemEvent';
+export interface Task {
     id: string;
     name: string;
-    scheduleType: CronScheduleType;
+    scheduleType: TaskScheduleType;
     schedule: string;
     tabName: string;
     message: string;
-    payloadType: CronPayloadType;
+    payloadType: TaskPayloadType;
     enabled: boolean;
     createdAt: string;
     lastRunAt: string | null;
@@ -187,4 +188,3 @@ export interface CircuitBreakerConfig {
     maxRepeats: number;
     windowSize: number;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,4 +1,3 @@
 // ─── Config ───
 export {};
 // Channel interface: see src/channels/types.ts
-//# sourceMappingURL=types.js.map

package/dist/users/index.d.ts

@@ -1,3 +1,2 @@
-export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin, getUserIdentities, ensureAdminFromConfig } from './service.js';
+export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';
 export type { User } from './service.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/users/index.js

@@ -1,2 +1 @@
-export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin, getUserIdentities, ensureAdminFromConfig } from './service.js';
-//# sourceMappingURL=index.js.map
+export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';

package/dist/users/service.d.ts

@@ -15,11 +15,3 @@ export declare function linkIdentity(userId: string, channelId: string, peerId:
 export declare function listUsers(): User[];
 /** Check if any admin exists */
 export declare function hasAdmin(): boolean;
-/** Get user's identities across channels */
-export declare function getUserIdentities(userId: string): Array<{
-    channelId: string;
-    peerId: string;
-}>;
-/** Auto-create admin user from config's allowed IDs (migration helper) */
-export declare function ensureAdminFromConfig(channelId: string, peerIds: Array<string | number>): void;
-//# sourceMappingURL=service.d.ts.map