beecork 1.7.0 → 2.0.0

package/dist/session/manager.js

@@ -1,379 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { ClaudeSubprocess } from './subprocess.js';
-import { CircuitBreaker } from './circuit-breaker.js';
-import { ContextMonitor } from './context-monitor.js';
-import { TabStore } from './tab-store.js';
-import { MessageQueue } from './message-queue.js';
-import { BudgetGuard } from './budget-guard.js';
-import { StaleSessionDetector } from './stale-session.js';
-import { ContextCompactor } from './context-compactor.js';
-import { PendingMessageStore } from './pending-store.js';
-import { completeDelegation } from '../delegation/manager.js';
-import { getDb } from '../db/index.js';
-import { resolveWorkingDir, validateTabName } from '../config.js';
-import { logger } from '../util/logger.js';
-import { logActivity } from '../timeline/index.js';
-import { getAllKnowledge, formatKnowledgeForContext } from '../knowledge/index.js';
-/**
- * TabManager orchestrates per-tab Claude subprocess lifecycles. Heavy lifting
- * (queueing, budget enforcement, stale-session recovery, context compaction,
- * pending-message dispatch) is delegated to collaborators in this directory
- * so this class stays focused on:
- *
- *   - tab CRUD (ensureTab, listTabs, stopTab, closeTab, stopAll)
- *   - subprocess orchestration (executeMessage)
- *   - wiring the collaborators together
- *
- * The split happened in the 2026-05-15 audit fix; see the audit file for the
- * rationale. Before the split this file was 467 lines and 10 responsibilities.
- */
-export class TabManager {
-    config;
-    subprocesses = new Map();
-    queue = new MessageQueue();
-    budget;
-    // In-memory cache of per-tab cumulative cost. Lazily seeded with a single
-    // SUM query when a tab is first checked; thereafter updated incrementally
-    // from the assistant-message insert. Saves an O(N messages) SUM scan on
-    // every inbound message — the previous code re-aggregated the entire tab
-    // history just to gate budget.
-    tabCostCache = new Map();
-    onNotify = null;
-    constructor(config) {
-        this.config = config;
-        this.budget = new BudgetGuard(config.claudeCode.maxBudgetUsd);
-    }
-    /** Set a callback for sending notifications (e.g., via Telegram) */
-    setNotifyCallback(cb) {
-        this.onNotify = cb;
-    }
-    /** Ensure a tab exists in the database. Creates it if missing. */
-    ensureTab(tabName, workingDirOverride) {
-        const db = getDb();
-        const existing = TabStore.findByName(tabName);
-        if (existing)
-            return existing;
-        // Validate tab name before creating (centralized for all channels + MCP)
-        if (tabName !== 'default') {
-            const validationError = validateTabName(tabName);
-            if (validationError)
-                throw new Error(validationError);
-        }
-        // Check for a matching tab template
-        const template = this.config.tabTemplates?.[tabName];
-        const tab = {
-            id: uuidv4(),
-            name: tabName,
-            sessionId: uuidv4(),
-            status: 'idle',
-            workingDir: workingDirOverride || template?.workingDir || resolveWorkingDir(tabName),
-            createdAt: new Date().toISOString(),
-            lastActivityAt: new Date().toISOString(),
-            pid: null,
-            systemPrompt: template?.systemPrompt || null,
-        };
-        db.prepare(`
-      INSERT INTO tabs (id, name, session_id, status, working_dir, created_at, last_activity_at, system_prompt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(tab.id, tab.name, tab.sessionId, tab.status, tab.workingDir, tab.createdAt, tab.lastActivityAt, tab.systemPrompt);
-        logger.info(`Created tab: ${tabName}`);
-        return tab;
-    }
-    /** Send a message to a tab. Creates the tab if it doesn't exist. Queues if busy. */
-    async sendMessage(tabName, prompt, options) {
-        const tab = this.ensureTab(tabName, options?.projectPath);
-        // If a subprocess is already running on this tab, queue the message
-        if (this.subprocesses.get(tabName)?.isRunning) {
-            return new Promise((resolve, reject) => {
-                const accepted = this.queue.enqueue(tabName, { prompt, resolve, reject });
-                if (!accepted) {
-                    reject(new Error(`Queue full for tab "${tabName}". Try again later.`));
-                    return;
-                }
-                logger.info(`[${tabName}] Message queued (queue size: ${this.queue.size(tabName)})`);
-            });
-        }
-        return this.executeMessage(tab, prompt, options?.resume ?? false, options?.onTextChunk, options?.onToolUse, options?._compactionDepth);
-    }
-    /** Get all tabs from the database */
-    listTabs() {
-        return TabStore.listAll();
-    }
-    /** Get a specific tab */
-    getTab(tabName) {
-        return TabStore.findByName(tabName);
-    }
-    /** Stop a tab's running subprocess */
-    stopTab(tabName) {
-        const sub = this.subprocesses.get(tabName);
-        if (sub?.isRunning)
-            sub.kill();
-        this.updateTabStatus(tabName, 'stopped');
-        this.clearQueue(tabName);
-    }
-    /** Update a tab's system_prompt. Returns true if the tab existed. */
-    setSystemPrompt(tabName, systemPrompt) {
-        return TabStore.setSystemPrompt(tabName, systemPrompt);
-    }
-    /** Close a tab — stop subprocess and delete its rows. Returns true if the tab existed. */
-    closeTab(tabName) {
-        const tab = TabStore.findByName(tabName);
-        this.stopTab(tabName);
-        if (tab)
-            this.tabCostCache.delete(tab.id);
-        return TabStore.deleteWithMessages(tabName);
-    }
-    /** Stop all running subprocesses (clean shutdown) */
-    stopAll() {
-        for (const [tabName, sub] of this.subprocesses) {
-            if (sub.isRunning)
-                sub.kill();
-            this.updateTabStatus(tabName, 'stopped');
-        }
-        this.subprocesses.clear();
-        for (const dropped of this.queue.clearAll()) {
-            for (const item of dropped) {
-                item.reject(new Error('Daemon shutting down'));
-            }
-        }
-    }
-    async executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth, forceFresh = false, retryDepth = 0) {
-        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) {
-            let tabSpend = this.tabCostCache.get(tab.id);
-            if (tabSpend === undefined) {
-                tabSpend = db
-                    .prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE tab_id = ?')
-                    .get(tab.id).total;
-                this.tabCostCache.set(tab.id, tabSpend);
-            }
-            const decision = this.budget.check(tabSpend, tab.name);
-            if (!decision.allowed) {
-                this.onNotify?.(decision.reason).catch(() => { });
-                return {
-                    text: decision.reason,
-                    costUsd: 0,
-                    durationMs: 0,
-                    sessionId: tab.sessionId,
-                    error: true,
-                };
-            }
-            if (decision.warning) {
-                this.onNotify?.(decision.warning).catch(() => { });
-            }
-        }
-        // Inject knowledge (global markdown + project markdown + tab facts)
-        const knowledge = getAllKnowledge(tab.workingDir, tab.name);
-        const knowledgeContext = formatKnowledgeForContext(knowledge);
-        const enrichedPrompt = knowledgeContext ? `${knowledgeContext}\n\n${prompt}` : prompt;
-        // Store user message
-        db.prepare('INSERT INTO messages (tab_id, role, content) VALUES (?, ?, ?)').run(tab.id, 'user', prompt);
-        this.updateTabStatus(tab.name, 'running');
-        // Get fresh tab to pick up system_prompt
-        const freshTab = TabStore.findByName(tab.name) || tab;
-        const subprocess = new ClaudeSubprocess(tab.name, tab.workingDir, this.config, tab.sessionId, freshTab.systemPrompt);
-        this.subprocesses.set(tab.name, subprocess);
-        // Circuit breaker is per-call state — its lifetime is exactly the
-        // subprocess's lifetime. Keep it as a local const; the previous
-        // circuitBreakers Map suggested cross-call state but nothing read it
-        // outside this scope.
-        const breaker = new CircuitBreaker(tab.name);
-        const contextMonitor = new ContextMonitor(tab.name);
-        // Resume if: explicitly requested or DB has prior successful responses for this tab.
-        // forceFresh overrides both — used after a stale-session retry to guarantee --session-id, not --resume.
-        // LIMIT 1 short-circuits on the first matching row — a long-running tab with
-        // 10k messages used to walk the whole index for a boolean answer.
-        const hasDbHistory = db
-            .prepare("SELECT 1 FROM messages WHERE tab_id = ? AND role = 'assistant' AND content != '' LIMIT 1")
-            .get(tab.id) !== undefined;
-        const shouldResume = !forceFresh && (resume || hasDbHistory);
-        return new Promise((resolve, reject) => {
-            let resultText = '';
-            let resultEvent = null;
-            let loopWarningPending = false;
-            let checkpointTriggered = false;
-            // Prevent the SIGTERM-then-exit double dispatch: when onError already
-            // routed the failure through reject() + processNextInQueue, suppress
-            // the inevitable subsequent onExit so the queue doesn't shift twice.
-            let errored = false;
-            const callbacks = {
-                onEvent: (event) => {
-                    // Capture session_id from StreamInit and update tab record
-                    if (event.type === 'system' && 'subtype' in event && event.subtype === 'init') {
-                        const initEvent = event;
-                        if (initEvent.session_id) {
-                            db.prepare('UPDATE tabs SET session_id = ? WHERE id = ?').run(initEvent.session_id, tab.id);
-                        }
-                    }
-                    if (event.type === 'assistant') {
-                        const assistant = event;
-                        // Track context usage
-                        if (assistant.message.usage) {
-                            const contextAction = contextMonitor.recordUsage(assistant.message.usage);
-                            if (contextAction === 'warn') {
-                                logger.info(`[${tab.name}] Context window warning — will summarize on next turn`);
-                            }
-                            else if (contextAction === 'checkpoint') {
-                                checkpointTriggered = true;
-                                logger.warn(`[${tab.name}] Context window checkpoint triggered`);
-                            }
-                        }
-                        for (const block of assistant.message.content) {
-                            if (block.type === 'text') {
-                                resultText += block.text;
-                                onTextChunk?.(block.text);
-                            }
-                            else if (block.type === 'tool_use') {
-                                const toolUse = block;
-                                onToolUse?.(toolUse.name, toolUse.input);
-                                const action = breaker.recordToolCall(toolUse);
-                                if (action === 'break') {
-                                    logger.warn(`[${tab.name}] Circuit breaker tripped, killing subprocess`);
-                                    subprocess.kill();
-                                }
-                                else if (action === 'notify') {
-                                    this.onNotify?.(`Loop detected in tab "${tab.name}": ${toolUse.name} repeated 10+ times. Send /stop ${tab.name} to kill it.`).catch((err) => logger.warn('Notify failed:', err));
-                                }
-                                else if (action === 'warn') {
-                                    loopWarningPending = true;
-                                }
-                            }
-                        }
-                    }
-                    else if (event.type === 'result') {
-                        resultEvent = event;
-                    }
-                },
-                onExit: (code) => {
-                    if (errored) {
-                        // onError already rejected and drained the queue; don't double-dispatch.
-                        return;
-                    }
-                    this.subprocesses.delete(tab.name);
-                    const result = {
-                        text: resultEvent?.result ?? resultText,
-                        costUsd: resultEvent?.total_cost_usd ?? 0,
-                        durationMs: resultEvent?.duration_ms ?? 0,
-                        sessionId: subprocess.sessionId,
-                        error: resultEvent?.is_error ?? code !== 0,
-                    };
-                    // Handle resume failure (Claude Code session cache rotated / never existed / expired).
-                    if (StaleSessionDetector.isStale(result, resultEvent, shouldResume, retryDepth)) {
-                        const detail = resultEvent?.errors?.[0] ?? result.text.split('\n')[0];
-                        logger.warn(`[${tab.name}] Resume session ${tab.sessionId} unavailable in Claude Code cache (${detail}). Retrying with fresh session.`);
-                        const recovery = StaleSessionDetector.buildRecovery(tab.id, enrichedPrompt, db);
-                        db.prepare('UPDATE tabs SET session_id = ?, status = ? WHERE id = ?').run(recovery.newSessionId, 'idle', tab.id);
-                        this.executeMessage({ ...tab, sessionId: recovery.newSessionId }, recovery.contextPrompt, false, onTextChunk, onToolUse, compactionDepth, true, retryDepth + 1)
-                            .then(resolve)
-                            .catch(reject);
-                        return;
-                    }
-                    // Store assistant response. Skip empty content (typically failed/error runs) so
-                    // it doesn't trigger the hasDbHistory shouldResume override on future calls.
-                    if (result.text.trim() !== '') {
-                        db.prepare('INSERT INTO messages (tab_id, role, content, cost_usd, tokens_in, tokens_out) VALUES (?, ?, ?, ?, ?, ?)').run(tab.id, 'assistant', result.text, result.costUsd, resultEvent?.usage?.input_tokens ?? null, resultEvent?.usage?.output_tokens ?? null);
-                        // Keep the budget cache in sync with the row we just inserted —
-                        // avoids the per-message SUM scan in the next budget check.
-                        if (this.tabCostCache.has(tab.id)) {
-                            this.tabCostCache.set(tab.id, (this.tabCostCache.get(tab.id) ?? 0) + (result.costUsd || 0));
-                        }
-                    }
-                    // 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 < ContextCompactor.MAX_DEPTH) {
-                        // Compactor handles its own try/catch and always returns a SendResult.
-                        // The queue drain MUST happen regardless of compaction outcome — the
-                        // previous pattern omitted it in this branch, so a queued message
-                        // could wait indefinitely while compaction recursion was in flight.
-                        ContextCompactor.compact(tab, enrichedPrompt, result, onTextChunk, currentDepth, (tabName, p, opts) => this.sendMessage(tabName, p, opts), this.onNotify, db)
-                            .then(resolve)
-                            .finally(() => this.processNextInQueue(tab.name));
-                        return;
-                    }
-                    // Check for delegation completion
-                    try {
-                        const delegation = completeDelegation(tab.name, result.text);
-                        if (delegation && delegation.returnToTab) {
-                            PendingMessageStore.enqueueDelegationResult(delegation.returnToTab, `[Result from tab:${tab.name}]: ${result.text.slice(0, 10000)}`);
-                            logActivity('delegation_completed', `Delegation ${tab.name} → ${delegation.returnToTab}`, {
-                                tabName: tab.name,
-                                details: result.text.slice(0, 500),
-                            });
-                            this.onNotify?.(`Delegation complete: ${tab.name} → result sent back to ${delegation.returnToTab}`).catch(() => { });
-                            logger.info(`Delegation result sent: ${tab.name} → ${delegation.returnToTab}`);
-                        }
-                    }
-                    catch (err) {
-                        logger.warn('Delegation completion check failed:', err);
-                    }
-                    resolve(result);
-                    // Process next queued message (prepend loop warning if needed)
-                    if (loopWarningPending) {
-                        const next = this.queue.peek(tab.name);
-                        if (next) {
-                            next.prompt = `[WARNING: You appear to be repeating the same action. Reassess your approach.]\n\n${next.prompt}`;
-                            loopWarningPending = false;
-                        }
-                    }
-                    this.processNextInQueue(tab.name);
-                },
-                onError: (err) => {
-                    errored = true;
-                    this.subprocesses.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);
-                },
-            };
-            subprocess.send(enrichedPrompt, callbacks, shouldResume).catch((err) => {
-                if (!errored) {
-                    errored = true;
-                    this.subprocesses.delete(tab.name);
-                    this.updateTabStatus(tab.name, 'error');
-                    reject(err);
-                    this.processNextInQueue(tab.name);
-                }
-            });
-        });
-    }
-    processNextInQueue(tabName) {
-        const next = this.queue.dequeue(tabName);
-        if (!next)
-            return;
-        const tab = this.getTab(tabName);
-        if (!tab) {
-            next.reject(new Error(`Tab "${tabName}" not found`));
-            return;
-        }
-        this.executeMessage(tab, next.prompt, false).then(next.resolve).catch(next.reject);
-    }
-    updateTabStatus(tabName, status) {
-        TabStore.setStatus(tabName, status);
-    }
-    clearQueue(tabName) {
-        const dropped = this.queue.clear(tabName);
-        for (const item of dropped) {
-            item.reject(new Error(`Tab "${tabName}" was stopped`));
-        }
-    }
-}

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

@@ -1,29 +0,0 @@
-/**
- * Small store wrapping the `memories` table. Used by the MCP and dashboard
- * layers instead of inline `INSERT INTO memories` so schema details stay in
- * one place.
- */
-import type Database from 'better-sqlite3';
-export interface MemoryRow {
-    id: number;
-    content: string;
-    tabName: string | null;
-    source: string;
-    createdAt: string;
-}
-export declare const MemoryStore: {
-    add(content: string, opts?: {
-        tabName?: string | null;
-        source?: string;
-    }, db?: Database.Database): void;
-    delete(id: number | string, db?: Database.Database): boolean;
-    count(db?: Database.Database): number;
-    list(opts?: {
-        limit?: number;
-        offset?: number;
-        query?: string;
-    }, db?: Database.Database): {
-        memories: MemoryRow[];
-        total: number;
-    };
-};

package/dist/session/memory-store.js

@@ -1,45 +0,0 @@
-/**
- * Small store wrapping the `memories` table. Used by the MCP and dashboard
- * layers instead of inline `INSERT INTO memories` so schema details stay in
- * one place.
- */
-import { getDb } from '../db/index.js';
-function rowToMemory(r) {
-    return {
-        id: r.id,
-        content: r.content,
-        tabName: r.tab_name,
-        source: r.source,
-        createdAt: r.created_at,
-    };
-}
-export const MemoryStore = {
-    add(content, opts, db = getDb()) {
-        db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(content, opts?.tabName ?? null, opts?.source ?? 'tool');
-    },
-    delete(id, db = getDb()) {
-        const result = db.prepare('DELETE FROM memories WHERE id = ?').run(id);
-        return result.changes > 0;
-    },
-    count(db = getDb()) {
-        return db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
-    },
-    list(opts = {}, db = getDb()) {
-        const limit = opts.limit ?? 50;
-        const offset = opts.offset ?? 0;
-        if (opts.query) {
-            const rows = db
-                .prepare('SELECT id, content, tab_name, source, created_at FROM memories WHERE content LIKE ? ORDER BY created_at DESC LIMIT ? OFFSET ?')
-                .all(`%${opts.query}%`, limit, offset);
-            const total = db
-                .prepare('SELECT COUNT(*) as c FROM memories WHERE content LIKE ?')
-                .get(`%${opts.query}%`).c;
-            return { memories: rows.map(rowToMemory), total };
-        }
-        const rows = db
-            .prepare('SELECT id, content, tab_name, source, created_at FROM memories ORDER BY created_at DESC LIMIT ? OFFSET ?')
-            .all(limit, offset);
-        const total = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
-        return { memories: rows.map(rowToMemory), total };
-    },
-};

package/dist/session/message-queue.d.ts

@@ -1,28 +0,0 @@
-/**
- * Per-tab FIFO queue for messages waiting on a busy subprocess.
- *
- * Extracted from TabManager so the queue's "max size, enqueue, dequeue,
- * peek-and-mutate-next, clear-on-stop" semantics are self-contained and
- * unit-testable without spinning up a real subprocess.
- */
-import type { SendResult } from './manager.js';
-export declare const MAX_QUEUE_SIZE = 10;
-export interface QueuedMessage {
-    prompt: string;
-    resolve: (r: SendResult) => void;
-    reject: (e: Error) => void;
-}
-export declare class MessageQueue {
-    private queues;
-    /** Attempt to enqueue. Returns false if the per-tab queue is full. */
-    enqueue(tabName: string, msg: QueuedMessage): boolean;
-    /** Remove and return the next message. Drops the per-tab entry when empty. */
-    dequeue(tabName: string): QueuedMessage | undefined;
-    /** Peek at the next queued message without removing it (used to inject loop warning prefix). */
-    peek(tabName: string): QueuedMessage | undefined;
-    size(tabName: string): number;
-    /** Drain the queue for a tab, returning the dropped messages so callers can reject them. */
-    clear(tabName: string): QueuedMessage[];
-    /** Drain every queue. Returns the dropped messages grouped by tab. */
-    clearAll(): QueuedMessage[][];
-}

package/dist/session/message-queue.js

@@ -1,52 +0,0 @@
-/**
- * Per-tab FIFO queue for messages waiting on a busy subprocess.
- *
- * Extracted from TabManager so the queue's "max size, enqueue, dequeue,
- * peek-and-mutate-next, clear-on-stop" semantics are self-contained and
- * unit-testable without spinning up a real subprocess.
- */
-export const MAX_QUEUE_SIZE = 10;
-export class MessageQueue {
-    queues = new Map();
-    /** Attempt to enqueue. Returns false if the per-tab queue is full. */
-    enqueue(tabName, msg) {
-        let queue = this.queues.get(tabName);
-        if (!queue) {
-            queue = [];
-            this.queues.set(tabName, queue);
-        }
-        if (queue.length >= MAX_QUEUE_SIZE)
-            return false;
-        queue.push(msg);
-        return true;
-    }
-    /** Remove and return the next message. Drops the per-tab entry when empty. */
-    dequeue(tabName) {
-        const queue = this.queues.get(tabName);
-        if (!queue || queue.length === 0)
-            return undefined;
-        const next = queue.shift();
-        if (queue.length === 0)
-            this.queues.delete(tabName);
-        return next;
-    }
-    /** Peek at the next queued message without removing it (used to inject loop warning prefix). */
-    peek(tabName) {
-        return this.queues.get(tabName)?.[0];
-    }
-    size(tabName) {
-        return this.queues.get(tabName)?.length ?? 0;
-    }
-    /** Drain the queue for a tab, returning the dropped messages so callers can reject them. */
-    clear(tabName) {
-        const queue = this.queues.get(tabName) ?? [];
-        this.queues.delete(tabName);
-        return queue;
-    }
-    /** Drain every queue. Returns the dropped messages grouped by tab. */
-    clearAll() {
-        const all = Array.from(this.queues.values());
-        this.queues.clear();
-        return all;
-    }
-}

package/dist/session/pending-dispatcher.d.ts

@@ -1,31 +0,0 @@
-/**
- * Polls `pending_messages` and dispatches each row by type.
- *
- * Replaces the inline `processPendingMessages` block that previously lived in
- * TabManager. Two functional changes from that code:
- *
- *  1. Claim-before-dispatch (status='processing' set atomically before send).
- *     The original poll-every-5s code re-picked the same row on every tick
- *     while its dispatch was in flight — long Claude runs could re-fire the
- *     same prompt many times.
- *
- *  2. Branch on type. The original consumer only recognized 'notification' and
- *     fell through to "send as plain user prompt" for everything else, which
- *     meant `type='media'` rows were handed to Claude as raw JSON and never
- *     actually delivered to channels.
- */
-import type { TabManager } from './manager.js';
-import type { ChannelRegistry } from '../channels/registry.js';
-export type NotifyFn = ((text: string) => Promise<void>) | null;
-export declare class PendingMessageDispatcher {
-    private tabManager;
-    private channels;
-    private onNotify;
-    private pollCount;
-    constructor(tabManager: TabManager, channels: ChannelRegistry, onNotify: NotifyFn);
-    /** Reset any rows stuck in 'processing' from a previous daemon run. */
-    recoverOnStart(): void;
-    /** Called on every daemon poll tick. */
-    tick(): void;
-    private dispatch;
-}