@jigyasudham/veto 0.8.3 → 1.1.0

package/dist/cli.js

@@ -2,10 +2,10 @@
 // Veto CLI — entry point for `npx veto init`
 // Suppress Node experimental warnings (node:sqlite) for clean UX
 process.removeAllListeners('warning');
-import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { mkdirSync, existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, extname, resolve } from 'node:path';
 import { homedir } from 'node:os';
-const VERSION = '0.8.2';
+const VERSION = '1.0.0';
 const VETO_DIR = join(homedir(), '.veto');
 const HOME = homedir();
 const c = {
@@ -25,7 +25,7 @@ function printBanner() {
     console.log(c.bold(c.cyan('   ╚████╔╝ ███████╗   ██║   ╚██████╔╝')));
     console.log(c.bold(c.cyan('    ╚═══╝  ╚══════╝   ╚═╝    ╚═════╝')));
     console.log('');
-    console.log(c.dim(`  50 agents. 28 skills. 3 AIs. Self-learning. Zero extra cost.`));
+    console.log(c.dim(`  50 agents. 33 tools. 3 AIs. Self-learning. Zero extra cost.`));
     console.log(c.dim(`  v${VERSION}`));
     console.log('');
 }
@@ -127,7 +127,20 @@ async function initCommand() {
         console.error(c.red(`  Error initializing database: ${msg}`));
         process.exit(1);
     }
-    // 3. Auto-configure every AI CLI / IDE found on this machine
+    // 3. Auto-scan current project and store project map
+    const cwd = resolve(process.cwd());
+    const { getDb: _getDb, updateProjectMap } = await import('./memory/local.js');
+    try {
+        process.stdout.write('  · Scanning project directory...');
+        const { structure, key_modules, tech_stack } = scanProjectDir(cwd);
+        updateProjectMap({ project_dir: cwd, structure: JSON.stringify(structure), key_modules, tech_stack });
+        const stackStr = tech_stack.length ? ` (${tech_stack.slice(0, 4).join(', ')})` : '';
+        console.log(c.green(' ✓') + ` Project map saved${stackStr}`);
+    }
+    catch {
+        console.log(c.dim(' skipped'));
+    }
+    // 4. Auto-configure every AI CLI / IDE found on this machine
     console.log('');
     console.log('  Configuring all AI tools found on this machine...');
     console.log('');
@@ -168,6 +181,203 @@ async function initCommand() {
         console.log('');
     }
 }
