beecork 1.5.0 → 1.7.0

package/dist/mcp/validate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal MCP tool-input validator. Walks the declared `inputSchema` from
+ * `tool-definitions.ts` and rejects calls that violate `required`, `type`, or
+ * `enum`. Handlers previously had ad-hoc checks for some fields and silently
+ * accepted invalid inputs for others — this single validator converts the
+ * inconsistency into a uniform "Invalid input: ..." failure.
+ *
+ * Deliberately handwritten (no Ajv/zod dep) to avoid pulling a runtime dep
+ * for one validation pass.
+ */
+interface PropertySchema {
+    type?: string | string[];
+    enum?: readonly unknown[];
+    items?: PropertySchema;
+    description?: string;
+}
+export interface InputSchema {
+    type?: string;
+    properties?: Record<string, PropertySchema>;
+    required?: readonly string[];
+}
+export declare function validateToolArgs(schema: unknown, args: Record<string, unknown> | undefined): string | null;
+export {};

package/dist/mcp/validate.js

@@ -0,0 +1,65 @@
+/**
+ * Minimal MCP tool-input validator. Walks the declared `inputSchema` from
+ * `tool-definitions.ts` and rejects calls that violate `required`, `type`, or
+ * `enum`. Handlers previously had ad-hoc checks for some fields and silently
+ * accepted invalid inputs for others — this single validator converts the
+ * inconsistency into a uniform "Invalid input: ..." failure.
+ *
+ * Deliberately handwritten (no Ajv/zod dep) to avoid pulling a runtime dep
+ * for one validation pass.
+ */
+export function validateToolArgs(schema, args) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const s = schema;
+    const a = args || {};
+    // Required fields
+    for (const field of s.required ?? []) {
+        const value = a[field];
+        if (value === undefined || value === null || value === '') {
+            return `Invalid input: "${field}" is required`;
+        }
+    }
+    // Per-property type/enum checks
+    for (const [field, propSchema] of Object.entries(s.properties ?? {})) {
+        const value = a[field];
+        if (value === undefined || value === null)
+            continue;
+        const typeError = checkType(value, propSchema, field);
+        if (typeError)
+            return typeError;
+        if (propSchema.enum && !propSchema.enum.includes(value)) {
+            return `Invalid input: "${field}" must be one of ${JSON.stringify(propSchema.enum)} (got ${JSON.stringify(value)})`;
+        }
+    }
+    return null;
+}
+function checkType(value, schema, field) {
+    if (!schema.type)
+        return null;
+    const types = (Array.isArray(schema.type) ? schema.type : [schema.type]);
+    for (const t of types) {
+        if (matchesType(value, t))
+            return null;
+    }
+    return `Invalid input: "${field}" must be ${types.join(' | ')} (got ${typeof value})`;
+}
+function matchesType(value, t) {
+    switch (t) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        default:
+            // Unknown types fall through to accept (lenient).
+            return true;
+    }
+}

package/dist/media/factory.js

@@ -9,24 +9,28 @@ import { NanoBananaGenerator } from './generators/nano-banana.js';
 import { ElevenLabsMusicGenerator } from './generators/elevenlabs-music.js';
 import { LyriaGenerator } from './generators/lyria.js';
 import { RecraftGenerator } from './generators/recraft.js';
+// Lookup table — adding a new generator becomes one entry instead of one switch case.
+const GENERATOR_BUILDERS = {
+    'dall-e': (k, m) => new DalleGenerator(k, m),
+    'stable-diffusion': (k) => new StableDiffusionGenerator(k),
+    runway: (k) => new RunwayGenerator(k),
+    veo: (k) => new VeoGenerator(k),
+    kling: (k) => new KlingGenerator(k),
+    'elevenlabs-sfx': (k) => new ElevenLabsSfxGenerator(k),
+    'nano-banana': (k, m) => new NanoBananaGenerator(k, m),
+    'elevenlabs-music': (k) => new ElevenLabsMusicGenerator(k),
+    lyria: (k, m) => new LyriaGenerator(k, m),
+    recraft: (k) => new RecraftGenerator(k),
+};
 export function createMediaGenerator(config) {
     if (!config.apiKey) {
         logger.warn(`Media generator ${config.provider}: missing API key`);
         return null;
     }
-    switch (config.provider) {
-        case 'dall-e': return new DalleGenerator(config.apiKey, config.model);
-        case 'stable-diffusion': return new StableDiffusionGenerator(config.apiKey);
-        case 'runway': return new RunwayGenerator(config.apiKey);
-        case 'veo': return new VeoGenerator(config.apiKey);
-        case 'kling': return new KlingGenerator(config.apiKey);
-        case 'elevenlabs-sfx': return new ElevenLabsSfxGenerator(config.apiKey);
-        case 'nano-banana': return new NanoBananaGenerator(config.apiKey, config.model);
-        case 'elevenlabs-music': return new ElevenLabsMusicGenerator(config.apiKey);
-        case 'lyria': return new LyriaGenerator(config.apiKey, config.model);
-        case 'recraft': return new RecraftGenerator(config.apiKey);
-        default:
-            logger.warn(`Unknown media generator: ${config.provider}`);
-            return null;
+    const build = GENERATOR_BUILDERS[config.provider];
+    if (!build) {
+        logger.warn(`Unknown media generator: ${config.provider}`);
+        return null;
     }
+    return build(config.apiKey, config.model);
 }

package/dist/media/generators/dall-e.js

@@ -16,7 +16,7 @@ export class DalleGenerator {
         const response = await fetch('https://api.openai.com/v1/images/generations', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
@@ -33,7 +33,7 @@ export class DalleGenerator {
             const err = await response.text();
             throw new Error(`DALL-E error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         const buffer = Buffer.from(data.data[0].b64_json, 'base64');
         const filePath = saveMedia(buffer, 'png', 'generated-image.png');
         return { filePath, mimeType: 'image/png' };

package/dist/media/generators/kling.js

@@ -14,7 +14,7 @@ export class KlingGenerator {
         const response = await fetch('https://api.klingai.com/v1/videos/text2video', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
@@ -28,14 +28,14 @@ export class KlingGenerator {
             const err = await response.text();
             throw new Error(`Kling error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const { data } = await response.json();
+        const { data } = (await response.json());
         // Poll for completion
-        const headers = { 'Authorization': `Bearer ${this.apiKey}` };
+        const headers = { Authorization: `Bearer ${this.apiKey}` };
         const videoUrl = await pollForCompletion({
             statusUrl: `https://api.klingai.com/v1/videos/text2video/${data.task_id}`,
             headers,
             isComplete: (d) => d.data.task_status === 'succeed' && !!d.data.task_result?.videos[0],
-            isFailed: (d) => d.data.task_status === 'failed' ? 'generation failed' : null,
+            isFailed: (d) => (d.data.task_status === 'failed' ? 'generation failed' : null),
             getResultUrl: (d) => d.data.task_result.videos[0].url,
             label: 'Kling',
         });

package/dist/media/generators/lyria.js

@@ -29,7 +29,7 @@ export class LyriaGenerator {
             const err = await response.text();
             throw new Error(`Lyria error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         const audioPart = data.candidates?.[0]?.content?.parts?.find((p) => p.inlineData);
         if (!audioPart?.inlineData?.data) {
             throw new Error('Lyria returned no audio data');

package/dist/media/generators/nano-banana.d.ts

@@ -6,5 +6,5 @@ export declare class NanoBananaGenerator implements MediaGenerator {
     readonly name = "Google Nano Banana";
     readonly supportedTypes: MediaType[];
     constructor(apiKey: string, model?: string);
-    generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
+    generate(type: MediaType, prompt: string, _options?: GenerateOptions): Promise<GenerateResult>;
 }

package/dist/media/generators/nano-banana.js

@@ -9,7 +9,7 @@ export class NanoBananaGenerator {
         this.apiKey = apiKey;
         this.model = model;
     }
-    async generate(type, prompt, options) {
+    async generate(type, prompt, _options) {
         if (type !== 'image')
             throw new Error('Nano Banana only supports image generation');
         // Gemini image generation API
@@ -31,7 +31,7 @@ export class NanoBananaGenerator {
             const err = await response.text();
             throw new Error(`Nano Banana error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         const imagePart = data.candidates?.[0]?.content?.parts?.find((p) => p.inlineData);
         if (!imagePart?.inlineData?.data) {
             throw new Error('Nano Banana returned no image data');

package/dist/media/generators/poll-util.js

@@ -1,8 +1,8 @@
 import { logger } from '../../util/logger.js';
 export async function pollForCompletion(opts) {
-    const { statusUrl, headers, isComplete, isFailed, getResultUrl, interval = 5000, maxAttempts = 60, label = 'API' } = opts;
+    const { statusUrl, headers, isComplete, isFailed, getResultUrl, interval = 5000, maxAttempts = 60, label = 'API', } = opts;
     for (let i = 0; i < maxAttempts; i++) {
-        await new Promise(r => setTimeout(r, interval));
+        await new Promise((r) => setTimeout(r, interval));
         const resp = await fetch(statusUrl, { headers, signal: AbortSignal.timeout(10000) });
         if (!resp.ok) {
             logger.warn(`[${label}] Poll failed: ${resp.status}`);
@@ -11,12 +11,12 @@ export async function pollForCompletion(opts) {
             }
             continue;
         }
-        const data = await resp.json();
+        const data = (await resp.json());
         const failMsg = isFailed(data);
         if (failMsg)
             throw new Error(`${label} generation failed: ${failMsg}`);
         if (isComplete(data))
             return getResultUrl(data);
     }
-    throw new Error(`${label} generation timed out after ${maxAttempts * interval / 1000}s`);
+    throw new Error(`${label} generation timed out after ${(maxAttempts * interval) / 1000}s`);
 }

package/dist/media/generators/recraft.js

@@ -17,14 +17,14 @@ export class RecraftGenerator {
         const response = await fetch(endpoint, {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
                 prompt: prompt.slice(0, 2000),
                 model: isVector ? 'recraftv4' : 'recraftv4',
                 response_format: isVector ? 'url' : 'b64_json',
-                style: isVector ? 'vector_illustration' : (options?.style || 'realistic_image'),
+                style: isVector ? 'vector_illustration' : options?.style || 'realistic_image',
                 size: options?.width && options?.height ? `${options.width}x${options.height}` : '1024x1024',
             }),
             signal: AbortSignal.timeout(120000),
@@ -33,7 +33,7 @@ export class RecraftGenerator {
             const err = await response.text();
             throw new Error(`Recraft error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         const image = data.data?.[0];
         if (isVector && image?.url) {
             // Download SVG from URL

package/dist/media/generators/runway.js

@@ -15,7 +15,7 @@ export class RunwayGenerator {
         const startResponse = await fetch('https://api.runwayml.com/v1/image_to_video', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
                 'Content-Type': 'application/json',
                 'X-Runway-Version': '2024-11-06',
             },
@@ -30,14 +30,14 @@ export class RunwayGenerator {
             const err = await startResponse.text();
             throw new Error(`Runway error ${startResponse.status}: ${err.slice(0, 200)}`);
         }
-        const { id: taskId } = await startResponse.json();
+        const { id: taskId } = (await startResponse.json());
         // Poll for completion (max 5 minutes)
-        const headers = { 'Authorization': `Bearer ${this.apiKey}`, 'X-Runway-Version': '2024-11-06' };
+        const headers = { Authorization: `Bearer ${this.apiKey}`, 'X-Runway-Version': '2024-11-06' };
         const videoUrl = await pollForCompletion({
             statusUrl: `https://api.runwayml.com/v1/tasks/${taskId}`,
             headers,
             isComplete: (data) => data.status === 'SUCCEEDED' && !!data.output?.[0],
-            isFailed: (data) => data.status === 'FAILED' ? 'generation failed' : null,
+            isFailed: (data) => (data.status === 'FAILED' ? 'generation failed' : null),
             getResultUrl: (data) => data.output[0],
             label: 'Runway',
         });

package/dist/media/generators/stable-diffusion.js

@@ -18,8 +18,8 @@ export class StableDiffusionGenerator {
         const response = await fetch('https://api.stability.ai/v2beta/stable-image/generate/core', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Accept': 'image/*',
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: 'image/*',
             },
             body: formData,
             signal: AbortSignal.timeout(120000),

package/dist/media/generators/veo.js

@@ -24,7 +24,7 @@ export class VeoGenerator {
             const err = await response.text();
             throw new Error(`Veo error ${response.status}: ${err.slice(0, 200)}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         const buffer = Buffer.from(data.predictions[0].bytesBase64Encoded, 'base64');
         const filePath = saveMedia(buffer, 'mp4', 'generated-video.mp4');
         return { filePath, mimeType: 'video/mp4', durationMs: (options?.duration || 5) * 1000 };

package/dist/media/index.js

@@ -4,5 +4,5 @@ import { createMediaGenerator } from './factory.js';
 export function initMediaGenerators(configs) {
     if (!configs || configs.length === 0)
         return [];
-    return configs.map(c => createMediaGenerator(c)).filter((g) => g !== null);
+    return configs.map((c) => createMediaGenerator(c)).filter((g) => g !== null);
 }

package/dist/media/store.d.ts

@@ -8,3 +8,10 @@ export declare function isOversized(sizeBytes: number, maxSizeMb?: number): bool
 export declare function cleanupMedia(ttlMs?: number): number;
 /** Get the media directory path */
 export declare function getMediaDir(): string;
+/**
+ * Resolve a file path and confirm it lives inside the beecork media directory.
+ * Throws otherwise. Used at trust boundaries (MCP tools, voice transcription)
+ * where a caller could otherwise hand us an arbitrary path to read or upload.
+ * Returns the resolved (absolute) path on success.
+ */
+export declare function assertInsideMediaDir(filePath: string): string;

package/dist/media/store.js

@@ -17,9 +17,7 @@ export function saveMedia(buffer, extension, originalName) {
     const safeName = originalName
         ? originalName.replace(/[\/\\]/g, '_').replace(/\.\./g, '_')
         : undefined;
-    const name = safeName
-        ? `${timestamp}-${safeName}`
-        : `${timestamp}.${extension}`;
+    const name = safeName ? `${timestamp}-${safeName}` : `${timestamp}.${extension}`;
     const filePath = path.join(MEDIA_DIR, name);
     fs.writeFileSync(filePath, buffer);
     return filePath;
@@ -43,7 +41,9 @@ export function cleanupMedia(ttlMs = DEFAULT_TTL_MS) {
                 cleaned++;
             }
         }
-        catch { /* file may have been deleted by another process */ }
+        catch {
+            /* file may have been deleted by another process */
+        }
     }
     if (cleaned > 0)
         logger.info(`Media cleanup: removed ${cleaned} expired files`);
@@ -53,3 +53,17 @@ export function cleanupMedia(ttlMs = DEFAULT_TTL_MS) {
 export function getMediaDir() {
     return MEDIA_DIR;
 }
+/**
+ * Resolve a file path and confirm it lives inside the beecork media directory.
+ * Throws otherwise. Used at trust boundaries (MCP tools, voice transcription)
+ * where a caller could otherwise hand us an arbitrary path to read or upload.
+ * Returns the resolved (absolute) path on success.
+ */
+export function assertInsideMediaDir(filePath) {
+    const resolved = path.resolve(filePath);
+    const root = path.resolve(MEDIA_DIR) + path.sep;
+    if (!resolved.startsWith(root)) {
+        throw new Error(`filePath must be inside the beecork media directory (${MEDIA_DIR})`);
+    }
+    return resolved;
+}

package/dist/media/types.d.ts

@@ -19,3 +19,25 @@ export interface MediaGenerator {
     readonly supportedTypes: MediaType[];
     generate(type: MediaType, prompt: string, options?: GenerateOptions): Promise<GenerateResult>;
 }
+/** Gemini `:generateContent` response shape (used by lyria + nano-banana). */
+export interface GeminiInlineDataPart {
+    inlineData?: {
+        mimeType?: string;
+        data: string;
+    };
+}
+export interface GeminiCandidate {
+    content?: {
+        parts?: GeminiInlineDataPart[];
+    };
+}
+export interface GeminiGenerateContentResponse {
+    candidates?: GeminiCandidate[];
+}
+/** Recraft `/v1/images/generations` response. */
+export interface RecraftGenerateResponse {
+    data?: Array<{
+        url?: string;
+        b64_json?: string;
+    }>;
+}

package/dist/notifications/index.d.ts

@@ -1,6 +1,4 @@
 export type { NotificationProvider } from './types.js';
-export { PushoverProvider } from './pushover.js';
-export { NtfyProvider } from './ntfy.js';
-export { WebhookNotificationProvider } from './webhook-provider.js';
 import type { NotificationProvider } from './types.js';
-export declare function createNotificationProvider(config: any): NotificationProvider | null;
+import type { NotificationConfig } from '../types.js';
+export declare function createNotificationProvider(config: NotificationConfig): NotificationProvider | null;

package/dist/notifications/index.js

@@ -1,34 +1,21 @@
-export { PushoverProvider } from './pushover.js';
-export { NtfyProvider } from './ntfy.js';
-export { WebhookNotificationProvider } from './webhook-provider.js';
 import { logger } from '../util/logger.js';
 import { PushoverProvider } from './pushover.js';
 import { NtfyProvider } from './ntfy.js';
 import { WebhookNotificationProvider } from './webhook-provider.js';
 export function createNotificationProvider(config) {
-    if (!config?.type)
-        return null;
     switch (config.type) {
         case 'pushover':
-            if (!config.userKey || !config.appToken) {
-                logger.warn('Pushover: missing userKey or appToken');
-                return null;
-            }
             return new PushoverProvider(config.userKey, config.appToken);
         case 'ntfy':
-            if (!config.topic) {
-                logger.warn('ntfy: missing topic');
-                return null;
-            }
             return new NtfyProvider(config.topic, config.server);
         case 'webhook':
-            if (!config.url) {
-                logger.warn('Webhook notification: missing url');
-                return null;
-            }
             return new WebhookNotificationProvider(config.url, config.headers);
-        default:
-            logger.warn(`Unknown notification provider: ${config.type}`);
+        default: {
+            // Exhaustiveness check — TS will error here if NotificationConfig gains
+            // a new variant without a matching case above.
+            const _exhaustive = config;
+            logger.warn(`Unknown notification provider: ${JSON.stringify(_exhaustive)}`);
             return null;
+        }
     }
 }

package/dist/notifications/ntfy.js

@@ -11,9 +11,9 @@ export class NtfyProvider {
         const response = await fetch(`${this.server}/${this.topic}`, {
             method: 'POST',
             headers: {
-                'Title': 'Beecork',
-                'Priority': urgent ? '5' : '3',
-                'Tags': urgent ? 'warning' : 'robot',
+                Title: 'Beecork',
+                Priority: urgent ? '5' : '3',
+                Tags: urgent ? 'warning' : 'robot',
             },
             body: message,
             signal: AbortSignal.timeout(10000),

package/dist/observability/analytics.js

@@ -1,28 +1,44 @@
 import { getDb } from '../db/index.js';
 export function getCostSummary() {
     const db = getDb();
-    const today = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')").get().total;
-    const last7 = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now', '-7 days')").get().total;
-    const last30 = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now', '-30 days')").get().total;
+    const today = db
+        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')")
+        .get().total;
+    const last7 = db
+        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now', '-7 days')")
+        .get().total;
+    const last30 = db
+        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now', '-30 days')")
+        .get().total;
     // Per-tab summed over the last 30 days only — the unbounded version grew
     // linearly with the messages table and made /cost noticeably slow over time.
-    const perTab = db.prepare(`
+    const perTab = db
+        .prepare(`
     SELECT t.name, COALESCE(SUM(m.cost_usd), 0) as cost, COUNT(m.id) as messages
     FROM tabs t LEFT JOIN messages m ON m.tab_id = t.id
       AND m.created_at > date('now', '-30 days')
     GROUP BY t.id ORDER BY cost DESC
-  `).all();
+  `)
+        .all();
     return { today, last7Days: last7, last30Days: last30, perTab };
 }
 export function getActivitySummary(hours = 24) {
     const db = getDb();
     const sinceDate = new Date(Date.now() - hours * 3600000).toISOString();
-    const messagesReceived = db.prepare('SELECT COUNT(*) as c FROM messages WHERE role = ? AND created_at > ?').get('user', sinceDate).c;
-    const messagesFromAssistant = db.prepare('SELECT COUNT(*) as c FROM messages WHERE role = ? AND created_at > ?').get('assistant', sinceDate).c;
+    const messagesReceived = db
+        .prepare('SELECT COUNT(*) as c FROM messages WHERE role = ? AND created_at > ?')
+        .get('user', sinceDate).c;
+    const messagesFromAssistant = db
+        .prepare('SELECT COUNT(*) as c FROM messages WHERE role = ? AND created_at > ?')
+        .get('assistant', sinceDate).c;
     const tasksFired = db.prepare('SELECT COUNT(*) as c FROM tasks WHERE last_run_at > ?').get(sinceDate).c;
     const memoriesCreated = db.prepare('SELECT COUNT(*) as c FROM memories WHERE created_at > ?').get(sinceDate).c;
-    const totalCost = db.prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > ?').get(sinceDate).total;
-    const activeTabsCount = db.prepare('SELECT COUNT(DISTINCT tab_id) as c FROM messages WHERE created_at > ?').get(sinceDate).c;
+    const totalCost = db
+        .prepare('SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > ?')
+        .get(sinceDate).total;
+    const activeTabsCount = db
+        .prepare('SELECT COUNT(DISTINCT tab_id) as c FROM messages WHERE created_at > ?')
+        .get(sinceDate).c;
     return {
         period: `Last ${hours} hours`,
         messagesReceived,
@@ -40,19 +56,25 @@ const ANOMALY_STATE_KEY = 'anomaly_spend_state';
  */
 export function checkAnomaliesWithDb(db) {
     // Today's spend
-    const todaySpend = db.prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')").get().total;
+    const todaySpend = db
+        .prepare("SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages WHERE created_at > date('now')")
+        .get().total;
     // 7-day rolling average (excluding today)
-    const avgSpend = db.prepare(`
+    const avgSpend = db
+        .prepare(`
     SELECT COALESCE(AVG(daily_total), 0) as avg FROM (
       SELECT date(created_at) as day, SUM(cost_usd) as daily_total
       FROM messages
       WHERE created_at > date('now', '-7 days') AND created_at < date('now')
       GROUP BY date(created_at)
     )
-  `).get().avg;
+  `)
+        .get().avg;
     const isBreach = avgSpend > 0 && todaySpend > avgSpend * 2;
     const newState = isBreach ? 'breach' : 'ok';
-    const prevRow = db.prepare('SELECT value FROM preferences WHERE key = ?').get(ANOMALY_STATE_KEY);
+    const prevRow = db
+        .prepare('SELECT value FROM preferences WHERE key = ?')
+        .get(ANOMALY_STATE_KEY);
     const prevState = prevRow?.value ?? 'ok';
     if (newState === prevState)
         return null;

package/dist/projects/index.d.ts

@@ -1,4 +1,4 @@
 export type { Project, RouteDecision, RoutingContext } from './types.js';
-export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject } from './manager.js';
+export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject, } from './manager.js';
 export { routeMessage, setUserContext, resolveProjectRoute } from './router.js';
 export type { RouteResult } from './router.js';

package/dist/projects/index.js

@@ -1,2 +1,2 @@
-export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject } from './manager.js';
+export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject, } from './manager.js';
 export { routeMessage, setUserContext, resolveProjectRoute } from './router.js';

package/dist/projects/manager.d.ts

@@ -1,8 +1,4 @@
 import type { Project } from './types.js';
-/** Get the workspace root from config */
-export declare function getWorkspaceRoot(): string;
-/** Get the managed workspace path (.beecork/ under workspace root) */
-export declare function getManagedWorkspace(): string;
 /** Discover projects in scan paths (look for git repos, package.json, etc.) */
 export declare function discoverProjects(scanPaths?: string[]): Project[];
 /** Create a new project. parentDir must resolve under an allowed root. */