beecork 1.4.11 → 1.5.0

package/dist/mcp/tool-definitions.js

@@ -0,0 +1,364 @@
+// MCP tool definitions for the Beecork MCP server.
+// One array, one place to maintain the public tool surface. Handler logic
+// lives in `./handlers.ts`; the server file (`./server.ts`) glues them.
+export const TOOL_DEFINITIONS = [
+    {
+        name: 'beecork_remember',
+        description: 'Store a fact in Beecork\'s long-term memory. Use this for preferences, decisions, server addresses, outcomes, or anything the user might want recalled in future sessions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The fact or information to remember' },
+                scope: { type: 'string', enum: ['global', 'project', 'tab', 'auto'], description: 'Where to store: global (about the user), project (about this folder), tab (about this conversation), or auto (Claude decides)' },
+                category: { type: 'string', description: 'For global scope: people, preferences, routines, or general' },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'beecork_task_create',
+        description: 'Schedule a task that will run automatically. The task sends a message to a Beecork tab at the scheduled time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable name for the task' },
+                scheduleType: {
+                    type: 'string',
+                    enum: ['at', 'every', 'cron'],
+                    description: '"at" = one-time ISO datetime, "every" = interval like "30m"/"2h"/"1d", "cron" = cron expression like "0 9 * * 1"',
+                },
+                schedule: { type: 'string', description: 'The schedule value (ISO datetime, interval, or cron expression)' },
+                message: { type: 'string', description: 'The prompt/message to send when the task fires' },
+                tabName: { type: 'string', description: 'Which tab to send the message to (default: "default")' },
+            },
+            required: ['name', 'scheduleType', 'schedule', 'message'],
+        },
+    },
+    {
+        name: 'beecork_task_list',
+        description: 'List all scheduled tasks.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_task_delete',
+        description: 'Delete a scheduled task by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'The ID of the task to delete' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'beecork_cron_create',
+        description: '[DEPRECATED — use beecork_task_create] Schedule a task that will run automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable name for the job' },
+                scheduleType: { type: 'string', enum: ['at', 'every', 'cron'] },
+                schedule: { type: 'string' },
+                message: { type: 'string' },
+                tabName: { type: 'string' },
+            },
+            required: ['name', 'scheduleType', 'schedule', 'message'],
+        },
+    },
+    {
+        name: 'beecork_cron_list',
+        description: '[DEPRECATED — use beecork_task_list] List all scheduled tasks.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_cron_delete',
+        description: '[DEPRECATED — use beecork_task_delete] Delete a scheduled task by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'beecork_watch_create',
+        description: 'Create a watcher that periodically runs a check command and triggers an action when a condition is met.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable name for the watcher' },
+                description: { type: 'string', description: 'What to watch (natural language)' },
+                checkCommand: { type: 'string', description: 'Shell command to run for checking' },
+                condition: { type: 'string', description: 'When to trigger: "contains X", "not contains X", "> N", "< N", "any", "error"' },
+                action: { type: 'string', enum: ['notify', 'fix', 'delegate'], description: 'What to do when triggered (default: notify)' },
+                actionDetails: { type: 'string', description: 'For fix: command to run. For delegate: tab name + message.' },
+                schedule: { type: 'string', description: 'How often to check: cron expression or interval like "5m", "1h"' },
+            },
+            required: ['name', 'checkCommand', 'condition', 'schedule'],
+        },
+    },
+    {
+        name: 'beecork_watch_list',
+        description: 'List all watchers.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_watch_delete',
+        description: 'Delete a watcher by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'beecork_tab_create',
+        description: 'Create a new Beecork tab (an isolated Claude session with its own working directory and history).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Tab name (alphanumeric + hyphens, max 32 chars). Cannot be "default".' },
+                workingDir: { type: 'string', description: 'Absolute path or ~/path for the tab\'s working directory' },
+                template: { type: 'string', description: 'Name of a tab template from config (sets workingDir + systemPrompt)' },
+                systemPrompt: { type: 'string', description: 'Tab-specific system prompt for Claude' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'beecork_tab_list',
+        description: 'List all Beecork tabs and their status.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_send_message',
+        description: 'Send a message to another Beecork tab. The message will be processed asynchronously by that tab\'s Claude subprocess.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tabName: { type: 'string', description: 'Which tab to send to' },
+                message: { type: 'string', description: 'The message text' },
+            },
+            required: ['tabName', 'message'],
+        },
+    },
+    {
+        name: 'beecork_recall',
+        description: 'Search Beecork\'s memory and knowledge files for facts matching a query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query (matches content substrings)' },
+                limit: { type: 'number', description: 'Max results (default 10, max 50)' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'beecork_notify',
+        description: 'Send a notification to the user via their configured channels (Telegram, Discord, etc.).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                message: { type: 'string', description: 'The notification text' },
+                urgent: { type: 'boolean', description: 'Prepend a 🚨 prefix' },
+            },
+            required: ['message'],
+        },
+    },
+    {
+        name: 'beecork_status',
+        description: 'Get a summary of Beecork state: tab/task/watcher/memory counts.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_send_media',
+        description: 'Send a generated or local media file (image/video/audio) through the user\'s channels.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the media file' },
+                caption: { type: 'string', description: 'Optional caption' },
+                tabName: { type: 'string', description: 'Tab to attribute the send to (default: "default")' },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'beecork_channels',
+        description: 'List configured channels and their capabilities.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_cost',
+        description: 'Get cost summary (today, 7-day, 30-day, per-tab).',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string', description: 'Filter to a single tab' } },
+        },
+    },
+    {
+        name: 'beecork_failed_deliveries',
+        description: 'List recent messages that failed to deliver via channels.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_activity',
+        description: 'Get activity summary for the last N hours.',
+        inputSchema: {
+            type: 'object',
+            properties: { hours: { type: 'number', description: 'Lookback window (default 24)' } },
+        },
+    },
+    {
+        name: 'beecork_export_data',
+        description: 'Export historical data as JSON for analysis.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['costs', 'messages', 'crons'], description: 'What to export' },
+                days: { type: 'number', description: 'Lookback window in days (default 30)' },
+            },
+            required: ['type'],
+        },
+    },
+    {
+        name: 'beecork_handoff',
+        description: 'Get info to resume a tab\'s session in your terminal.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string' } },
+            required: ['tabName'],
+        },
+    },
+    {
+        name: 'beecork_delegate',
+        description: 'Delegate a sub-task to another tab. The result will be sent back when complete.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tabName: { type: 'string', description: 'Tab to delegate to' },
+                message: { type: 'string', description: 'The task description' },
+                returnToTab: { type: 'string', description: 'Tab to notify when complete (default: "default")' },
+            },
+            required: ['tabName', 'message'],
+        },
+    },
+    {
+        name: 'beecork_delegation_status',
+        description: 'List pending delegations.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string', description: 'Filter by source or target tab' } },
+        },
+    },
+    {
+        name: 'beecork_project_create',
+        description: 'Register a project folder so the router can detect it from natural language.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Project name (also the folder name)' },
+                path: { type: 'string', description: 'Optional parent directory (must be under a scan path)' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'beecork_project_list',
+        description: 'List registered projects/folders.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_close_tab',
+        description: 'Permanently close a tab — stops its subprocess and deletes its message history.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabName: { type: 'string' } },
+            required: ['tabName'],
+        },
+    },
+    {
+        name: 'beecork_generate_image',
+        description: 'Generate an image via a configured media provider (DALL-E, Recraft, etc.).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                style: { type: 'string' },
+                provider: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'beecork_generate_video',
+        description: 'Generate a video via a configured media provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                duration: { type: 'number' },
+                provider: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'beecork_generate_audio',
+        description: 'Generate audio via a configured media provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                provider: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'beecork_media_providers',
+        description: 'List configured media generators and what they support.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_knowledge',
+        description: 'List all stored knowledge (memories + knowledge files), optionally filtered by scope.',
+        inputSchema: {
+            type: 'object',
+            properties: { scope: { type: 'string', enum: ['global', 'project', 'tab', 'all'] } },
+        },
+    },
+    {
+        name: 'beecork_capabilities',
+        description: 'List available capability packs and their status.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'beecork_history',
+        description: 'Get the activity timeline for a given day/tab.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'ISO date YYYY-MM-DD (default: today)' },
+                tabName: { type: 'string' },
+                limit: { type: 'number' },
+            },
+        },
+    },
+    {
+        name: 'beecork_replay',
+        description: 'Re-run a past activity event by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { eventId: { type: 'string' } },
+            required: ['eventId'],
+        },
+    },
+    {
+        name: 'beecork_store_search',
+        description: 'Search the Beecork community extension registry (npm packages starting with "beecork-").',
+        inputSchema: {
+            type: 'object',
+            properties: { query: { type: 'string' } },
+            required: ['query'],
+        },
+    },
+];

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,5 +1,5 @@
 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)

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

