beecork 1.7.0 → 1.7.1

package/dist/cron/scheduler.d.ts

@@ -0,0 +1,22 @@
+import type { TabManager, NotifyCallback } from '../session/manager.js';
+export declare class CronScheduler {
+    private tabManager;
+    private onNotify;
+    private scheduledJobs;
+    private store;
+    constructor(tabManager: TabManager, onNotify: NotifyCallback | null);
+    /** Load all cron jobs from store and schedule them */
+    loadAndSchedule(): void;
+    /** Check for the reload signal file and reload if present */
+    checkForReload(): void;
+    /** Stop all scheduled jobs */
+    stopAll(): void;
+    private scheduleJob;
+    private fireJob;
+    private handleSystemEvent;
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
+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/scheduler.js

@@ -0,0 +1,220 @@
+import cron from 'node-cron';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CronStore } from './store.js';
+import { getCronReloadSignalPath, getLogsDir } from '../util/paths.js';
+import { logger } from '../util/logger.js';
+export class CronScheduler {
+    tabManager;
+    onNotify;
+    scheduledJobs = new Map();
+    store = new CronStore();
+    constructor(tabManager, onNotify) {
+        this.tabManager = tabManager;
+        this.onNotify = onNotify;
+    }
+    /** Load all cron jobs from store and schedule them */
+    loadAndSchedule() {
+        // Cancel existing
+        for (const [, task] of this.scheduledJobs) {
+            task.stop();
+        }
+        this.scheduledJobs.clear();
+        const jobs = this.store.list();
+        let scheduled = 0;
+        let missedFires = 0;
+        for (const job of jobs) {
+            if (!job.enabled)
+                continue;
+            // Detect missed fires: one-time "at" jobs whose time has passed but never ran
+            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`);
+                    missedFires++;
+                    this.fireJob(job);
+                    this.store.update(job.id, { enabled: false }); // Disable after one-time execution
+                    continue;
+                }
+            }
+            this.scheduleJob(job);
+            scheduled++;
+        }
+        logger.info(`Cron: loaded ${scheduled} active jobs (${jobs.length} total)${missedFires > 0 ? `, fired ${missedFires} missed` : ''}`);
+    }
+    /** Check for the reload signal file and reload if present */
+    checkForReload() {
+        const signalPath = getCronReloadSignalPath();
+        if (fs.existsSync(signalPath)) {
+            try {
+                fs.unlinkSync(signalPath);
+            }
+            catch { /* race condition, ok */ }
+            logger.info('Cron: reload signal detected, reloading schedules');
+            this.loadAndSchedule();
+        }
+    }
+    /** Stop all scheduled jobs */
+    stopAll() {
+        for (const [, task] of this.scheduledJobs) {
+            task.stop();
+        }
+        this.scheduledJobs.clear();
+    }
+    scheduleJob(job) {
+        switch (job.scheduleType) {
+            case 'cron': {
+                if (!cron.validate(job.schedule)) {
+                    logger.error(`Cron: invalid expression for "${job.name}": ${job.schedule}`);
+                    return;
+                }
+                const task = cron.schedule(job.schedule, () => this.fireJob(job));
+                this.scheduledJobs.set(job.id, task);
+                break;
+            }
+            case 'every': {
+                const cronExpr = intervalToCron(job.schedule);
+                if (cronExpr) {
+                    if (!cron.validate(cronExpr)) {
+                        logger.error(`Cron: invalid cron expression for "${job.name}": ${cronExpr}`);
+                        return;
+                    }
+                    const task = cron.schedule(cronExpr, () => this.fireJob(job));
+                    this.scheduledJobs.set(job.id, task);
+                }
+                else {
+                    // Use setInterval for non-cron-expressible intervals
+                    const totalMs = intervalToMs(job.schedule);
+                    if (totalMs) {
+                        const timer = setInterval(() => this.fireJob(job), totalMs);
+                        this.scheduledJobs.set(job.id, { stop: () => clearInterval(timer) });
+                    }
+                    else {
+                        logger.error(`Cron: invalid interval for "${job.name}": ${job.schedule}`);
+                    }
+                }
+                break;
+            }
+            case 'at': {
+                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`);
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    this.fireJob(job);
+                    this.store.update(job.id, { enabled: false });
+                }, delay);
+                this.scheduledJobs.set(job.id, { stop: () => clearTimeout(timer) });
+                break;
+            }
+        }
+    }
+    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
+        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`);
+            }
+            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`);
+            }
+            return;
+        }
+        try {
+            this.tabManager.ensureTab(job.tabName);
+            const result = await this.tabManager.sendMessage(job.tabName, job.message);
+            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)
+            try {
+                if (this.onNotify) {
+                    if (result.error) {
+                        await this.onNotify(`❌ [${job.name}] Failed — ${firstLine}`);
+                    }
+                    else {
+                        await this.onNotify(`✅ [${job.name}] Done — ${firstLine}`);
+                    }
+                }
+            }
+            catch (notifyErr) {
+                logger.warn(`Cron job "${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`);
+            try {
+                await this.onNotify?.(`❌ [${job.name}] Failed — ${errMsg}`);
+            }
+            catch { /* notification best-effort */ }
+        }
+    }
+    async handleSystemEvent(job) {
+        switch (job.message) {
+            case 'health_check':
+                logger.info('System event: health check — daemon alive');
+                if (this.onNotify) {
+                    await this.onNotify('🟢 Beecork health check: all systems operational');
+                }
+                break;
+            case 'memory_compaction':
+                logger.info('System event: memory compaction (not yet implemented)');
+                break;
+            default:
+                logger.warn(`Unknown system event: ${job.message}`);
+        }
+    }
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to milliseconds */
+export function intervalToMs(interval) {
+    const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
+    if (!match || match.slice(1).every(g => g === undefined))
+        return null;
+    const weeks = parseInt(match[1] || '0', 10);
+    const days = parseInt(match[2] || '0', 10);
+    const hours = parseInt(match[3] || '0', 10);
+    const mins = parseInt(match[4] || '0', 10);
+    const totalMs = ((weeks * 7 * 24 * 60) + (days * 24 * 60) + (hours * 60) + mins) * 60 * 1000;
+    return totalMs > 0 ? totalMs : null;
+}
+/** Convert human interval (30m, 2h, 1d, 1h30m, 2w) to cron expression */
+export function intervalToCron(interval) {
+    // Try combined format: 1h30m, 2h, 30m, 1d, 2w
+    const match = interval.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?$/);
+    if (!match || match.slice(1).every(g => g === undefined))
+        return null;
+    const weeks = parseInt(match[1] || '0', 10);
+    const days = parseInt(match[2] || '0', 10);
+    const hours = parseInt(match[3] || '0', 10);
+    const mins = parseInt(match[4] || '0', 10);
+    // Convert to total minutes for simple intervals
+    const totalMins = weeks * 7 * 24 * 60 + days * 24 * 60 + hours * 60 + mins;
+    if (totalMins <= 0)
+        return null;
+    // Simple minute interval
+    if (totalMins <= 59)
+        return `*/${totalMins} * * * *`;
+    // Hourly intervals
+    if (mins === 0 && days === 0 && weeks === 0 && hours > 0 && hours <= 23)
+        return `0 */${hours} * * *`;
+    // Daily intervals
+    if (mins === 0 && hours === 0 && weeks === 0 && days > 0)
+        return `0 0 */${days} * *`;
+    // 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
+    return null;
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/cron/store.d.ts

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

