beecork 1.7.1 → 2.0.0

package/dist/pipe/brain.js

@@ -1,89 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

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

package/dist/projects/index.d.ts

@@ -1,4 +0,0 @@
-export type { Project, RouteDecision, RoutingContext } from './types.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 +0,0 @@
-export { discoverProjects, createProject, listProjects, getProject, ensureCategory, touchProject, } from './manager.js';
-export { routeMessage, setUserContext, resolveProjectRoute } from './router.js';

package/dist/projects/manager.d.ts

@@ -1,13 +0,0 @@
-import type { Project } from './types.js';
-/** 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. */
-export declare function createProject(name: string, parentDir?: string): Project;
-/** Ensure a managed category exists (lazy creation) */
-export declare function ensureCategory(name: string): Project;
-/** List all projects */
-export declare function listProjects(): Project[];
-/** Get a project by name */
-export declare function getProject(name: string): Project | null;
-/** Update last used timestamp */
-export declare function touchProject(name: string): void;

package/dist/projects/manager.js

@@ -1,166 +0,0 @@
-import fs from 'node:fs';
-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';
-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 expandHome(root);
-}
-/** 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.) */
-export function discoverProjects(scanPaths) {
-    const paths = scanPaths || [getWorkspaceRoot()];
-    const projects = [];
-    const db = getDb();
-    for (let scanPath of paths) {
-        scanPath = expandHome(scanPath);
-        if (!fs.existsSync(scanPath))
-            continue;
-        try {
-            const entries = fs.readdirSync(scanPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                if (entry.name.startsWith('.'))
-                    continue; // Skip hidden dirs
-                if (entry.name === 'node_modules')
-                    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'));
-                if (isProject) {
-                    projects.push({
-                        id: uuidv4(),
-                        name: entry.name,
-                        path: dirPath,
-                        type: 'user-project',
-                        lastUsedAt: new Date().toISOString(),
-                        createdAt: new Date().toISOString(),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            logger.warn(`Failed to scan ${scanPath}:`, err);
-        }
-    }
-    // Upsert into database
-    for (const project of projects) {
-        db.prepare(`
-      INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)
-      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. parentDir must resolve under an allowed root. */
-export function createProject(name, parentDir) {
-    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(resolvedParent, safeName);
-    // Ensure resolved path is within the parent directory
-    if (!projectPath.startsWith(resolvedParent)) {
-        throw new Error('Project path must be within the parent directory');
-    }
-    if (fs.existsSync(projectPath)) {
-        // Folder already exists — just register it
-        logger.info(`Project folder already exists: ${projectPath}`);
-    }
-    else {
-        fs.mkdirSync(projectPath, { recursive: true });
-        logger.info(`Created project folder: ${projectPath}`);
-    }
-    const db = getDb();
-    const id = uuidv4();
-    db.prepare(`
-    INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)
-    ON CONFLICT(name) DO UPDATE SET path = excluded.path
-  `).run(id, name, projectPath, 'user-project');
-    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 rowToProject(existing);
-    const id = uuidv4();
-    db.prepare('INSERT INTO projects (id, name, path, type) VALUES (?, ?, ?, ?)').run(id, name, categoryPath, 'category');
-    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(rowToProject);
-}
-/** Get a project by name */
-export function getProject(name) {
-    const db = getDb();
-    const row = db.prepare('SELECT * FROM projects WHERE name = ?').get(name);
-    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);
-}

package/dist/projects/router.d.ts

@@ -1,17 +0,0 @@
-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>;

package/dist/projects/router.js

@@ -1,246 +0,0 @@
-import { getDb } from '../db/index.js';
-import { listProjects, getProject, ensureCategory, touchProject } from './manager.js';
-// Category keywords for non-project routing
-const CATEGORY_KEYWORDS = {
-    research: ['research', 'find out', 'look into', 'compare', 'investigate', 'analyze', 'study'],
-    planning: ['plan', 'schedule', 'organize', 'roadmap', 'strategy', 'outline', 'agenda'],
-};
-// Per-user current context tracking (in-memory, resets on daemon restart)
-const userContext = new Map();
-// Project list cache. listProjects() ran on every inbound message and re-did a
-// full SELECT + ORDER BY across the projects table; with N projects each call
-// then re-lowercased every name. The cache is invalidated explicitly via
-// invalidateProjectCache() at the few sites that mutate the table.
-let projectsCache = null;
-const PROJECTS_CACHE_TTL_MS = 30_000;
-function getUserProjectsCached() {
-    const now = Date.now();
-    if (projectsCache && projectsCache.expiresAt > now)
-        return projectsCache.user;
-    const user = listProjects()
-        .filter((p) => p.type === 'user-project')
-        .map((p) => ({ ...p, nameLower: p.name.toLowerCase() }));
-    projectsCache = { user, expiresAt: now + PROJECTS_CACHE_TTL_MS };
-    return user;
-}
-/** Invalidate the project cache. Call after createProject/discoverProjects/etc. */
-export function invalidateProjectCache() {
-    projectsCache = null;
-}
-/** Route a message to the right project and tab */
-export function routeMessage(message, context) {
-    const projects = getUserProjectsCached();
-    const userId = context?.userId || 'default';
-    const messageLower = message.toLowerCase();
-    // 1. Check for explicit project mention by name
-    const mentionedProject = findMentionedProject(messageLower, projects);
-    if (mentionedProject) {
-        const { tabName, exists } = resolveTabInProject(mentionedProject);
-        touchProject(mentionedProject.name);
-        recordRouting(message, mentionedProject.name);
-        return {
-            project: mentionedProject,
-            tabName,
-            isNewTab: !exists,
-            confidence: 0.95,
-            needsConfirmation: false,
-            reason: `Message mentions project "${mentionedProject.name}"`,
-        };
-    }
-    // 2. Check if continuing current context
-    const currentCtx = userContext.get(userId);
-    if (currentCtx && Date.now() - currentCtx.updatedAt < 10 * 60 * 1000) {
-        // 10 min window
-        const project = getProject(currentCtx.projectName);
-        if (project) {
-            touchProject(project.name);
-            return {
-                project,
-                tabName: currentCtx.tabName,
-                isNewTab: false,
-                confidence: 0.7,
-                needsConfirmation: false,
-                reason: `Continuing in "${project.name}" (recent context)`,
-            };
-        }
-    }
-    // 3. Check routing preferences (learned patterns)
-    const learned = checkLearnedRouting(messageLower);
-    if (learned) {
-        const project = getProject(learned.projectName);
-        if (project && learned.confidence >= 0.9) {
-            const { tabName, exists } = resolveTabInProject(project);
-            touchProject(project.name);
-            return {
-                project,
-                tabName,
-                isNewTab: !exists,
-                confidence: learned.confidence,
-                needsConfirmation: false,
-                reason: `Learned pattern → "${project.name}"`,
-            };
-        }
-    }
-    // 4. Multiple projects could match — ask user
-    const possibleMatches = findPossibleMatches(messageLower, projects);
-    if (possibleMatches.length > 1) {
-        return {
-            project: possibleMatches[0],
-            tabName: possibleMatches[0].name,
-            isNewTab: false,
-            confidence: 0.5,
-            needsConfirmation: true,
-            reason: `Multiple projects could match: ${possibleMatches.map((p) => p.name).join(', ')}`,
-        };
-    }
-    // 5. Check for category keywords (non-project)
-    const category = detectCategory(messageLower);
-    if (category) {
-        const project = ensureCategory(category);
-        const tabName = category;
-        return {
-            project,
-            tabName,
-            isNewTab: !tabExists(tabName),
-            confidence: 0.8,
-            needsConfirmation: false,
-            reason: `Detected category: ${category}`,
-        };
-    }
-    // 6. Default to general
-    const general = ensureCategory('general');
-    return {
-        project: general,
-        tabName: 'general',
-        isNewTab: !tabExists('general'),
-        confidence: 0.6,
-        needsConfirmation: false,
-        reason: 'Default routing to general',
-    };
-}
-/** Update current context for a user */
-export function setUserContext(userId, projectName, tabName) {
-    userContext.set(userId, { projectName, tabName, updatedAt: Date.now() });
-    // Evict oldest entry when map grows too large
-    if (userContext.size > 1000) {
-        let oldestKey = '';
-        let oldestTime = Infinity;
-        for (const [key, val] of userContext) {
-            if (val.updatedAt < oldestTime) {
-                oldestTime = val.updatedAt;
-                oldestKey = key;
-            }
-        }
-        if (oldestKey)
-            userContext.delete(oldestKey);
-    }
-}
-/** Find a project explicitly mentioned by name in the message (messageLower already lower-cased) */
-function findMentionedProject(messageLower, projects) {
-    for (const project of projects) {
-        if (messageLower.includes(project.nameLower))
-            return project;
-    }
-    return null;
-}
-/** Find possible project matches (for ambiguity) */
-function findPossibleMatches(messageLower, projects) {
-    const words = messageLower.split(/\s+/);
-    return projects.filter((p) => {
-        const nameParts = p.nameLower.split(/[-_]/);
-        return nameParts.some((part) => words.includes(part));
-    });
-}
-/**
- * Resolve which tab to use within a project. Coalesces the previous
- * "find tabs + tabExists" into one query — the caller used to fire both
- * back-to-back, and the working_dir scan had no covering index.
- * (Index added by migration v28; see src/db/migrations.ts.)
- */
-function resolveTabInProject(project) {
-    const db = getDb();
-    const row = db
-        .prepare('SELECT name FROM tabs WHERE working_dir = ? ORDER BY last_activity_at DESC LIMIT 1')
-        .get(project.path);
-    return row ? { tabName: row.name, exists: true } : { tabName: project.name, exists: false };
-}
-/** Check if a tab exists in the database */
-function tabExists(tabName) {
-    const db = getDb();
-    const row = db.prepare('SELECT 1 FROM tabs WHERE name = ?').get(tabName);
-    return !!row;
-}
-/** Detect a category from keywords (messageLower already lower-cased) */
-function detectCategory(messageLower) {
-    for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
-        if (keywords.some((kw) => messageLower.includes(kw)))
-            return category;
-    }
-    return null;
-}
-/** Record a successful routing for learning */
-function recordRouting(message, projectName) {
-    const db = getDb();
-    // Extract key words from message for pattern matching
-    const words = message
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((w) => w.length > 3)
-        .slice(0, 5);
-    const pattern = words.join(' ');
-    if (!pattern)
-        return;
-    db.prepare(`
-    INSERT INTO routing_preferences (pattern, project_name)
-    VALUES (?, ?)
-    ON CONFLICT(pattern, project_name) DO UPDATE SET hit_count = hit_count + 1
-  `).run(pattern, projectName);
-}
-/** Check learned routing preferences (messageLower already lower-cased) */
-function checkLearnedRouting(messageLower) {
-    const db = getDb();
-    const words = messageLower.split(/\s+/).filter((w) => w.length > 3);
-    if (words.length === 0)
-        return null;
-    // Fetch all preferences in a single query and match in JS
-    const allPrefs = db
-        .prepare('SELECT pattern, project_name, confidence, hit_count FROM routing_preferences WHERE hit_count >= 3 ORDER BY hit_count DESC LIMIT 200')
-        .all();
-    for (const pref of allPrefs) {
-        // pref.pattern was written via .toLowerCase() in recordRouting(), so no
-        // re-lowercase here (saves N allocations per inbound message).
-        const patternLower = pref.pattern;
-        if (words.some((word) => patternLower.includes(word) || word.includes(patternLower))) {
-            return { projectName: pref.project_name, confidence: Math.min(pref.confidence, 0.9) };
-        }
-    }
-    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 };
-    }
-}