@@ -4,9 +4,12 @@ export function getCostSummary() {
     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();
     return { today, last7Days: last7, last30Days: last30, perTab };
@@ -16,7 +19,7 @@ export function getActivitySummary(hours = 24) {
     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 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;
@@ -24,7 +27,7 @@ export function getActivitySummary(hours = 24) {
         period: `Last ${hours} hours`,
         messagesReceived,
         messagesFromAssistant,
-        cronJobsFired,
+        tasksFired,
         memoriesCreated,
         totalCost,
         activeTabsCount,
@@ -85,7 +88,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

@@ -5,7 +5,7 @@ export declare function getWorkspaceRoot(): string;
 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 +15,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

@@ -4,6 +4,9 @@ import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.js';
 import { getConfig } from '../config.js';
 import { logger } from '../util/logger.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 */
 export function getWorkspaceRoot() {
     const config = getConfig();
@@ -67,16 +70,29 @@ export function discoverProjects(scanPaths) {
     }
     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(requestedParent.startsWith('~')
+        ? requestedParent.replace('~', process.env.HOME || '')
+        : 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(r.startsWith('~') ? r.replace('~', process.env.HOME || '') : 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)) {
@@ -101,9 +117,8 @@ export function ensureCategory(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 };
-    }
+    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() };
@@ -112,31 +127,17 @@ export function ensureCategory(name) {
 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,
-    }));
+    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;
-}
+// closeTab moved to TabManager.closeTab — see src/session/manager.ts. It now kills
+// the subprocess and deletes the rows in one place rather than the caller doing both.