package/dist/cron/store.js

@@ -0,0 +1,83 @@
+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) {
+    return {
+        id: row.id, name: row.name,
+        scheduleType: row.schedule_type,
+        schedule: row.schedule, tabName: row.tab_name, message: row.message,
+        payloadType: row.payload_type || 'agentTurn',
+        enabled: row.enabled === 1, createdAt: row.created_at,
+        lastRunAt: row.last_run_at, nextRunAt: row.next_run_at,
+    };
+}
+export class CronStore {
+    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);
+    }
+    get(id) {
+        const db = getDb();
+        const row = db.prepare('SELECT * FROM cron_jobs WHERE id = ?').get(id);
+        return row ? rowToJob(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)
+      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) {
+        const db = getDb();
+        const existing = this.get(id);
+        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);
+        return true;
+    }
+    delete(id) {
+        const db = getDb();
+        const result = db.prepare('DELETE FROM cron_jobs WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    /** One-time migration from crontab.json to SQLite */
+    migrateFromJson() {
+        const jsonPath = getCrontabPath();
+        if (!fs.existsSync(jsonPath))
+            return;
+        const db = getDb();
+        const count = db.prepare('SELECT COUNT(*) as count FROM cron_jobs').get();
+        if (count.count > 0) {
+            // Already migrated, clean up JSON
+            try {
+                fs.renameSync(jsonPath, jsonPath + '.bak');
+            }
+            catch { /* ok */ }
+            return;
+        }
+        try {
+            const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+            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)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const tx = db.transaction(() => {
+                for (const j of jobs) {
+                    insert.run(j.id, j.name, j.scheduleType, j.schedule, j.tabName || 'default', j.message, j.enabled ? 1 : 0, 'local', j.createdAt, j.lastRunAt, j.nextRunAt);
+                }
+            });
+            tx();
+            fs.renameSync(jsonPath, jsonPath + '.bak');
+            logger.info(`Migrated ${jobs.length} cron jobs from JSON to SQLite`);
+        }
+        catch (err) {
+            logger.error('Failed to migrate cron jobs from JSON:', err);
+        }
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/machines/forwarder.d.ts

@@ -0,0 +1,7 @@
+import type { Machine } from './registry.js';
+/**
+ * Forward a message to a remote Beecork instance via SSH.
+ * Writes to the remote machine's pending_messages table.
+ */
+export declare function forwardToMachine(machine: Machine, tabName: string, message: string): Promise<boolean>;
+//# sourceMappingURL=forwarder.d.ts.map

package/dist/machines/forwarder.js

@@ -0,0 +1,35 @@
+import { execFileSync } from 'node:child_process';
+import { logger } from '../util/logger.js';
+import { validateTabName } from '../config.js';
+/**
+ * Forward a message to a remote Beecork instance via SSH.
+ * Writes to the remote machine's pending_messages table.
+ */
+export async function forwardToMachine(machine, tabName, message) {
+    if (!machine.host || !machine.sshUser) {
+        logger.warn(`Cannot forward to ${machine.name}: no SSH config`);
+        return false;
+    }
+    // Validate inputs to prevent injection via execFileSync args
+    if (tabName !== 'default') {
+        const tabError = validateTabName(tabName);
+        if (tabError) {
+            logger.error(`Invalid tab name for forwarding: ${tabError}`);
+            return false;
+        }
+    }
+    try {
+        // Use execFileSync with array args to prevent shell injection
+        execFileSync('ssh', [
+            `${machine.sshUser}@${machine.host}`,
+            'beecork', 'send', tabName, message,
+        ], { timeout: 30000, encoding: 'utf-8' });
+        logger.info(`Message forwarded to ${machine.name} (${machine.host}), tab: ${tabName}`);
+        return true;
+    }
+    catch (err) {
+        logger.error(`Failed to forward to ${machine.name}:`, err);
+        return false;
+    }
+}
+//# sourceMappingURL=forwarder.js.map

package/dist/machines/index.d.ts

@@ -0,0 +1 @@
+export { getMachineId, registerThisMachine, listMachines, type Machine } from './registry.js';

package/dist/machines/index.js

@@ -0,0 +1 @@
+export { getMachineId, registerThisMachine, listMachines } from './registry.js';

package/dist/machines/registry.d.ts

@@ -0,0 +1,15 @@
+export interface Machine {
+    id: string;
+    name: string;
+    host: string | null;
+    sshUser: string | null;
+    projectPaths: string[];
+    isPrimary: boolean;
+    lastSeenAt: string;
+}
+/** Get or create this machine's unique ID */
+export declare function getMachineId(): string;
+/** Register this machine in the database */
+export declare function registerThisMachine(projectPaths: string[]): Machine;
+/** List all machines */
+export declare function listMachines(): Machine[];

package/dist/machines/registry.js

@@ -0,0 +1,46 @@
+import os from 'node:os';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+import { getBeecorkHome } from '../util/paths.js';
+import { logger } from '../util/logger.js';
+import fs from 'node:fs';
+const MACHINE_ID_PATH = `${getBeecorkHome()}/machine-id`;
+/** Get or create this machine's unique ID */
+export function getMachineId() {
+    if (fs.existsSync(MACHINE_ID_PATH)) {
+        return fs.readFileSync(MACHINE_ID_PATH, 'utf-8').trim();
+    }
+    const id = uuidv4();
+    fs.writeFileSync(MACHINE_ID_PATH, id, { mode: 0o600 });
+    return id;
+}
+/** Register this machine in the database */
+export function registerThisMachine(projectPaths) {
+    const db = getDb();
+    const id = getMachineId();
+    const name = os.hostname();
+    db.prepare(`
+    INSERT INTO machines (id, name, project_paths, last_seen_at)
+    VALUES (?, ?, ?, datetime('now'))
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      project_paths = excluded.project_paths,
+      last_seen_at = datetime('now')
+  `).run(id, name, JSON.stringify(projectPaths));
+    logger.info(`Machine registered: ${name} (${id.slice(0, 8)}) with ${projectPaths.length} project paths`);
+    return { id, name, host: null, sshUser: null, projectPaths, isPrimary: false, lastSeenAt: new Date().toISOString() };
+}
+/** List all machines */
+export function listMachines() {
+    const db = getDb();
+    const rows = db.prepare('SELECT * FROM machines ORDER BY is_primary DESC, name').all();
+    return rows.map(r => ({
+        id: r.id,
+        name: r.name,
+        host: r.host,
+        sshUser: r.ssh_user,
+        projectPaths: JSON.parse(r.project_paths || '[]'),
+        isPrimary: !!r.is_primary,
+        lastSeenAt: r.last_seen_at,
+    }));
+}

package/dist/media/loader.d.ts

@@ -0,0 +1,8 @@
+import type { MediaGenerator } from './types.js';
+/**
+ * Discover and load community media generator packages from node_modules.
+ * Convention: packages named `beecork-media-<name>` must export a default
+ * class implementing the MediaGenerator interface.
+ */
+export declare function loadCommunityGenerators(apiKeys?: Record<string, string>): Promise<MediaGenerator[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/media/loader.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../util/logger.js';
+const MEDIA_PREFIX = 'beecork-media-';
+/**
+ * Discover and load community media generator packages from node_modules.
+ * Convention: packages named `beecork-media-<name>` must export a default
+ * class implementing the MediaGenerator interface.
+ */
+export async function loadCommunityGenerators(apiKeys) {
+    const generators = [];
+    const searchPaths = [path.join(process.cwd(), 'node_modules')];
+    for (const searchPath of searchPaths) {
+        if (!fs.existsSync(searchPath))
+            continue;
+        try {
+            for (const dir of fs.readdirSync(searchPath)) {
+                if (!dir.startsWith(MEDIA_PREFIX))
+                    continue;
+                try {
+                    const pkgPath = path.join(searchPath, dir);
+                    const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json'), 'utf-8'));
+                    const entryPath = path.join(pkgPath, pkgJson.main || 'index.js');
+                    if (!fs.existsSync(entryPath))
+                        continue;
+                    const module = await import(entryPath);
+                    const GeneratorClass = module.default || module[Object.keys(module)[0]];
+                    if (!GeneratorClass || typeof GeneratorClass !== 'function')
+                        continue;
+                    const name = dir.slice(MEDIA_PREFIX.length);
+                    const instance = new GeneratorClass(apiKeys?.[name]);
+                    if (!instance.id || !instance.name || typeof instance.generate !== 'function')
+                        continue;
+                    generators.push(instance);
+                    logger.info(`Community media generator loaded: ${instance.name} (${instance.id})`);
+                }
+                catch (err) {
+                    logger.warn(`Failed to load community generator ${dir}:`, err);
+                }
+            }
+        }
+        catch { }
+    }
+    return generators;
+}
+//# sourceMappingURL=loader.js.map

package/dist/memory/extractor.d.ts

@@ -0,0 +1,5 @@
+import type { BeecorkConfig } from '../types.js';
+/** Auto-extract memories from a completed session */
+export declare function extractMemories(config: BeecorkConfig, tabName: string, sessionText: string, durationMs: number): Promise<void>;
+/** Inject relevant memories into a prompt */
+export declare function getRelevantMemories(tabName: string): string[];

package/dist/memory/extractor.js

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+import { getDb } from '../db/index.js';
+import { logger } from '../util/logger.js';
+const EXTRACTION_PROMPT = `Extract 0-5 key facts, decisions, or outcomes from this session transcript that would be useful in future sessions. Output ONLY a JSON array of strings. If nothing is worth remembering, output an empty array [].
+
+Examples of what to extract:
+- Server addresses, credentials, file paths
+- User preferences ("prefers deployments after 11pm")
+- Decisions made ("chose PostgreSQL over MySQL for X reason")
+- Outcomes ("deploy succeeded", "bug was in auth middleware")
+
+Session transcript:
+`;
+/** Auto-extract memories from a completed session */
+export async function extractMemories(config, tabName, sessionText, durationMs) {
+    // Only extract from non-trivial sessions
+    if (durationMs < 10000 || sessionText.length < 200)
+        return;
+    // Rate limit: check if we extracted recently for this tab
+    const db = getDb();
+    const recent = db.prepare(`SELECT COUNT(*) as count FROM memories
+     WHERE tab_name = ? AND source = 'auto'
+     AND created_at > datetime('now', '-5 minutes')`).get(tabName);
+    if (recent.count > 0) {
+        logger.debug(`[${tabName}] Skipping memory extraction — too recent`);
+        return;
+    }
+    try {
+        const prompt = EXTRACTION_PROMPT + sessionText.slice(0, 5000); // Limit transcript size
+        const facts = await runExtractionSession(config, prompt);
+        if (facts.length === 0)
+            return;
+        for (const fact of facts) {
+            db.prepare('INSERT INTO memories (content, tab_name, source) VALUES (?, ?, ?)').run(fact, tabName, 'auto');
+        }
+        // Enforce maxLongTermEntries limit
+        const maxEntries = config.memory.maxLongTermEntries ?? 1000;
+        const count = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
+        if (count > maxEntries) {
+            const excess = count - maxEntries;
+            db.prepare('DELETE FROM memories WHERE rowid IN (SELECT rowid FROM memories ORDER BY created_at ASC LIMIT ?)').run(excess);
+            logger.info(`[${tabName}] Evicted ${excess} oldest memories (limit: ${maxEntries})`);
+        }
+        logger.info(`[${tabName}] Auto-extracted ${facts.length} memories`);
+    }
+    catch (err) {
+        logger.error(`[${tabName}] Memory extraction failed:`, err);
+    }
+}
+/** Inject relevant memories into a prompt */
+export function getRelevantMemories(tabName) {
+    const db = getDb();
+    // Get recent global memories + tab-specific memories
+    const memories = db.prepare(`SELECT content FROM memories
+     WHERE tab_name IS NULL OR tab_name = ?
+     ORDER BY created_at DESC LIMIT 20`).all(tabName);
+    return memories.map(m => m.content);
+}
+async function runExtractionSession(config, prompt) {
+    // Prefer direct API call (cheaper, faster) when API key is available
+    if (config.pipe?.anthropicApiKey) {
+        return runExtractionViaApi(config.pipe.anthropicApiKey, config.pipe.routingModel, prompt);
+    }
+    // Fallback: spawn Claude Code subprocess
+    return runExtractionViaSubprocess(config, prompt);
+}
+function parseFactsFromText(text) {
+    const jsonMatch = text.match(/\[[\s\S]*?\]/);
+    if (jsonMatch) {
+        const facts = JSON.parse(jsonMatch[0]);
+        if (Array.isArray(facts) && facts.every(f => typeof f === 'string')) {
+            return facts.slice(0, 5);
+        }
+    }
+    return [];
+}
+let cachedClient = null;
+let cachedApiKey = '';
+async function runExtractionViaApi(apiKey, model, prompt) {
+    const { default: Anthropic } = await import('@anthropic-ai/sdk');
+    if (!cachedClient || cachedApiKey !== apiKey) {
+        cachedClient = new Anthropic({ apiKey });
+        cachedApiKey = apiKey;
+    }
+    const client = cachedClient;
+    try {
+        const response = await client.messages.create({
+            model,
+            max_tokens: 500,
+            system: 'Extract 0-5 key facts from this session transcript worth remembering across sessions. Output ONLY a JSON array of strings. If nothing is worth remembering, output [].',
+            messages: [{ role: 'user', content: prompt }],
+        }, { timeout: 15000 });
+        const text = response.content.find((b) => b.type === 'text')?.text ?? '[]';
+        return parseFactsFromText(text);
+    }
+    catch (err) {
+        logger.warn('API-based memory extraction failed, falling back to subprocess:', err);
+        return [];
+    }
+}
+async function runExtractionViaSubprocess(config, prompt) {
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        const safeResolve = (val) => { if (!resolved) {
+            resolved = true;
+            resolve(val);
+        } };
+        const safeReject = (err) => { if (!resolved) {
+            resolved = true;
+            reject(err);
+        } };
+        const args = [
+            '-p',
+            '--output-format', 'stream-json',
+            '--verbose',
+            ...config.claudeCode.defaultFlags,
+            '--no-session-persistence',
+            prompt,
+        ];
+        const proc = spawn(config.claudeCode.bin, args, {
+            cwd: process.cwd(),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let output = '';
+        let stdoutBuffer = '';
+        proc.stdout.on('data', (chunk) => {
+            stdoutBuffer += chunk.toString();
+            const lines = stdoutBuffer.split('\n');
+            stdoutBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === 'result' && event.result) {
+                        output = event.result;
+                    }
+                }
+                catch { /* skip non-JSON */ }
+            }
+        });
+        proc.on('exit', () => {
+            clearTimeout(timer);
+            try {
+                safeResolve(parseFactsFromText(output));
+            }
+            catch {
+                safeResolve([]);
+            }
+        });
+        proc.on('error', safeReject);
+        const timer = setTimeout(() => {
+            proc.kill('SIGTERM');
+            safeResolve([]);
+        }, 30000);
+    });
+}

