beecork 1.2.0 → 1.3.1

package/dist/channels/registry.js

@@ -49,4 +49,3 @@ export class ChannelRegistry {
         await Promise.all(Array.from(this.channels.values()).map(channel => channel.sendNotification(text, urgent).catch(err => logger.warn(`${channel.name} notify failed:`, err))));
     }
 }
-//# sourceMappingURL=registry.js.map

package/dist/channels/telegram.d.ts

@@ -20,6 +20,7 @@ export declare class TelegramChannel implements Channel {
     private botUsername;
     private mutedGroups;
     private welcomeSent;
+    private sttWarmedUp;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
     stop(): void;
@@ -37,4 +38,3 @@ export declare class TelegramChannel implements Channel {
     private isAdmin;
     private setReaction;
 }
-//# sourceMappingURL=telegram.d.ts.map

package/dist/channels/telegram.js

@@ -1,14 +1,14 @@
 import TelegramBot from 'node-telegram-bot-api';
 import fs from 'node:fs';
 import path from 'node:path';
-import { chunkText, timeAgo, parseTabMessage, buildMediaPrompt } from '../util/text.js';
+import { chunkText, timeAgo, parseTabMessage } from '../util/text.js';
 import { logger } from '../util/logger.js';
 import { retryWithBackoff } from '../util/retry.js';
 import { getAdminUserId } from '../config.js';
 import { getLogsDir } from '../util/paths.js';
 import { saveMedia, isOversized } from '../media/store.js';
 import { inboundLimiter, groupLimiter } from '../util/rate-limiter.js';
-import { ProgressTracker } from '../util/progress.js';
+import { processInboundMessage } from './pipeline.js';
 import { initVoiceProviders } from '../voice/index.js';
 const DEFAULT_GROUP_CONFIG = { activationMode: 'mention', maxResponsesPerMinute: 3, tabPerGroup: true };
 /** Format tab status for Telegram display */
@@ -35,6 +35,7 @@ export class TelegramChannel {
     botUsername = null;
     mutedGroups = new Set();
     welcomeSent = new Set();
+    sttWarmedUp = false;
     constructor(ctx) {
         this.ctx = ctx;
         this.bot = new TelegramBot(ctx.config.telegram.token, {
@@ -193,6 +194,8 @@ export class TelegramChannel {
                     text = text.replace(new RegExp(`@${this.botUsername}`, 'gi'), '').trim();
                 }
             }
+            // Track voice pipeline timing
+            const voicePipelineStart = msg.voice ? Date.now() : null;
             // Download media if present (in parallel)
             const downloadTasks = [];
             if (msg.photo) {
@@ -228,17 +231,8 @@ export class TelegramChannel {
                 .map(r => r.value);
             // Transcribe voice messages if STT is configured
             if (this.sttProvider) {
-                for (const m of media) {
-                    if (m.type === 'voice' && m.filePath) {
-                        try {
-                            const transcription = await this.sttProvider.transcribe(m.filePath);
-                            m.caption = `[Transcribed from voice message]: ${transcription}`;
-                        }
-                        catch (err) {
-                            logger.warn('Voice transcription failed, passing file path instead:', err);
-                        }
-                    }
-                }
+                const { transcribeVoiceMessages } = await import('../voice/index.js');
+                this.sttWarmedUp = await transcribeVoiceMessages(media, this.sttProvider, 'telegram', this.sttWarmedUp);
             }
             // Skip if no text AND no media
             if (!text && media.length === 0)
@@ -255,6 +249,9 @@ export class TelegramChannel {
                 });
                 logger.info(`[telegram] Message received from ${msg.from?.id}, sending typing`);
                 await this.handleMessage(chatId, text, msg.message_id, media, isGroup);
+                if (voicePipelineStart) {
+                    logger.info(`[telegram] Voice-to-response total: ${Date.now() - voicePipelineStart}ms`);
+                }
             }
             catch (err) {
                 logger.error('Telegram: error handling message:', err);
@@ -274,6 +271,34 @@ export class TelegramChannel {
             await this.bot.sendMessage(chatId, 'Beecork unmuted in this group.');
             return;
         }
+        if (text === '/history' || text.startsWith('/history ')) {
+            const dateArg = text.slice(9).trim();
+            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, limit: 30 });
+            await this.sendResponse(chatId, formatTimeline(events));
+            return;
+        }
+        if (text === '/knowledge') {
+            const { getAllKnowledge, formatKnowledgeForContext } = await import('../knowledge/index.js');
+            const entries = getAllKnowledge();
+            if (entries.length === 0) {
+                await this.bot.sendMessage(chatId, 'No knowledge stored yet. Beecork learns from your conversations.');
+                return;
+            }
+            const formatted = formatKnowledgeForContext(entries);
+            await this.sendResponse(chatId, formatted.slice(0, 4000));
+            return;
+        }
         // Shared command handler (covers /tabs, /stop, /tab, /projects, /project, /newproject, /close, /fresh, /register, /link, /users, /cost, /activity, /handoff, /machines)
         const { handleSharedCommand } = await import('./command-handler.js');
         const result = await handleSharedCommand({
@@ -296,28 +321,17 @@ export class TelegramChannel {
         await this.handleMessage(chatId, text, messageId);
     }
     async handleMessage(chatId, text, messageId, media = [], isGroup = false) {
-        let { tabName, prompt: rawPrompt } = parseTabMessage(text);
-        if (!rawPrompt && media.length === 0)
+        const { tabName } = parseTabMessage(text);
+        if (!tabName && !text && media.length === 0)
             return;
-        // Group tab routing: use a dedicated tab per group unless /tab is explicit
+        // Telegram-specific: group tab routing
+        let overrideTabName;
         if (isGroup) {
             const groupConfig = this.ctx.config.groups || DEFAULT_GROUP_CONFIG;
             if (groupConfig.tabPerGroup && !text.startsWith('/tab ')) {
-                tabName = `group-tg-${Math.abs(chatId)}`;
+                overrideTabName = `group-tg-${Math.abs(chatId)}`;
             }
         }
-        // Smart project routing (shared across all channels)
-        const { resolveProjectRoute } = await import('./command-handler.js');
-        const route = await resolveProjectRoute(rawPrompt, tabName, text, String(chatId));
-        if (route.confirmationMessage) {
-            await this.bot.sendMessage(chatId, route.confirmationMessage);
-            return;
-        }
-        let effectiveTabName = route.effectiveTabName;
-        let projectPath = route.projectPath;
-        // Build prompt with media references
-        const prompt = buildMediaPrompt(media, rawPrompt);
-        logger.info(`[telegram] Handling message for tab "${effectiveTabName}" (chat: ${chatId}, msg: ${messageId})`);
         // React with ⏳
         await this.setReaction(chatId, messageId, '⏳');
         // Typing indicator — keep refreshing every 4s
@@ -328,13 +342,14 @@ export class TelegramChannel {
         const typingInterval = setInterval(sendTyping, 4000);
         // "Still working" timeout
         const stillWorkingTimeout = setTimeout(() => {
-            this.bot.sendMessage(chatId, `Still working on your request in tab "${effectiveTabName}"...`).catch(() => { });
+            this.bot.sendMessage(chatId, `Still working on your request...`).catch(() => { });
         }, 120000);
         try {
             let responseText;
             let responseError;
-            let responseTab = effectiveTabName;
+            let responseTab;
             if (this.ctx.pipeBrain) {
+                // PipeBrain path is Telegram-specific (not shared in pipeline)
                 const pipeResult = await this.ctx.pipeBrain.process(text, { chatId, userId: 0, messageId });
                 responseText = pipeResult.response.text || '(empty response)';
                 responseError = pipeResult.response.error;
@@ -345,9 +360,13 @@ export class TelegramChannel {
                 }
             }
             else {
+                // Telegram-specific: streaming message edits
                 let streamMsgId = null;
                 let streamBuffer = '';
                 let lastEditTime = 0;
+                // We need the effective tab name for the stream prefix, but it's determined
+                // inside the pipeline. Use a mutable ref that the pipeline result will fill.
+                let effectiveTabForStream = overrideTabName || tabName;
                 const onTextChunk = async (chunk) => {
                     streamBuffer += chunk;
                     const now = Date.now();
@@ -355,7 +374,7 @@ export class TelegramChannel {
                         return;
                     lastEditTime = now;
                     try {
-                        const prefix = effectiveTabName !== 'default' ? `[${effectiveTabName}] ` : '';
+                        const prefix = effectiveTabForStream !== 'default' ? `[${effectiveTabForStream}] ` : '';
                         const preview = prefix + streamBuffer.slice(0, 4000) + (streamBuffer.length > 4000 ? '...' : '');
                         if (!streamMsgId) {
                             const sent = await this.bot.sendMessage(chatId, preview);
@@ -367,59 +386,80 @@ export class TelegramChannel {
                     }
                     catch { /* edit failures are non-critical */ }
                 };
-                // Progress updates for long tasks (every 30 seconds)
-                const progressTracker = new ProgressTracker(effectiveTabName, (msg) => {
-                    this.bot.sendMessage(chatId, msg).catch(() => { });
-                });
-                const result = await this.ctx.tabManager.sendMessage(effectiveTabName, prompt, {
+                // Shared pipeline handles: routing, media prompt, progress, sendMessage, TTS
+                const pipelineResult = await processInboundMessage({
+                    text,
+                    media,
+                    channelId: 'telegram',
+                    tabManager: this.ctx.tabManager,
+                    voiceReplyMode: this.ctx.config.voice?.replyMode,
+                    ttsProvider: this.ttsProvider,
+                    userId: String(chatId),
+                    sendProgress: (msg) => {
+                        this.bot.sendMessage(chatId, msg).catch(() => { });
+                    },
+                    overrideTabName,
                     onTextChunk,
-                    onToolUse: (name, input) => progressTracker.record(name, input),
-                    projectPath,
                 });
-                progressTracker.stop();
-                responseText = result.text || '(empty response)';
-                responseError = result.error;
+                // Empty result means no prompt and no media
+                if (!pipelineResult.responseText) {
+                    clearInterval(typingInterval);
+                    clearTimeout(stillWorkingTimeout);
+                    return;
+                }
+                // Update the effective tab for stream prefix (now known)
+                effectiveTabForStream = pipelineResult.tabName;
+                responseText = pipelineResult.responseText;
+                responseError = pipelineResult.isError;
+                responseTab = pipelineResult.tabName;
+                // Telegram-specific: if streaming was active and no error, edit the final message
                 if (streamMsgId && !responseError) {
                     clearInterval(typingInterval);
                     clearTimeout(stillWorkingTimeout);
                     await this.setReaction(chatId, messageId, '✅');
+                    // Send voice if available (even with streaming)
+                    if (pipelineResult.audioPath) {
+                        await this.bot.sendVoice(chatId, pipelineResult.audioPath);
+                        if (pipelineResult.voiceOnly)
+                            return;
+                    }
                     try {
-                        const prefix = effectiveTabName !== 'default' ? `[${effectiveTabName}] ` : '';
+                        const prefix = responseTab !== 'default' ? `[${responseTab}] ` : '';
                         const finalText = prefix + responseText;
                         if (finalText.length <= 4096) {
                             await this.bot.editMessageText(finalText, { chat_id: chatId, message_id: streamMsgId });
                         }
                         else {
-                            await this.sendResponse(chatId, responseText, effectiveTabName);
+                            await this.sendResponse(chatId, responseText, responseTab);
                         }
                     }
                     catch {
-                        await this.sendResponse(chatId, responseText, effectiveTabName);
+                        await this.sendResponse(chatId, responseText, responseTab);
                     }
                     return;
                 }
+                // Send voice reply if TTS generated audio (non-streaming path)
+                if (pipelineResult.audioPath) {
+                    clearInterval(typingInterval);
+                    clearTimeout(stillWorkingTimeout);
+                    await this.setReaction(chatId, messageId, responseError ? '❌' : '✅');
+                    await this.bot.sendVoice(chatId, pipelineResult.audioPath);
+                    if (pipelineResult.voiceOnly)
+                        return;
+                    if (!responseError) {
+                        await this.sendResponse(chatId, responseText, responseTab);
+                        return;
+                    }
+                }
             }
             clearInterval(typingInterval);
             clearTimeout(stillWorkingTimeout);
             if (responseError) {
                 await this.setReaction(chatId, messageId, '❌');
-                await this.sendResponse(chatId, `Error: ${responseText}`, responseTab);
+                await this.sendResponse(chatId, responseText, responseTab);
                 return;
             }
             await this.setReaction(chatId, messageId, '✅');
-            // TTS: send voice reply if configured
-            const voiceReplyMode = this.ctx.config.voice?.replyMode;
-            if (this.ttsProvider && (voiceReplyMode === 'voice' || voiceReplyMode === 'both')) {
-                try {
-                    const audioPath = await this.ttsProvider.synthesize(responseText);
-                    await this.bot.sendVoice(chatId, audioPath);
-                    if (voiceReplyMode === 'voice')
-                        return; // Don't send text
-                }
-                catch (err) {
-                    logger.warn('TTS failed, sending text reply:', err);
-                }
-            }
             await this.sendResponse(chatId, responseText, responseTab);
         }
         catch (err) {
@@ -510,4 +550,3 @@ export class TelegramChannel {
         }
     }
 }
-//# sourceMappingURL=telegram.js.map

package/dist/channels/types.d.ts

@@ -66,4 +66,3 @@ export interface ChannelContext {
     /** Broadcast notification to all channels + notification providers */
     notifyCallback?: (message: string) => Promise<void>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/channels/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/channels/webhook.d.ts

@@ -17,4 +17,3 @@ export declare class WebhookChannel implements Channel {
     private authenticate;
     private getConfig;
 }
-//# sourceMappingURL=webhook.d.ts.map

package/dist/channels/webhook.js

@@ -161,4 +161,3 @@ export class WebhookChannel {
         return this.ctx.config.webhook;
     }
 }
-//# sourceMappingURL=webhook.js.map

package/dist/channels/whatsapp.d.ts

@@ -13,6 +13,7 @@ export declare class WhatsAppChannel implements Channel {
     private readonly backoffDelays;
     private sttProvider;
     private ttsProvider;
+    private sttWarmedUp;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
     stop(): void;
@@ -23,4 +24,3 @@ export declare class WhatsAppChannel implements Channel {
     private sendResponse;
     private isAllowed;
 }
-//# sourceMappingURL=whatsapp.d.ts.map

package/dist/channels/whatsapp.js

@@ -2,9 +2,9 @@ import fs from 'node:fs';
 import { logger } from '../util/logger.js';
 import { saveMedia, isOversized } from '../media/store.js';
 import { retryWithBackoff } from '../util/retry.js';
-import { chunkText, parseTabMessage, buildMediaPrompt } from '../util/text.js';
+import { chunkText } from '../util/text.js';
 import { inboundLimiter } from '../util/rate-limiter.js';
-import { ProgressTracker } from '../util/progress.js';
+import { processInboundMessage } from './pipeline.js';
 import { initVoiceProviders } from '../voice/index.js';
 const WHATSAPP_MAX_LENGTH = 8192;
 export class WhatsAppChannel {
@@ -21,6 +21,7 @@ export class WhatsAppChannel {
     backoffDelays = [1000, 5000, 15000, 30000, 60000];
     sttProvider = null;
     ttsProvider = null;
+    sttWarmedUp = false;
     constructor(ctx) {
         this.ctx = ctx;
         this.allowedNumbers = new Set(ctx.config.whatsapp?.allowedNumbers ?? []);
@@ -146,17 +147,8 @@ export class WhatsAppChannel {
                     .map(r => r.value);
                 // Transcribe voice messages if STT is configured
                 if (this.sttProvider) {
-                    for (const att of media) {
-                        if (att.type === 'voice' && att.filePath) {
-                            try {
-                                const transcription = await this.sttProvider.transcribe(att.filePath);
-                                att.caption = `[Transcribed from voice message]: ${transcription}`;
-                            }
-                            catch (err) {
-                                logger.warn('Voice transcription failed, passing file path instead:', err);
-                            }
-                        }
-                    }
+                    const { transcribeVoiceMessages } = await import('../voice/index.js');
+                    this.sttWarmedUp = await transcribeVoiceMessages(media, this.sttProvider, 'whatsapp', this.sttWarmedUp);
                 }
                 if (!text && media.length === 0)
                     return;
@@ -177,48 +169,31 @@ export class WhatsAppChannel {
                             return;
                         }
                     }
-                    const { tabName, prompt: rawPrompt } = parseTabMessage(text);
-                    if (!rawPrompt && media.length === 0)
-                        return;
-                    // Build prompt with media references
-                    const prompt = buildMediaPrompt(media, rawPrompt);
-                    // Smart project routing (shared across all channels)
-                    const { resolveProjectRoute } = await import('./command-handler.js');
-                    const route = await resolveProjectRoute(rawPrompt, tabName, text, waUserId);
-                    if (route.confirmationMessage) {
-                        await sock.sendMessage(sender, { text: route.confirmationMessage });
-                        return;
-                    }
-                    let effectiveTabName = route.effectiveTabName;
-                    let projectPath = route.projectPath;
                     await sock.sendPresenceUpdate('composing', sender).catch(() => { });
-                    // Progress updates for long tasks (every 30 seconds)
-                    const progressTracker = new ProgressTracker(effectiveTabName, (msg) => {
-                        sock.sendMessage(sender, { text: msg }).catch(() => { });
+                    // Shared message pipeline
+                    const pipelineResult = await processInboundMessage({
+                        text,
+                        media,
+                        channelId: 'whatsapp',
+                        tabManager: this.ctx.tabManager,
+                        voiceReplyMode: this.ctx.config.voice?.replyMode,
+                        ttsProvider: this.ttsProvider,
+                        userId: waUserId,
+                        sendProgress: (msg) => {
+                            sock.sendMessage(sender, { text: msg }).catch(() => { });
+                        },
                     });
-                    const result = await this.ctx.tabManager.sendMessage(effectiveTabName, prompt, {
-                        onToolUse: (name, input) => progressTracker.record(name, input),
-                        projectPath,
-                    });
-                    progressTracker.stop();
-                    const responseText = result.error
-                        ? `Error: ${result.text}`
-                        : result.text || '(empty response)';
                     await sock.sendPresenceUpdate('paused', sender).catch(() => { });
-                    // TTS: send voice reply if configured
-                    const voiceReplyMode = this.ctx.config.voice?.replyMode;
-                    if (this.ttsProvider && (voiceReplyMode === 'voice' || voiceReplyMode === 'both')) {
-                        try {
-                            const audioPath = await this.ttsProvider.synthesize(responseText);
-                            await sock.sendMessage(sender, { audio: { url: audioPath }, mimetype: 'audio/ogg; codecs=opus', ptt: true });
-                            if (voiceReplyMode === 'voice')
-                                return; // Don't send text
-                        }
-                        catch (err) {
-                            logger.warn('TTS failed, sending text reply:', err);
-                        }
+                    // Empty result means no prompt and no media
+                    if (!pipelineResult.responseText)
+                        return;
+                    // Send voice reply if TTS generated audio
+                    if (pipelineResult.audioPath) {
+                        await sock.sendMessage(sender, { audio: { url: pipelineResult.audioPath }, mimetype: 'audio/ogg; codecs=opus', ptt: true });
+                        if (pipelineResult.voiceOnly)
+                            return;
                     }
-                    await this.sendResponse(sender, responseText, effectiveTabName);
+                    await this.sendResponse(sender, pipelineResult.responseText, pipelineResult.tabName);
                 }
                 catch (err) {
                     logger.error('WhatsApp message handler error:', err);
@@ -292,4 +267,3 @@ export class WhatsAppChannel {
         return this.allowedNumbers.has(number);
     }
 }
-//# sourceMappingURL=whatsapp.js.map

package/dist/cli/capabilities.d.ts

@@ -1,4 +1,3 @@
 export declare function enableCapability(packId: string): Promise<void>;
 export declare function listCapabilities(): Promise<void>;
 export declare function disableCapability(packId: string): Promise<void>;
-//# sourceMappingURL=capabilities.d.ts.map

package/dist/cli/capabilities.js

@@ -70,4 +70,3 @@ export async function disableCapability(packId) {
     console.log(`\n✓ ${packId} disabled.`);
     console.log('  Restart daemon to apply: beecork stop && beecork start\n');
 }
-//# sourceMappingURL=capabilities.js.map

package/dist/cli/channel.d.ts

@@ -1,4 +1,3 @@
 export declare function channelInstall(packageName: string): void;
 export declare function channelCreate(name: string): void;
 export declare function channelList(): void;
-//# sourceMappingURL=channel.d.ts.map

package/dist/cli/channel.js

@@ -174,7 +174,7 @@ npm publish
 }
 export function channelList() {
     try {
-        const output = execSync('npm list -g --depth=0 2>/dev/null', { encoding: 'utf-8' });
+        const output = execSync('npm list -g --depth=0', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
         const lines = output.split('\n').filter(line => line.includes(CHANNEL_PREFIX));
         if (lines.length === 0) {
             console.log('No community channels installed.');
@@ -191,4 +191,3 @@ export function channelList() {
         console.log('No community channels installed.');
     }
 }
-//# sourceMappingURL=channel.js.map

package/dist/cli/commands.d.ts

@@ -5,10 +5,11 @@ export declare function listTabs(): Promise<void>;
 export declare function tailLogs(tabName?: string): Promise<void>;
 export declare function listCrons(): Promise<void>;
 export declare function deleteCron(id: string): Promise<void>;
+export declare function listWatchers(): Promise<void>;
+export declare function deleteWatcher(id: string): Promise<void>;
 export declare function listMemories(): Promise<void>;
 export declare function deleteMemory(id: string): Promise<void>;
 export declare function updateBeecork(options: {
     check?: boolean;
 }): Promise<void>;
 export declare function sendMessage(message: string): Promise<void>;
-//# sourceMappingURL=commands.d.ts.map

package/dist/cli/commands.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { spawn, execSync } from 'node:child_process';
 import { getDb, closeDb } from '../db/index.js';
 import { getConfig } from '../config.js';
-import { CronStore } from '../cron/store.js';
+import { TaskStore } from '../tasks/store.js';
 import { getDaemonPid, timeAgo } from './helpers.js';
 import { startService, stopService } from '../service/install.js';
 import { getPidPath, getLogsDir } from '../util/paths.js';
@@ -79,10 +79,10 @@ export async function showStatus() {
             const pidInfo = tab.pid ? ` (PID ${tab.pid})` : '';
             console.log(`  ${tab.name.padEnd(20)} ${tab.status.padEnd(12)} last active: ${ago}${pidInfo}`);
         }
-        const store = new CronStore();
+        const store = new TaskStore();
         const jobs = store.list();
         const activeJobs = jobs.filter(j => j.enabled);
-        console.log(`\nCron jobs: ${activeJobs.length} active (${jobs.length} total)`);
+        console.log(`\nTasks: ${activeJobs.length} active (${jobs.length} total)`);
         if (activeJobs.length > 0) {
             for (const job of activeJobs.slice(0, 5)) {
                 const lastRun = job.lastRunAt ? `last: ${timeAgo(job.lastRunAt)}` : 'never run';
@@ -119,34 +119,69 @@ export async function tailLogs(tabName) {
         console.log(`No log file found: ${logFile}`);
         return;
     }
-    const child = spawn('tail', ['-f', '-n', '50', logFile], { stdio: 'inherit' });
-    process.on('SIGINT', () => child.kill());
+    if (process.platform === 'win32') {
+        // Windows: use PowerShell Get-Content -Wait
+        const child = spawn('powershell', ['-Command', `Get-Content -Path '${logFile}' -Tail 50 -Wait`], { stdio: 'inherit' });
+        process.on('SIGINT', () => child.kill());
+    }
+    else {
+        const child = spawn('tail', ['-f', '-n', '50', logFile], { stdio: 'inherit' });
+        process.on('SIGINT', () => child.kill());
+    }
 }
 export async function listCrons() {
-    requireDb(); // Ensure DB exists before CronStore tries to access it
-    const store = new CronStore();
+    requireDb();
+    const store = new TaskStore();
     const jobs = store.list();
     if (jobs.length === 0) {
-        console.log('No cron jobs.');
+        console.log('No tasks.');
         return;
     }
-    console.log(`\nCron jobs (${jobs.length}):\n`);
+    console.log(`\nTasks (${jobs.length}):\n`);
     for (const job of jobs) {
         const status = job.enabled ? 'enabled' : 'disabled';
         const lastRun = job.lastRunAt ? timeAgo(job.lastRunAt) : 'never';
         console.log(`  ${job.name.padEnd(20)} [${status}] ${job.scheduleType}:${job.schedule}`);
-        console.log(`    → tab:${job.tabName} | last: ${lastRun} | ID: ${job.id}`);
+        console.log(`    -> tab:${job.tabName} | last: ${lastRun} | ID: ${job.id}`);
     }
     console.log('');
 }
 export async function deleteCron(id) {
-    requireDb(); // Ensure DB exists before CronStore tries to access it
-    const store = new CronStore();
+    requireDb();
+    const store = new TaskStore();
     if (store.delete(id)) {
-        console.log(`Deleted cron job: ${id}`);
+        console.log(`Deleted task: ${id}`);
+    }
+    else {
+        console.log(`No task found with ID: ${id}`);
+    }
+}
+export async function listWatchers() {
+    const db = requireDb();
+    const watchers = db.prepare('SELECT * FROM watchers ORDER BY created_at').all();
+    closeDb();
+    if (watchers.length === 0) {
+        console.log('No watchers.');
+        return;
+    }
+    console.log(`\nWatchers (${watchers.length}):\n`);
+    for (const w of watchers) {
+        const status = w.enabled ? 'enabled' : 'disabled';
+        const lastCheck = w.last_check_at ? timeAgo(w.last_check_at) : 'never';
+        console.log(`  ${w.name.padEnd(20)} [${status}] ${w.schedule}`);
+        console.log(`    condition: ${w.condition} | action: ${w.action} | triggers: ${w.trigger_count} | last: ${lastCheck} | ID: ${w.id}`);
+    }
+    console.log('');
+}
+export async function deleteWatcher(id) {
+    const db = requireDb();
+    const result = db.prepare('DELETE FROM watchers WHERE id = ?').run(id);
+    closeDb();
+    if (result.changes > 0) {
+        console.log(`Deleted watcher: ${id}`);
     }
     else {
-        console.log(`No cron job found with ID: ${id}`);
+        console.log(`No watcher found with ID: ${id}`);
     }
 }
 export async function listMemories() {
@@ -232,4 +267,3 @@ export async function sendMessage(message) {
     }
     closeDb();
 }
-//# sourceMappingURL=commands.js.map

package/dist/cli/doctor.d.ts

@@ -1,2 +1 @@
 export declare function runDoctor(): Promise<void>;
-//# sourceMappingURL=doctor.d.ts.map

package/dist/cli/doctor.js

@@ -8,7 +8,8 @@ export async function runDoctor() {
     try {
         const config = getConfig();
         const bin = config.claudeCode?.bin || 'claude';
-        execSync(`which ${bin}`, { encoding: 'utf-8' });
+        const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+        execSync(`${whichCmd} ${bin}`, { encoding: 'utf-8' });
         try {
             const version = execSync(`${bin} --version 2>&1`, { encoding: 'utf-8' }).trim();
             checks.push({ name: 'Claude Code', status: 'pass', message: `Found: ${version}` });
@@ -147,4 +148,3 @@ export async function runDoctor() {
     if (fails > 0)
         process.exit(1);
 }
-//# sourceMappingURL=doctor.js.map

package/dist/cli/handoff.d.ts

@@ -13,4 +13,3 @@ export declare function exportTab(tabName: string): TabInfo | null;
 export declare function attachTab(tabName: string): void;
 export declare function formatHandoffInfo(info: TabInfo): string;
 export {};
-//# sourceMappingURL=handoff.d.ts.map

package/dist/cli/handoff.js

@@ -66,4 +66,3 @@ export function formatHandoffInfo(info) {
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=handoff.js.map

package/dist/cli/helpers.d.ts

@@ -1,3 +1,2 @@
 export { timeAgo } from '../util/text.js';
 export declare function getDaemonPid(): number | null;
-//# sourceMappingURL=helpers.d.ts.map