package/dist/projects/router.d.ts

@@ -3,3 +3,13 @@ import type { RouteDecision, RoutingContext } from './types.js';
 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>;

package/dist/projects/router.js

@@ -191,3 +191,31 @@ function checkLearnedRouting(message) {
     }
     return null;
 }
+/**
+ * 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 async function resolveProjectRoute(rawPrompt, tabName, text, userId) {
+    if (tabName !== 'default' || text.startsWith('/tab ')) {
+        return { effectiveTabName: tabName };
+    }
+    try {
+        const decision = routeMessage(rawPrompt, { userId });
+        if (decision.needsConfirmation) {
+            const projects = listProjects().filter((p) => p.type === 'user-project');
+            const options = projects.map((p, i) => `${i + 1}) ${p.name}`).join('\n');
+            return {
+                effectiveTabName: tabName,
+                confirmationMessage: `Which project?\n${options}\n\nReply with the number, or just send your message with /project <name> first.`,
+            };
+        }
+        setUserContext(userId, decision.project.name, decision.tabName);
+        return {
+            effectiveTabName: decision.tabName,
+            projectPath: decision.project.path,
+        };
+    }
+    catch {
+        return { effectiveTabName: tabName };
+    }
+}

package/dist/session/manager.d.ts

@@ -33,6 +33,10 @@ export declare class TabManager {
     private queryTab;
     /** Stop a tab's running subprocess */
     stopTab(tabName: string): void;
+    /** Update a tab's system_prompt. Returns true if the tab existed. */
+    setSystemPrompt(tabName: string, systemPrompt: string): boolean;
+    /** Close a tab — stop subprocess and delete its rows. Returns true if the tab existed. */
+    closeTab(tabName: string): boolean;
     /** Stop all running subprocesses (clean shutdown) */
     stopAll(): void;
     /** Process pending messages from MCP server IPC */