package/dist/pipe/anthropic-client.d.ts

@@ -0,0 +1,9 @@
+import type { RouteDecision, Project } from './types.js';
+export declare class PipeAnthropicClient {
+    private client;
+    private routingModel;
+    constructor(apiKey: string, routingModel: string);
+    /** Route a message to the right project/tab (Haiku — fast, cheap) */
+    route(message: string, projects: Project[], recentRouting: string[]): Promise<RouteDecision>;
+    private complete;
+}

package/dist/pipe/anthropic-client.js

@@ -0,0 +1,50 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { logger } from '../util/logger.js';
+import { retryWithBackoff } from '../util/retry.js';
+export class PipeAnthropicClient {
+    client;
+    routingModel;
+    constructor(apiKey, routingModel) {
+        this.client = new Anthropic({ apiKey });
+        this.routingModel = routingModel;
+    }
+    /** Route a message to the right project/tab (Haiku — fast, cheap) */
+    async route(message, projects, recentRouting) {
+        const projectList = projects.map(p => `- ${p.name}: ${p.path}${p.languages?.length ? ` (${p.languages.join(', ')})` : ''}${p.description ? ` — ${p.description}` : ''}`).join('\n');
+        const response = await this.complete(`You are a message router. Given a user message, determine which project it relates to.
+
+Available projects:
+${projectList || '(no projects discovered yet)'}
+
+Recent routing decisions:
+${recentRouting.slice(0, 5).join('\n') || '(none)'}
+
+Respond with ONLY valid JSON: {"tabName": "project-name", "projectPath": "/path", "confidence": 0.0-1.0, "reason": "brief explanation", "needsConfirmation": false}
+
+If the message is a general question not related to any project, use tabName "default" with the user's home directory.
+If unsure which project, set confidence below 0.5 and needsConfirmation to true.`, message);
+        try {
+            return JSON.parse(response);
+        }
+        catch {
+            logger.warn('Failed to parse routing response:', response);
+            return { tabName: 'default', projectPath: null, confidence: 0.3, reason: 'Could not parse routing', needsConfirmation: true };
+        }
+    }
+    async complete(systemPrompt, userMessage) {
+        try {
+            const response = await retryWithBackoff(() => this.client.messages.create({
+                model: this.routingModel,
+                max_tokens: 500,
+                system: systemPrompt,
+                messages: [{ role: 'user', content: userMessage }],
+            }, { timeout: 30000 }), [1000, 5000, 15000], `Pipe API call (routing)`);
+            const textBlock = response.content.find(b => b.type === 'text');
+            return textBlock?.text ?? '';
+        }
+        catch (err) {
+            logger.error(`Pipe API call failed (routing):`, err);
+            throw err;
+        }
+    }
+}