+// ─── Project Map Scanner ────────────────────────────────────────────────────────
+function scanProjectDir(dir) {
+    const structure = {};
+    const key_modules = [];
+    const tech_stack = [];
+    // Read package.json for stack detection
+    const pkgPath = join(dir, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+            structure['name'] = pkg.name;
+            structure['version'] = pkg.version;
+            const allDeps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+            structure['dep_count'] = allDeps.length;
+            const stackMap = [
+                [['next'], 'Next.js'], [['react'], 'React'], [['vue'], 'Vue'],
+                [['express'], 'Express'], [['fastify'], 'Fastify'], [['hono'], 'Hono'],
+                [['prisma'], 'Prisma'], [['drizzle-orm'], 'Drizzle'], [['typeorm'], 'TypeORM'],
+                [['@modelcontextprotocol/sdk'], 'MCP'], [['typescript'], 'TypeScript'],
+                [['jest'], 'Jest'], [['vitest'], 'Vitest'], [['tailwindcss'], 'Tailwind'],
+                [['zod'], 'Zod'], [['graphql'], 'GraphQL'],
+            ];
+            for (const [keywords, label] of stackMap) {
+                if (keywords.some(k => allDeps.some(d => d.toLowerCase().includes(k)))) {
+                    tech_stack.push(label);
+                }
+            }
+        }
+        catch { /* malformed */ }
+    }
+    // Detect key config files
+    const CONFIG_FILES = ['tsconfig.json', 'vite.config.ts', 'vite.config.js', 'next.config.ts',
+        'next.config.js', 'tailwind.config.ts', 'drizzle.config.ts', 'prisma/schema.prisma',
+        'docker-compose.yml', '.env.example'];
+    const foundConfigs = CONFIG_FILES.filter(f => existsSync(join(dir, f)));
+    if (foundConfigs.length)
+        structure['config_files'] = foundConfigs;
+    // Scan src/ directory
+    const srcDir = join(dir, 'src');
+    if (existsSync(srcDir)) {
+        let tsCount = 0;
+        let testCount = 0;
+        const topDirs = [];
+        for (const entry of readdirSync(srcDir)) {
+            const full = join(srcDir, entry);
+            try {
+                if (statSync(full).isDirectory()) {
+                    topDirs.push(entry);
+                    key_modules.push(`src/${entry}`);
+                }
+                else {
+                    const ext = extname(entry);
+                    if (['.ts', '.tsx', '.js', '.jsx'].includes(ext))
+                        tsCount++;
+                    if (entry.includes('.test.') || entry.includes('.spec.'))
+                        testCount++;
+                }
+            }
+            catch { /* skip */ }
+        }
+        structure['src_dirs'] = topDirs;
+        structure['ts_files_in_src'] = tsCount;
+        if (testCount > 0)
+            structure['test_files'] = testCount;
+    }
+    // Entry points
+    const entryPoints = ['src/index.ts', 'src/main.ts', 'src/app.ts', 'src/server.ts', 'src/cli.ts', 'index.ts'];
+    const found = entryPoints.filter(f => existsSync(join(dir, f)));
+    if (found.length)
+        structure['entry_points'] = found;
+    return { structure, key_modules, tech_stack };
+}
+// ─── CLI Subcommands ────────────────────────────────────────────────────────────
+async function statusCommand() {
+    const { getDbPath } = await import('./memory/local.js');
+    const { getDb } = await import('./memory/local.js');
+    const db = getDb();
+    const sessionCount = db.prepare('SELECT COUNT(*) as c FROM sessions').get().c;
+    const memoryCount = db.prepare('SELECT COUNT(*) as c FROM knowledge_base').get().c;
+    const patternCount = db.prepare('SELECT COUNT(*) as c FROM patterns').get().c;
+    const outcomeCount = db.prepare('SELECT COUNT(*) as c FROM learning_data').get().c;
+    console.log('');
+    console.log(c.bold('  Veto Status'));
+    console.log(c.dim('  ─────────────────────────────'));
+    console.log(`  Version     ${c.cyan(VERSION)}`);
+    console.log(`  DB          ${c.dim(getDbPath())}`);
+    console.log(`  Sessions    ${c.cyan(String(sessionCount))}`);
+    console.log(`  Memory      ${c.cyan(String(memoryCount))} knowledge entries`);
+    console.log(`  Patterns    ${c.cyan(String(patternCount))}`);
+    console.log(`  Outcomes    ${c.cyan(String(outcomeCount))} recorded`);
+    console.log('');
+}
+async function sessionsCommand() {
+    const { listSessions } = await import('./memory/local.js');
+    const sessions = listSessions(20);
+    console.log('');
+    console.log(c.bold('  Saved Sessions') + c.dim(` (${sessions.length})`));
+    console.log(c.dim('  ─────────────────────────────────────────────────────────────'));
+    if (sessions.length === 0) {
+        console.log(c.dim('  No sessions saved yet. Use veto_session_save inside an AI session.'));
+    }
+    else {
+        for (const s of sessions) {
+            const date = new Date(s.started_at).toLocaleString();
+            console.log(`  ${c.cyan(s.id.slice(0, 8))}  ${c.dim(date)}  ${c.bold(s.platform ?? 'claude')}  ${s.summary?.slice(0, 60) ?? ''}`);
+        }
+    }
+    console.log('');
+}
+async function memoryCommand() {
+    const args = process.argv.slice(3);
+    const query = args.join(' ') || undefined;
+    const { searchKnowledge } = await import('./memory/local.js');
+    const results = searchKnowledge({ query, limit: 20 });
+    console.log('');
+    console.log(c.bold('  Knowledge Base') + (query ? c.dim(` — "${query}"`) : '') + c.dim(` (${results.length} results)`));
+    console.log(c.dim('  ─────────────────────────────────────────────────────────────'));
+    if (results.length === 0) {
+        console.log(c.dim('  No entries found.'));
+    }
+    else {
+        for (const r of results) {
+            const tags = r.tags ? JSON.parse(r.tags).join(', ') : '';
+            console.log(`  ${c.cyan(`[${r.type}]`)} ${c.bold(r.title)}`);
+            if (tags)
+                console.log(`  ${c.dim('tags: ' + tags)}`);
+            console.log(`  ${c.dim(r.content.slice(0, 100).replace(/\n/g, ' ') + (r.content.length > 100 ? '...' : ''))}`);
+            console.log('');
+        }
+    }
+}
+async function patternsCommand() {
+    const { getPatterns } = await import('./memory/local.js');
+    const prefix = process.argv[3];
+    const patterns = getPatterns(prefix, 30);
+    console.log('');
+    console.log(c.bold('  Learned Patterns') + c.dim(` (${patterns.length})`));
+    console.log(c.dim('  ─────────────────────────────────────────────────────────────'));
+    if (patterns.length === 0) {
+        console.log(c.dim('  No patterns yet. Record outcomes with veto_record_outcome to build up patterns.'));
+    }
+    else {
+        for (const p of patterns) {
+            const conf = Math.round(p.confidence * 100);
+            const confColor = conf >= 80 ? c.green : conf >= 60 ? c.yellow : c.dim;
+            console.log(`  ${confColor(`${conf}%`)}  ${c.cyan(p.pattern_key)}  ${c.dim('→')}  ${p.pattern_val}  ${c.dim(`(seen ${p.seen_count}x)`)}`);
+        }
+    }
+    console.log('');
+}
+function helpCommand() {
+    console.log('');
+    console.log(c.bold(c.cyan('  veto')) + c.dim(` v${VERSION}`) + c.dim(' — 50 agents. 34 tools. 3 AIs. Self-learning. Zero extra cost.'));
+    console.log('');
+    console.log(c.bold('  CLI Commands'));
+    console.log(c.dim('  ─────────────────────────────────────────────────────'));
+    console.log(`  ${c.cyan('veto init')}                    Configure all AI tools + scan project`);
+    console.log(`  ${c.cyan('veto status')}                  Version, DB path, memory/session counts`);
+    console.log(`  ${c.cyan('veto sessions')}                List last 20 saved sessions`);
+    console.log(`  ${c.cyan('veto memory')} ${c.dim('[query]')}         Search knowledge base`);
+    console.log(`  ${c.cyan('veto patterns')} ${c.dim('[prefix]')}      List learned agent/routing patterns`);
+    console.log(`  ${c.cyan('veto help')}                    Show this help`);
+    console.log('');
+    console.log(c.bold('  MCP Tools (34)'));
+    console.log(c.dim('  ─────────────────────────────────────────────────────'));
+    console.log(`  ${c.dim('Session')}    veto_status · veto_session_save · veto_session_restore · veto_sessions_list`);
+    console.log(`  ${c.dim('Router')}     veto_route_task · veto_rate_status`);
+    console.log(`  ${c.dim('Council')}    veto_council_debate`);
+    console.log(`  ${c.dim('Agents')}     veto_agent_plan · veto_execute_parallel · veto_explain`);
+    console.log(`  ${c.dim('Review')}     veto_code_review · veto_security_scan · veto_secrets_scan · veto_diff_review`);
+    console.log(`  ${c.dim('Pipeline')}   veto_workflow`);
+    console.log(`  ${c.dim('Watch')}      veto_watch · veto_watch_poll · veto_watch_stop`);
+    console.log(`  ${c.dim('Memory')}     veto_memory_store · veto_memory_search · veto_memory_delete`);
+    console.log(`             veto_project_map_update · veto_project_map_get`);
+    console.log(`             veto_pattern_store · veto_patterns_list`);
+    console.log(`             veto_memory_export · veto_memory_import`);
+    console.log(`  ${c.dim('Learning')}   veto_record_outcome · veto_learning_stats · veto_learning_apply`);
+    console.log(`  ${c.dim('Handoff')}    veto_handoff · veto_continue · veto_platform_setup`);
+    console.log(`  ${c.dim('Plugins')}    veto_plugins`);
+    console.log('');
+    console.log(c.bold('  MCP Resources'));
+    console.log(c.dim('  ─────────────────────────────────────────────────────'));
+    console.log(`  ${c.cyan('veto://sessions')}              All saved sessions`);
+    console.log(`  ${c.cyan('veto://project-map?dir=<path>')} Project structure map`);
+    console.log(`  ${c.cyan('veto://memory?q=<query>')}      Knowledge base search`);
+    console.log(`  ${c.cyan('veto://patterns')}              Learned patterns`);
+    console.log('');
+    console.log(c.bold('  MCP Prompts'));
+    console.log(c.dim('  ─────────────────────────────────────────────────────'));
+    console.log(`  ${c.cyan('code-review')} · ${c.cyan('security-audit')} · ${c.cyan('deploy-checklist')} · ${c.cyan('explain-file')}`);
+    console.log('');
+    console.log(c.bold('  Docs'));
+    console.log(c.dim('  ─────────────────────────────────────────────────────'));
+    console.log(`  ${c.dim('GitHub:')}  https://github.com/jigyasudham/veto`);
+    console.log(`  ${c.dim('npm:')}     https://www.npmjs.com/package/@jigyasudham/veto`);
+    console.log('');
+}
 // ─── Router ────────────────────────────────────────────────────────────────────
 const command = process.argv[2] ?? 'init';
 switch (command) {
@@ -177,9 +387,38 @@ switch (command) {
             process.exit(1);
         });
         break;
+    case 'status':
+        statusCommand().catch((err) => {
+            console.error(c.red(`Error: ${err.message}`));
+            process.exit(1);
+        });
+        break;
+    case 'sessions':
+        sessionsCommand().catch((err) => {
+            console.error(c.red(`Error: ${err.message}`));
+            process.exit(1);
+        });
+        break;
+    case 'memory':
+        memoryCommand().catch((err) => {
+            console.error(c.red(`Error: ${err.message}`));
+            process.exit(1);
+        });
+        break;
+    case 'patterns':
+        patternsCommand().catch((err) => {
+            console.error(c.red(`Error: ${err.message}`));
+            process.exit(1);
+        });
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+        helpCommand();
+        break;
     default:
-        console.error(`Unknown command: ${command}`);
-        console.log('Usage: veto init');
+        console.error(c.red(`  Unknown command: ${command}`));
+        helpCommand();
         process.exit(1);
 }
 //# sourceMappingURL=cli.js.map

package/dist/context/reader.js

@@ -0,0 +1,113 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execSync } from 'node:child_process';
+const STACK_INDICATORS = [
+    [['next', 'next.js'], 'Next.js'],
+    [['react', 'react-dom'], 'React'],
+    [['vue'], 'Vue'],
+    [['svelte'], 'Svelte'],
+    [['express'], 'Express'],
+    [['fastify'], 'Fastify'],
+    [['hono'], 'Hono'],
+    [['prisma'], 'Prisma'],
+    [['drizzle-orm'], 'Drizzle'],
+    [['typeorm'], 'TypeORM'],
+    [['mongoose'], 'Mongoose'],
+    [['@modelcontextprotocol/sdk'], 'MCP'],
+    [['typescript', 'ts-node', 'tsx'], 'TypeScript'],
+    [['jest', 'vitest'], 'Testing'],
+    [['tailwindcss'], 'Tailwind'],
+    [['zod'], 'Zod'],
+    [['trpc', '@trpc/server'], 'tRPC'],
+    [['graphql'], 'GraphQL'],
+];
+function detectStack(deps) {
+    const names = Object.keys(deps).map(k => k.toLowerCase());
+    const stack = [];
+    for (const [keywords, label] of STACK_INDICATORS) {
+        if (keywords.some(k => names.some(n => n.includes(k)))) {
+            stack.push(label);
+        }
+    }
+    return stack;
+}
+function safeRead(filePath) {
+    try {
+        return readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function safeExec(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function readProjectContext(projectDir) {
+    const dir = resolve(projectDir);
+    if (!existsSync(dir)) {
+        return { summary: '', tech_stack: [], git_diff: '', key_files: [], error: `Directory not found: ${dir}` };
+    }
+    // package.json
+    let packageName;
+    let packageVersion;
+    let techStack = [];
+    const pkgRaw = safeRead(join(dir, 'package.json'));
+    if (pkgRaw) {
+        try {
+            const pkg = JSON.parse(pkgRaw);
+            packageName = pkg.name;
+            packageVersion = pkg.version;
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            techStack = detectStack(allDeps);
+        }
+        catch { /* malformed package.json */ }
+    }
+    // git diff — last 60 lines of unstaged + staged changes
+    const gitDiff = safeExec('git diff HEAD --stat --no-color', dir);
+    // git recent commits (last 5 one-liners for context)
+    const gitLog = safeExec('git log --oneline -5 --no-color', dir);
+    // key config files present
+    const CONFIG_FILES = [
+        'tsconfig.json', 'vite.config.ts', 'vite.config.js',
+        'next.config.ts', 'next.config.js', 'tailwind.config.ts',
+        'drizzle.config.ts', 'prisma/schema.prisma', '.env.example',
+    ];
+    const keyFiles = CONFIG_FILES.filter(f => existsSync(join(dir, f)));
+    // build compact summary string
+    const lines = ['[CODEBASE CONTEXT]'];
+    if (packageName)
+        lines.push(`Project: ${packageName}${packageVersion ? ` v${packageVersion}` : ''}`);
+    if (techStack.length)
+        lines.push(`Stack: ${techStack.join(', ')}`);
+    if (keyFiles.length)
+        lines.push(`Config files: ${keyFiles.join(', ')}`);
+    if (gitDiff)
+        lines.push(`Recent changes:\n${gitDiff}`);
+    if (gitLog)
+        lines.push(`Recent commits:\n${gitLog}`);
+    return {
+        summary: lines.join('\n'),
+        package_name: packageName,
+        package_version: packageVersion,
+        tech_stack: techStack,
+        git_diff: gitDiff,
+        key_files: keyFiles,
+    };
+}
+export function buildContextString(projectDir, existingContext) {
+    if (!projectDir)
+        return existingContext ?? '';
+    const ctx = readProjectContext(projectDir);
+    if (ctx.error)
+        return existingContext ?? '';
+    const parts = [ctx.summary];
+    if (existingContext)
+        parts.push(existingContext);
+    return parts.join('\n\n');
+}
+//# sourceMappingURL=reader.js.map

package/dist/council/index.js

@@ -7,8 +7,10 @@ import { analyze as devilAnalyze } from './devil-advocate.js';
 import { analyze as legalAnalyze } from './legal-compliance.js';
 import { analyze as securityAnalyze } from './security.js';
 import { decide, formatDebate } from './decision-engine.js';
+import { buildContextString } from '../context/reader.js';
 export async function runDebate(input) {
-    const fullText = input.context ? `${input.task}\n${input.context}` : input.task;
+    const enrichedContext = buildContextString(input.project_dir, input.context);
+    const fullText = enrichedContext ? `${input.task}\n\n${enrichedContext}` : input.task;
     // All 7 agents run in parallel — none depend on each other
     const [lead_dev, pm, architect, ux, devil, legal, security] = await Promise.all([
         Promise.resolve(leadDevAnalyze(fullText)),

package/dist/memory/local.js

@@ -19,8 +19,18 @@ export function getDb() {
     _db.exec(CREATE_TABLES);
     migrateCouncilOutcomes(_db);
     migrateCouncilColumns(_db);
+    migrateSessionColumns(_db);
     return _db;
 }
+// Adds active_client and last_resumed_at columns if they don't exist
+function migrateSessionColumns(db) {
+    const cols = db.prepare('PRAGMA table_info(sessions)').all();
+    const names = new Set(cols.map(c => c.name));
+    if (!names.has('active_client'))
+        db.exec('ALTER TABLE sessions ADD COLUMN active_client TEXT');
+    if (!names.has('last_resumed_at'))
+        db.exec('ALTER TABLE sessions ADD COLUMN last_resumed_at TEXT');
+}
 // Adds legal and security columns if they don't exist (Phase 3 → Phase 3.1 migration)
 function migrateCouncilColumns(db) {
     const cols = db.prepare('PRAGMA table_info(council_outcomes)').all();
@@ -58,11 +68,18 @@ export function saveSession(input) {
     stmt.run(id, now, input.platform ?? 'claude', input.project_dir ?? null, input.summary ?? null, input.context ? JSON.stringify(input.context) : null, input.task_state ? JSON.stringify(input.task_state) : null, input.token_count ?? 0);
     return { session_id: id, saved_at: now };
 }
-export function restoreSession(session_id) {
+export function restoreSession(session_id, active_client) {
     const db = getDb();
     const row = db.prepare('SELECT * FROM sessions WHERE id = ?').get(session_id);
     if (!row)
         return { found: false };
+    if (active_client) {
+        const now = new Date().toISOString();
+        db.prepare('UPDATE sessions SET active_client = ?, last_resumed_at = ? WHERE id = ?')
+            .run(active_client, now, session_id);
+        row.active_client = active_client;
+        row.last_resumed_at = now;
+    }
     return { found: true, session: row };
 }
 export function listSessions(limit = 10) {

package/dist/memory/schema.js

@@ -2,16 +2,18 @@
 // All tables created on first run — zero setup required
 export const CREATE_TABLES = `
   CREATE TABLE IF NOT EXISTS sessions (
-    id          TEXT PRIMARY KEY,
-    started_at  TEXT NOT NULL,
-    ended_at    TEXT,
-    platform    TEXT NOT NULL DEFAULT 'claude',
-    project_dir TEXT,
-    summary     TEXT,
-    context     TEXT,
-    task_state  TEXT,
-    token_count INTEGER DEFAULT 0,
-    created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    id               TEXT PRIMARY KEY,
+    started_at       TEXT NOT NULL,
+    ended_at         TEXT,
+    platform         TEXT NOT NULL DEFAULT 'claude',
+    active_client    TEXT,
+    last_resumed_at  TEXT,
+    project_dir      TEXT,
+    summary          TEXT,
+    context          TEXT,
+    task_state       TEXT,
+    token_count      INTEGER DEFAULT 0,
+    created_at       TEXT NOT NULL DEFAULT (datetime('now'))
   );
 
   CREATE TABLE IF NOT EXISTS decisions (

package/dist/plugins/loader.js

@@ -0,0 +1,49 @@
+import { readdirSync, existsSync } from 'node:fs';
+import { join, basename, extname } from 'node:path';
+import { homedir } from 'node:os';
+const PLUGIN_DIR = join(homedir(), '.veto', 'agents');
+const registry = new Map();
+let loaded = false;
+function pluginName(file) {
+    return basename(file, extname(file));
+}
+export async function loadPlugins() {
+    if (loaded)
+        return Array.from(registry.keys());
+    loaded = true;
+    if (!existsSync(PLUGIN_DIR))
+        return [];
+    const files = readdirSync(PLUGIN_DIR).filter(f => /\.(js|mjs)$/.test(f));
+    const names = [];
+    for (const file of files) {
+        const name = pluginName(file);
+        try {
+            const mod = await import(join(PLUGIN_DIR, file));
+            if (mod && typeof mod === 'object' &&
+                'plan' in mod && typeof mod.plan === 'function') {
+                registry.set(name, mod);
+                names.push(name);
+            }
+            else {
+                process.stderr.write(`[veto] Plugin "${file}" skipped — must export plan(task, context?)\n`);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[veto] Plugin "${file}" failed to load: ${err}\n`);
+        }
+    }
+    return names;
+}
+export function getPlugin(name) {
+    return registry.get(name);
+}
+export function isPlugin(name) {
+    return registry.has(name);
+}
+export function listPlugins() {
+    return Array.from(registry.entries()).map(([name, mod]) => ({
+        name,
+        has_analyze: typeof mod.analyze === 'function',
+    }));
+}
+//# sourceMappingURL=loader.js.map

package/dist/router/index.js

@@ -3,8 +3,8 @@ import { scoreComplexity } from './complexity-scorer.js';
 import { selectModel } from './model-selector.js';
 import { getRateStatus, trackRequest, getRoutingAdvice } from './rate-monitor.js';
 import { compressContext, estimateTokens } from './context-compressor.js';
-import { recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights } from './learning-updater.js';
-export { estimateTokens, getRateStatus, trackRequest, recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights };
+import { recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights, getRecommendedAgent } from './learning-updater.js';
+export { estimateTokens, getRateStatus, trackRequest, recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights, getRecommendedAgent };
 export function routeTask(task, options = {}) {
     const learned = getLearnedThresholds();
     const complexity = scoreComplexity(task, options.filesAffected, options.forceCouncil, learned.source === 'learned' ? learned : undefined);

package/dist/router/learning-updater.js

@@ -2,10 +2,54 @@
 import { randomUUID } from 'node:crypto';
 import { getDb } from '../memory/local.js';
 // ─── Record ───────────────────────────────────────────────────────────────────
-export function recordOutcome(taskType, complexity, modelTier, agent, outputQuality, tokensUsed = 0) {
+export function recordOutcome(taskType, complexity, modelTier, agent, outputQuality, tokensUsed = 0, fileExt) {
     const db = getDb();
     db.prepare(`INSERT INTO learning_data (id, task_type, complexity, model_tier, output_quality, tokens_used, agent)
      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), taskType, complexity, modelTier, outputQuality, tokensUsed, agent);
+    // Predictive routing: track agent quality per file extension and task type keyword
+    if (agent && agent !== 'dynamic' && outputQuality > 0) {
+        const now = new Date().toISOString();
+        const upsert = (key) => {
+            const existing = db.prepare('SELECT id, pattern_val, confidence, seen_count FROM patterns WHERE pattern_key = ?').get(key);
+            if (existing) {
+                // running average quality as confidence (0–1)
+                const newConf = ((existing.confidence * existing.seen_count) + (outputQuality / 100)) / (existing.seen_count + 1);
+                db.prepare('UPDATE patterns SET confidence = ?, seen_count = ?, updated_at = ? WHERE pattern_key = ?')
+                    .run(Math.min(1, newConf), existing.seen_count + 1, now, key);
+            }
+            else {
+                db.prepare('INSERT INTO patterns (id, pattern_key, pattern_val, confidence, seen_count, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
+                    .run(randomUUID(), key, agent, outputQuality / 100, 1, now);
+            }
+        };
+        if (fileExt)
+            upsert(`file_agent:${fileExt.toLowerCase()}:${agent}`);
+        const keyword = taskType.toLowerCase().split(/[\s_-]/)[0];
+        if (keyword)
+            upsert(`task_agent:${keyword}:${agent}`);
+    }
+}
+// ─── Predictive Agent Recommendation ─────────────────────────────────────────
+export function getRecommendedAgent(taskType, fileExt) {
+    const db = getDb();
+    // Try file extension match first (more specific)
+    if (fileExt) {
+        const rows = db.prepare(`SELECT pattern_key, pattern_val, confidence, seen_count FROM patterns
+       WHERE pattern_key LIKE ? AND seen_count >= 3
+       ORDER BY confidence DESC LIMIT 1`).all(`file_agent:${fileExt.toLowerCase()}:%`);
+        if (rows.length > 0 && rows[0].confidence >= 0.7)
+            return rows[0].pattern_val;
+    }
+    // Fall back to task keyword match
+    const keyword = taskType.toLowerCase().split(/[\s_-]/)[0];
+    if (keyword) {
+        const rows = db.prepare(`SELECT pattern_key, pattern_val, confidence, seen_count FROM patterns
+       WHERE pattern_key LIKE ? AND seen_count >= 3
+       ORDER BY confidence DESC LIMIT 1`).all(`task_agent:${keyword}:%`);
+        if (rows.length > 0 && rows[0].confidence >= 0.7)
+            return rows[0].pattern_val;
+    }
+    return null;
 }
 // ─── Stats ────────────────────────────────────────────────────────────────────
 export function getLearningStats() {