beecork 1.4.11 → 1.6.0

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.d.ts

@@ -1,11 +1,6 @@
 export type { MediaGenerator, MediaType, GenerateOptions, GenerateResult } from './types.js';
 export { createMediaGenerator } from './factory.js';
-export { saveMedia, cleanupMedia, ensureMediaDir, getMediaDir, isOversized } from './store.js';
+export { saveMedia, cleanupMedia, ensureMediaDir, isOversized } from './store.js';
 import type { MediaGenerator } from './types.js';
-export interface MediaGeneratorConfig {
-    provider: string;
-    apiKey?: string;
-    model?: string;
-    style?: string;
-}
+import type { MediaGeneratorConfig } from '../types.js';
 export declare function initMediaGenerators(configs?: MediaGeneratorConfig[]): MediaGenerator[];

package/dist/media/index.js

@@ -1,8 +1,8 @@
 export { createMediaGenerator } from './factory.js';
-export { saveMedia, cleanupMedia, ensureMediaDir, getMediaDir, isOversized } from './store.js';
+export { saveMedia, cleanupMedia, ensureMediaDir, isOversized } from './store.js';
 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.d.ts

@@ -13,7 +13,7 @@ export interface ActivitySummary {
     period: string;
     messagesReceived: number;
     messagesFromAssistant: number;
-    cronJobsFired: number;
+    tasksFired: number;
     memoriesCreated: number;
     totalCost: number;
     activeTabsCount: number;

package/dist/observability/analytics.js

@@ -1,30 +1,49 @@
 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 perTab = db.prepare(`
+    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(`
     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 cronJobsFired = db.prepare('SELECT COUNT(*) as c FROM tasks WHERE last_run_at > ?').get(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,
         messagesFromAssistant,
-        cronJobsFired,
+        tasksFired,
         memoriesCreated,
         totalCost,
         activeTabsCount,
@@ -37,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;
@@ -85,7 +110,7 @@ export function formatActivitySummary(summary) {
         `📊 Activity (${summary.period})`,
         `  Messages in: ${summary.messagesReceived}`,
         `  Messages out: ${summary.messagesFromAssistant}`,
-        `  Cron jobs fired: ${summary.cronJobsFired}`,
+        `  Tasks fired: ${summary.tasksFired}`,
         `  Memories created: ${summary.memoriesCreated}`,
         `  Active tabs: ${summary.activeTabsCount}`,
         `  Cost: $${summary.totalCost.toFixed(4)}`,

package/dist/projects/index.d.ts

@@ -1,3 +1,4 @@
 export type { Project, RouteDecision, RoutingContext } from './types.js';
-export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject, closeTab, getWorkspaceRoot, getManagedWorkspace } from './manager.js';
-export { routeMessage, setUserContext } from './router.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, closeTab, getWorkspaceRoot, getManagedWorkspace } from './manager.js';
-export { routeMessage, setUserContext } from './router.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,11 +1,7 @@
 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 */
+/** Create a new project. parentDir must resolve under an allowed root. */
 export declare function createProject(name: string, parentDir?: string): Project;
 /** Ensure a managed category exists (lazy creation) */
 export declare function ensureCategory(name: string): Project;
@@ -15,5 +11,3 @@ export declare function listProjects(): Project[];
 export declare function getProject(name: string): Project | null;
 /** Update last used timestamp */
 export declare function touchProject(name: string): void;
-/** Close (permanently delete) a tab */
-export declare function closeTab(tabName: string): boolean;

package/dist/projects/manager.js

@@ -3,16 +3,28 @@ import path from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.js';
 import { getConfig } from '../config.js';
+import { expandHome } from '../util/paths.js';
 import { logger } from '../util/logger.js';
-/** Get the workspace root from config */
-export function getWorkspaceRoot() {
+import { invalidateProjectCache } from './router.js';
+function rowToProject(r) {
+    return {
+        id: r.id,
+        name: r.name,
+        path: r.path,
+        type: r.type,
+        lastUsedAt: r.last_used_at,
+        createdAt: r.created_at,
+    };
+}
+/** Get the workspace root from config (module-local) */
+function getWorkspaceRoot() {
     const config = getConfig();
     // Use the default tab's workingDir as workspace root
     const root = config.tabs?.default?.workingDir || process.env.HOME || '';
-    return root.startsWith('~') ? root.replace('~', process.env.HOME || '') : root;
+    return expandHome(root);
 }
-/** Get the managed workspace path (.beecork/ under workspace root) */
-export function getManagedWorkspace() {
+/** Get the managed workspace path (.beecork/ under workspace root) (module-local) */
+function getManagedWorkspace() {
     return path.join(getWorkspaceRoot(), '.beecork');
 }
 /** Discover projects in scan paths (look for git repos, package.json, etc.) */
@@ -21,7 +33,7 @@ export function discoverProjects(scanPaths) {
     const projects = [];
     const db = getDb();
     for (let scanPath of paths) {
-        scanPath = scanPath.startsWith('~') ? scanPath.replace('~', process.env.HOME || '') : scanPath;
+        scanPath = expandHome(scanPath);
         if (!fs.existsSync(scanPath))
             continue;
         try {
@@ -35,13 +47,13 @@ export function discoverProjects(scanPaths) {
                     continue;
                 const dirPath = path.join(scanPath, entry.name);
                 // Check if it looks like a project (has .git, package.json, or similar)
-                const isProject = fs.existsSync(path.join(dirPath, '.git'))
-                    || fs.existsSync(path.join(dirPath, 'package.json'))
-                    || fs.existsSync(path.join(dirPath, 'Cargo.toml'))
-                    || fs.existsSync(path.join(dirPath, 'go.mod'))
-                    || fs.existsSync(path.join(dirPath, 'requirements.txt'))
-                    || fs.existsSync(path.join(dirPath, 'pyproject.toml'))
-                    || fs.existsSync(path.join(dirPath, 'CLAUDE.md'));
+                const isProject = fs.existsSync(path.join(dirPath, '.git')) ||
+                    fs.existsSync(path.join(dirPath, 'package.json')) ||
+                    fs.existsSync(path.join(dirPath, 'Cargo.toml')) ||
+                    fs.existsSync(path.join(dirPath, 'go.mod')) ||
+                    fs.existsSync(path.join(dirPath, 'requirements.txt')) ||
+                    fs.existsSync(path.join(dirPath, 'pyproject.toml')) ||
+                    fs.existsSync(path.join(dirPath, 'CLAUDE.md'));
                 if (isProject) {
                     projects.push({
                         id: uuidv4(),
@@ -65,18 +77,27 @@ export function discoverProjects(scanPaths) {
       ON CONFLICT(name) DO UPDATE SET path = excluded.path, last_used_at = datetime('now')
     `).run(project.id, project.name, project.path, project.type);
     }
+    invalidateProjectCache();
     return projects;
 }
-/** Create a new project */
+/** Create a new project. parentDir must resolve under an allowed root. */
 export function createProject(name, parentDir) {
-    const parent = parentDir || getWorkspaceRoot();
+    const requestedParent = parentDir || getWorkspaceRoot();
+    const resolvedParent = path.resolve(expandHome(requestedParent));
+    // Allowlist: parent must resolve under workspace root or one of the configured scan paths.
+    const config = getConfig();
+    const allowedRoots = [getWorkspaceRoot(), ...(config.projectScanPaths ?? [])].map((r) => path.resolve(expandHome(r)));
+    const isAllowed = allowedRoots.some((root) => resolvedParent === root || resolvedParent.startsWith(root + path.sep));
+    if (!isAllowed) {
+        throw new Error(`Project parent directory must be under workspace root or a configured scan path. Allowed: ${allowedRoots.join(', ')}`);
+    }
     // Sanitize name to prevent path traversal
     const safeName = path.basename(name.replace(/\.\./g, ''));
     if (!safeName)
         throw new Error('Invalid project name');
-    const projectPath = path.resolve(parent, safeName);
+    const projectPath = path.resolve(resolvedParent, safeName);
     // Ensure resolved path is within the parent directory
-    if (!projectPath.startsWith(path.resolve(parent))) {
+    if (!projectPath.startsWith(resolvedParent)) {
         throw new Error('Project path must be within the parent directory');
     }
     if (fs.existsSync(projectPath)) {
@@ -93,50 +114,53 @@ export function createProject(name, parentDir) {
     INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)
     ON CONFLICT(name) DO UPDATE SET path = excluded.path
   `).run(id, name, projectPath, 'user-project');
-    return { id, name, path: projectPath, type: 'user-project', lastUsedAt: new Date().toISOString(), createdAt: new Date().toISOString() };
+    invalidateProjectCache();
+    return {
+        id,
+        name,
+        path: projectPath,
+        type: 'user-project',
+        lastUsedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+    };
 }
 /** Ensure a managed category exists (lazy creation) */
 export function ensureCategory(name) {
     const categoryPath = path.join(getManagedWorkspace(), name);
     fs.mkdirSync(categoryPath, { recursive: true });
     const db = getDb();
-    const existing = db.prepare('SELECT * FROM projects WHERE name = ? AND type = ?').get(name, 'category');
-    if (existing) {
-        return { id: existing.id, name: existing.name, path: existing.path, type: 'category', lastUsedAt: existing.last_used_at, createdAt: existing.created_at };
-    }
+    const existing = db
+        .prepare('SELECT * FROM projects WHERE name = ? AND type = ?')
+        .get(name, 'category');
+    if (existing)
+        return rowToProject(existing);
     const id = uuidv4();
     db.prepare('INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)').run(id, name, categoryPath, 'category');
-    return { id, name, path: categoryPath, type: 'category', lastUsedAt: new Date().toISOString(), createdAt: new Date().toISOString() };
+    invalidateProjectCache();
+    return {
+        id,
+        name,
+        path: categoryPath,
+        type: 'category',
+        lastUsedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+    };
 }
 /** List all projects */
 export function listProjects() {
     const db = getDb();
-    const rows = db.prepare('SELECT * FROM projects ORDER BY type, last_used_at DESC').all();
-    return rows.map(r => ({
-        id: r.id, name: r.name, path: r.path, type: r.type,
-        lastUsedAt: r.last_used_at, createdAt: r.created_at,
-    }));
+    const rows = db
+        .prepare('SELECT * FROM projects ORDER BY type, last_used_at DESC')
+        .all();
+    return rows.map(rowToProject);
 }
 /** Get a project by name */
 export function getProject(name) {
     const db = getDb();
     const row = db.prepare('SELECT * FROM projects WHERE name = ?').get(name);
-    if (!row)
-        return null;
-    return { id: row.id, name: row.name, path: row.path, type: row.type, lastUsedAt: row.last_used_at, createdAt: row.created_at };
+    return row ? rowToProject(row) : null;
 }
 /** Update last used timestamp */
 export function touchProject(name) {
     getDb().prepare("UPDATE projects SET last_used_at = datetime('now') WHERE name = ?").run(name);
 }
-/** Close (permanently delete) a tab */
-export function closeTab(tabName) {
-    const db = getDb();
-    const tab = db.prepare('SELECT id FROM tabs WHERE name = ?').get(tabName);
-    if (!tab)
-        return false;
-    db.prepare('DELETE FROM messages WHERE tab_id = ?').run(tab.id);
-    db.prepare('DELETE FROM tabs WHERE id = ?').run(tab.id);
-    logger.info(`Tab permanently closed: ${tabName}`);
-    return true;
-}

package/dist/projects/router.d.ts

@@ -1,5 +1,17 @@
 import type { RouteDecision, RoutingContext } from './types.js';
+/** Invalidate the project cache. Call after createProject/discoverProjects/etc. */
+export declare function invalidateProjectCache(): void;
 /** Route a message to the right project and tab */
 export declare function routeMessage(message: string, context?: RoutingContext): RouteDecision;
 /** Update current context for a user */
 export declare function setUserContext(userId: string, projectName: string, tabName: string): void;
+export interface RouteResult {
+    effectiveTabName: string;
+    projectPath?: string;
+    confirmationMessage?: string;
+}
+/**
+ * Shared project routing logic — resolves which tab/project to use for a message.
+ * Pulled out of channels/ so all routing decisions live in one place.
+ */
+export declare function resolveProjectRoute(rawPrompt: string, tabName: string, text: string, userId: string): Promise<RouteResult>;