package/dist/pipe/brain.d.ts

@@ -0,0 +1,16 @@
+import type { TabManager } from '../session/manager.js';
+import type { BeecorkConfig } from '../types.js';
+import type { ChatContext, PipeResult } from './types.js';
+export declare class PipeBrain {
+    private client;
+    private memory;
+    private config;
+    private tabManager;
+    constructor(config: BeecorkConfig, tabManager: TabManager);
+    /** Main entry point: route a message to the right tab and send it to Claude. */
+    process(message: string, _context: ChatContext): Promise<PipeResult>;
+    /** Route a message to the right project/tab */
+    private route;
+    /** Discover projects on the filesystem */
+    discoverProjects(): Promise<number>;
+}

package/dist/pipe/brain.js

@@ -0,0 +1,89 @@
+import { PipeAnthropicClient } from './anthropic-client.js';
+import { PipeMemoryStore } from './memory-store.js';
+import { scanForProjects } from './project-scanner.js';
+import { parseTabMessage } from '../util/text.js';
+import { logger } from '../util/logger.js';
+export class PipeBrain {
+    client;
+    memory;
+    config;
+    tabManager;
+    constructor(config, tabManager) {
+        this.config = config;
+        this.tabManager = tabManager;
+        this.client = new PipeAnthropicClient(config.pipe.anthropicApiKey, config.pipe.routingModel);
+        this.memory = new PipeMemoryStore();
+    }
+    /** Main entry point: route a message to the right tab and send it to Claude. */
+    async process(message, _context) {
+        const decisions = [];
+        // Step 1: Route the message to the right tab/project
+        const route = await this.route(message, decisions);
+        // Step 2: Ensure the tab exists with the right working directory
+        if (route.projectPath) {
+            this.tabManager.ensureTab(route.tabName, route.projectPath);
+            this.memory.updateProjectLastUsed(route.projectPath);
+        }
+        // Step 3: Send to Claude Code
+        let result;
+        try {
+            result = await this.tabManager.sendMessage(route.tabName, message, { projectPath: route.projectPath ?? undefined });
+        }
+        catch (err) {
+            return {
+                tabName: route.tabName,
+                response: { text: `Error: ${err instanceof Error ? err.message : err}`, error: true, costUsd: 0, durationMs: 0 },
+                decisions,
+            };
+        }
+        return {
+            tabName: route.tabName,
+            response: { text: result.text, error: result.error, costUsd: result.costUsd, durationMs: result.durationMs },
+            decisions,
+        };
+    }
+    /** Route a message to the right project/tab */
+    async route(message, decisions) {
+        // Check for manual /tab override first
+        if (message.startsWith('/tab ')) {
+            const parsed = parseTabMessage(message);
+            if (parsed.tabName !== 'default') {
+                decisions.push(`📌 Manual routing to "${parsed.tabName}"`);
+                return { tabName: parsed.tabName, projectPath: null, confidence: 1.0, reason: 'Manual override', needsConfirmation: false };
+            }
+        }
+        const projects = this.memory.getProjects();
+        const recentRouting = this.memory.getRecentRouting(5);
+        // If no projects and no API key, just use default
+        if (projects.length === 0 || !this.config.pipe.anthropicApiKey) {
+            decisions.push('📍 Routing to default tab (no projects discovered)');
+            return { tabName: 'default', projectPath: null, confidence: 1.0, reason: 'No projects', needsConfirmation: false };
+        }
+        try {
+            const route = await this.client.route(message, projects, recentRouting);
+            // Record the routing decision
+            this.memory.recordRouting(message, route.tabName, route.projectPath, route.confidence);
+            if (route.confidence >= this.config.pipe.confidenceThreshold) {
+                decisions.push(`🧠 Routing to "${route.tabName}" (${Math.round(route.confidence * 100)}% confidence) — ${route.reason}`);
+            }
+            else {
+                decisions.push(`🤔 Low confidence routing to "${route.tabName}" (${Math.round(route.confidence * 100)}%) — ${route.reason}. Using default.`);
+                route.tabName = 'default';
+            }
+            return route;
+        }
+        catch (err) {
+            logger.error('Pipe routing failed, using default:', err);
+            decisions.push('⚠️ Routing failed, using default tab');
+            return { tabName: 'default', projectPath: null, confidence: 0.5, reason: 'Routing error', needsConfirmation: false };
+        }
+    }
+    /** Discover projects on the filesystem */
+    async discoverProjects() {
+        const projects = scanForProjects(this.config.pipe.projectScanPaths);
+        for (const project of projects) {
+            this.memory.upsertProject(project);
+        }
+        return projects.length;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { Project } from './types.js';
+export declare class PipeMemoryStore {
+    getProjects(): Project[];
+    upsertProject(project: Project): void;
+    updateProjectLastUsed(path: string): void;
+    getRecentRouting(limit?: number): string[];
+    recordRouting(messagePreview: string, tabName: string, projectPath: string | null, confidence: number): void;
+}

package/dist/pipe/memory-store.js

@@ -0,0 +1,39 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+export class PipeMemoryStore {
+    // ─── Projects ───
+    getProjects() {
+        const db = getDb();
+        const rows = db.prepare('SELECT * FROM projects ORDER BY last_used_at DESC NULLS LAST').all();
+        return rows.map(r => ({
+            id: r.id,
+            name: r.name,
+            path: r.path,
+            type: r.type || 'user-project',
+            lastUsedAt: r.last_used_at,
+            createdAt: r.created_at,
+        }));
+    }
+    upsertProject(project) {
+        const db = getDb();
+        db.prepare(`INSERT INTO projects (id, name, path, type)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET
+        path=excluded.path, type=excluded.type, last_used_at=datetime('now')
+    `).run(project.id || uuidv4(), project.name, project.path, project.type || 'user-project');
+    }
+    updateProjectLastUsed(path) {
+        const db = getDb();
+        db.prepare('UPDATE projects SET last_used_at = datetime("now") WHERE path = ?').run(path);
+    }
+    // ─── Routing History ───
+    getRecentRouting(limit = 10) {
+        const db = getDb();
+        const rows = db.prepare('SELECT message_preview, tab_name, confidence FROM routing_history ORDER BY created_at DESC LIMIT ?').all(limit);
+        return rows.map(r => `"${r.message_preview}" → ${r.tab_name} (${Math.round(r.confidence * 100)}%)`);
+    }
+    recordRouting(messagePreview, tabName, projectPath, confidence) {
+        const db = getDb();
+        db.prepare('INSERT INTO routing_history (message_preview, tab_name, project_path, confidence) VALUES (?, ?, ?, ?)').run(messagePreview.slice(0, 200), tabName, projectPath, confidence);
+    }
+}

package/dist/pipe/project-scanner.d.ts

@@ -0,0 +1,6 @@
+import type { Project } from './types.js';
+/**
+ * Read projects from the database (populated by discoverProjects() at daemon startup).
+ * Falls back to an empty list if the DB is not yet initialized.
+ */
+export declare function scanForProjects(_scanPaths: string[]): Project[];

package/dist/pipe/project-scanner.js

@@ -0,0 +1,26 @@
+import { getDb } from '../db/index.js';
+import { logger } from '../util/logger.js';
+/**
+ * Read projects from the database (populated by discoverProjects() at daemon startup).
+ * Falls back to an empty list if the DB is not yet initialized.
+ */
+export function scanForProjects(_scanPaths) {
+    try {
+        const db = getDb();
+        const rows = db.prepare('SELECT * FROM projects ORDER BY last_used_at DESC').all();
+        const projects = rows.map(r => ({
+            id: r.id,
+            name: r.name,
+            path: r.path,
+            type: r.type,
+            lastUsedAt: r.last_used_at,
+            createdAt: r.created_at,
+        }));
+        logger.info(`Project scanner: found ${projects.length} projects from DB`);
+        return projects;
+    }
+    catch (err) {
+        logger.warn('Project scanner: failed to read from DB, returning empty list:', err);
+        return [];
+    }
+}

package/dist/pipe/types.d.ts

@@ -0,0 +1,34 @@
+export interface Project {
+    id: string;
+    name: string;
+    path: string;
+    type: string;
+    lastUsedAt: string;
+    createdAt: string;
+    /** Populated at scan time, not persisted in DB */
+    description?: string;
+    /** Populated at scan time, not persisted in DB */
+    languages?: string[];
+}
+export interface RouteDecision {
+    tabName: string;
+    projectPath: string | null;
+    confidence: number;
+    reason: string;
+    needsConfirmation: boolean;
+}
+export interface ChatContext {
+    chatId: number;
+    userId: number;
+    messageId: number;
+}
+export interface PipeResult {
+    tabName: string;
+    response: {
+        text: string;
+        error: boolean;
+        costUsd: number;
+        durationMs: number;
+    };
+    decisions: string[];
+}

package/dist/pipe/types.js

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

package/dist/session/manager.js

@@ -273,6 +273,43 @@ export class TabManager {
                             .catch(reject);
                         return;
                     }
+                    // Silent network-stall recovery. The startup watchdog killed a
+                    // subprocess that never emitted a single event — almost always a
+                    // transient overnight DNS/connection blip that recovers within
+                    // seconds. Mirror the stale-session retry above (capped by retryDepth)
+                    // so a blip recovers inside a single fire instead of burning the full
+                    // maxRuntime and counting toward the 5-failure auto-disable.
+                    if (subprocess.killReason === 'silent') {
+                        if (retryDepth === 0) {
+                            logger.warn(`[${tab.name}] Subprocess produced no output (suspected transient network stall) — retrying once.`);
+                            // Don't touch the session — the subprocess may never have
+                            // initialized one. Retry with identical args.
+                            this.executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth, forceFresh, retryDepth + 1)
+                                .then(resolve)
+                                .catch(reject);
+                            return;
+                        }
+                        // Retry already attempted and it stalled again — surface a
+                        // network-specific failure instead of an empty "(no output)" so the
+                        // user checks connectivity, not their auth/subscription. Resolve
+                        // (not reject) with error:true; the scheduler counts this toward
+                        // auto-disable exactly like the maxRuntime path, and reports it via
+                        // the existing task-failure notification.
+                        logger.warn(`[${tab.name}] Still no output after retry — surfacing suspected network stall.`);
+                        db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?').run('idle', new Date().toISOString(), tab.name);
+                        logActivity('task_failed', 'Subprocess silent stall (retry exhausted)', {
+                            tabName: tab.name,
+                        });
+                        resolve({
+                            text: 'Subprocess produced no output, even after a retry — suspected network/DNS stall. Check connectivity.',
+                            costUsd: 0,
+                            durationMs: 0,
+                            sessionId: subprocess.sessionId,
+                            error: true,
+                        });
+                        this.processNextInQueue(tab.name);
+                        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() !== '') {

package/dist/session/subprocess.d.ts

@@ -15,6 +15,13 @@ export declare class ClaudeSubprocess {
     private buffer;
     private killTimer;
     private runtimeTimer;
+    private startupTimer;
+    /**
+     * Set when the startup watchdog kills a subprocess that never emitted a
+     * single event — distinguishes a transient network/connection stall from a
+     * normal exit or a real wall-clock overrun, so the manager can retry once.
+     */
+    killReason: 'silent' | null;
     readonly sessionId: string;
     constructor(tabName: string, workingDir: string, config: BeecorkConfig, sessionId?: string, tabSystemPrompt?: string | null | undefined);
     send(prompt: string, callbacks: SubprocessCallbacks, resume?: boolean): Promise<void>;

package/dist/session/subprocess.js

@@ -45,6 +45,13 @@ export class ClaudeSubprocess {
     buffer = '';
     killTimer = null;
     runtimeTimer = null;
+    startupTimer = null;
+    /**
+     * Set when the startup watchdog kills a subprocess that never emitted a
+     * single event — distinguishes a transient network/connection stall from a
+     * normal exit or a real wall-clock overrun, so the manager can retry once.
+     */
+    killReason = null;
     sessionId;
     constructor(tabName, workingDir, config, sessionId, tabSystemPrompt) {
         this.tabName = tabName;
@@ -75,6 +82,14 @@ export class ClaudeSubprocess {
                     continue;
                 try {
                     const event = JSON.parse(line);
+                    // First real event proves claude initialized and the socket is alive
+                    // — the startup-stall window is over, so disarm the watchdog for good.
+                    // It never re-arms, so legitimate multi-minute tool runs (which emit
+                    // nothing on stdout until the tool returns) are never killed.
+                    if (this.startupTimer) {
+                        clearTimeout(this.startupTimer);
+                        this.startupTimer = null;
+                    }
                     callbacks.onEvent(event);
                 }
                 catch {
@@ -99,6 +114,10 @@ export class ClaudeSubprocess {
                 clearTimeout(this.runtimeTimer);
                 this.runtimeTimer = null;
             }
+            if (this.startupTimer) {
+                clearTimeout(this.startupTimer);
+                this.startupTimer = null;
+            }
             callbacks.onError(err);
         });
         this.proc.on('exit', (code) => {
@@ -111,6 +130,10 @@ export class ClaudeSubprocess {
                 clearTimeout(this.runtimeTimer);
                 this.runtimeTimer = null;
             }
+            if (this.startupTimer) {
+                clearTimeout(this.startupTimer);
+                this.startupTimer = null;
+            }
             logger.info(`[${this.tabName}] Claude subprocess exited (code: ${code})`);
             callbacks.onExit(code);
         });
@@ -126,6 +149,24 @@ export class ClaudeSubprocess {
                 this.kill();
             }, maxRuntimeMs);
         }
+        // Startup watchdog. A healthy claude emits its init event within seconds of
+        // spawn. Total silence this long means it wedged on a stalled network socket
+        // (DNS/connection blip with no client-side timeout) and would otherwise sit
+        // idle until the 30-min maxRuntime kill. Unlike maxRuntime, this routes
+        // through onExit (kill only, no onError) so the manager retries once. It is
+        // disarmed on the first event, so it can only fire before claude initializes
+        // — long-running tools, which emit nothing on stdout until they return, are
+        // never affected.
+        const silentTimeoutMs = this.config.claudeCode.silentTimeoutMs ?? 120_000;
+        if (silentTimeoutMs > 0) {
+            this.startupTimer = setTimeout(() => {
+                if (!this.proc)
+                    return;
+                logger.warn(`[${this.tabName}] No output ${silentTimeoutMs}ms after spawn — killing as silent network stall`);
+                this.killReason = 'silent';
+                this.kill();
+            }, silentTimeoutMs);
+        }
     }
     kill() {
         if (!this.proc)

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

@@ -0,0 +1,4 @@
+/** Reserved for future approval mode implementation. Not currently wired into the runtime. */
+export type ToolRisk = 'safe' | 'dangerous';
+/** Classify a tool call as safe or dangerous */
+export declare function classifyTool(toolName: string, input: Record<string, unknown>): ToolRisk;

package/dist/session/tool-classifier.js

@@ -0,0 +1,56 @@
+const SAFE_TOOLS = new Set([
+    'Read', 'Glob', 'Grep', 'LSP', 'WebFetch', 'WebSearch',
+    'ToolSearch', 'TaskGet', 'TaskList',
+]);
+const DANGEROUS_TOOLS = new Set([
+    'Write', 'Edit', 'NotebookEdit',
+    'TaskCreate', 'TaskUpdate', 'TaskStop',
+]);
+const SAFE_BASH_PATTERNS = [
+    /^(ls|cat|head|tail|wc|file|stat|which|type|echo|printf)\b/,
+    /^git\s+(status|log|diff|show|branch|tag|remote)\b/,
+    /^(pwd|whoami|hostname|date|uname|env|printenv)\b/,
+    /^(find|grep|rg|fd|ag)\b/,
+    /^(node|python|ruby|go)\s+--?(version|help)/,
+    /^npm\s+(list|ls|view|info|outdated|audit)\b/,
+    /^curl\s.*-X\s*GET\b/,
+    /^curl\s+(?!.*-X\s*(POST|PUT|DELETE|PATCH))(?!.*--data)(?!.*-d\s)/,
+];
+const DANGEROUS_BASH_PATTERNS = [
+    /^rm\b/,
+    /^(mv|cp)\b.*--?(force|f)\b/,
+    /^chmod\b/,
+    /^chown\b/,
+    /^git\s+(push|reset|rebase|merge|checkout\s+--)\b/,
+    /^(docker|kubectl|terraform|ansible)\b/,
+    /^(sudo|su)\b/,
+    /^npm\s+(publish|install|uninstall|link)\b/,
+    /^(kill|killall|pkill)\b/,
+    /^curl\s.*-X\s*(POST|PUT|DELETE|PATCH)\b/,
+];
+/** Classify a tool call as safe or dangerous */
+export function classifyTool(toolName, input) {
+    if (SAFE_TOOLS.has(toolName))
+        return 'safe';
+    if (DANGEROUS_TOOLS.has(toolName))
+        return 'dangerous';
+    // Bash tool: inspect the command
+    if (toolName === 'Bash') {
+        const command = String(input.command || '').trim();
+        for (const pattern of SAFE_BASH_PATTERNS) {
+            if (pattern.test(command))
+                return 'safe';
+        }
+        for (const pattern of DANGEROUS_BASH_PATTERNS) {
+            if (pattern.test(command))
+                return 'dangerous';
+        }
+        // Default: unknown bash commands are dangerous
+        return 'dangerous';
+    }
+    // MCP tools from external servers: default to dangerous
+    if (toolName.startsWith('mcp__'))
+        return 'dangerous';
+    // Unknown tools: default to dangerous
+    return 'dangerous';
+}

package/dist/types.d.ts

@@ -10,6 +10,15 @@ export interface ClaudeCodeConfig {
     computerUse?: boolean;
     /** Hard timeout per subprocess turn. Default 30 min. Set to 0 to disable. */
     maxRuntimeMs?: number;
+    /**
+     * Startup watchdog: kill (and retry once) a subprocess that produces ZERO
+     * events this long after spawn. A healthy claude emits its init event within
+     * seconds; prolonged total silence means it wedged on a stalled network
+     * socket (DNS/connection blip with no client-side timeout). Default 2 min.
+     * Set to 0 to disable. Disarms on the first event, so it never fires
+     * mid-task — long-running tools are unaffected.
+     */
+    silentTimeoutMs?: number;
 }
 export interface MemoryConfig {
     dbPath: string;

package/dist/users/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';
+export type { User } from './service.js';

package/dist/users/index.js

@@ -0,0 +1 @@
+export { resolveUser, registerUser, linkIdentity, listUsers, hasAdmin } from './service.js';

package/dist/users/service.d.ts

@@ -0,0 +1,17 @@
+export interface User {
+    id: string;
+    name: string;
+    role: 'admin' | 'user';
+    budgetUsd: number | null;
+    createdAt: string;
+}
+/** Get or create a user from a channel identity */
+export declare function resolveUser(channelId: string, peerId: string): User | null;
+/** Register a new user */
+export declare function registerUser(name: string, channelId: string, peerId: string, role?: 'admin' | 'user'): User;
+/** Link an additional channel identity to an existing user */
+export declare function linkIdentity(userId: string, channelId: string, peerId: string): boolean;
+/** Get all users */
+export declare function listUsers(): User[];
+/** Check if any admin exists */
+export declare function hasAdmin(): boolean;

package/dist/users/service.js

@@ -0,0 +1,46 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.js';
+import { logger } from '../util/logger.js';
+function rowToUser(row) {
+    return { id: row.id, name: row.name, role: row.role, budgetUsd: row.budget_usd, createdAt: row.created_at };
+}
+/** Get or create a user from a channel identity */
+export function resolveUser(channelId, peerId) {
+    const db = getDb();
+    const identity = db.prepare('SELECT user_id FROM identities WHERE channel_id = ? AND peer_id = ?').get(channelId, peerId);
+    if (!identity)
+        return null;
+    const row = db.prepare('SELECT * FROM users WHERE id = ?').get(identity.user_id);
+    return row ? rowToUser(row) : null;
+}
+/** Register a new user */
+export function registerUser(name, channelId, peerId, role = 'user') {
+    const db = getDb();
+    const id = uuidv4();
+    db.prepare('INSERT INTO users (id, name, role) VALUES (?, ?, ?)').run(id, name, role);
+    db.prepare('INSERT INTO identities (user_id, channel_id, peer_id) VALUES (?, ?, ?)').run(id, channelId, peerId);
+    logger.info(`User registered: ${name} (${role}) via ${channelId}:${peerId}`);
+    return { id, name, role, budgetUsd: null, createdAt: new Date().toISOString() };
+}
+/** Link an additional channel identity to an existing user */
+export function linkIdentity(userId, channelId, peerId) {
+    const db = getDb();
+    try {
+        db.prepare('INSERT INTO identities (user_id, channel_id, peer_id) VALUES (?, ?, ?)').run(userId, channelId, peerId);
+        return true;
+    }
+    catch {
+        return false; // Already linked or conflict
+    }
+}
+/** Get all users */
+export function listUsers() {
+    const db = getDb();
+    return db.prepare('SELECT * FROM users ORDER BY created_at').all().map(rowToUser);
+}
+/** Check if any admin exists */
+export function hasAdmin() {
+    const db = getDb();
+    const row = db.prepare("SELECT COUNT(*) as c FROM users WHERE role = 'admin'").get();
+    return row.c > 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {