verbolab 0.1.0-alpha.1

package/dist/bin/verbo.js

@@ -0,0 +1,1156 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createDatabase } from '../src/db/database.js';
+import { createTaskStore } from '../src/core/task-store.js';
+import { createAgentSessionStore } from '../src/core/agent-session-store.js';
+import { createConflictDetector } from '../src/core/conflict-detector.js';
+import { createConflictEnforcer } from '../src/core/conflict-enforcer.js';
+import { createParallelizer, hasFileOverlap } from '../src/core/parallelizer.js';
+import { createAgentLauncher } from '../src/agent/agent-launcher.js';
+import { formatFunIdentity } from '../src/agent/fun-names.js';
+import { createApprovalStore } from '../src/approval/approval-store.js';
+import { createApprovalServer } from '../src/approval/approval-server.js';
+import { createHumanActionStore } from '../src/core/human-action-store.js';
+import { createLearningStore } from '../src/core/learning-store.js';
+import { createOrchestratorStore } from '../src/core/orchestrator-store.js';
+import { createGitHubOrchestrator } from '../src/intelligence/github-orchestrator.js';
+import { readBaseBranch, readHotFiles } from '../src/core/verbo-md.js';
+import { createMergeQueue } from '../src/core/merge-queue.js';
+import { createHotFiles } from '../src/core/hot-files.js';
+import { setVerboMdField, getVerboMdFields, validateFieldValue, requiresConfirmation, FIELD_REGISTRY, } from '../src/core/verbo-config-editor.js';
+import { cleanStaleState, pruneAuditLog } from '../src/core/startup-cleanup.js';
+import { registerTeamCommand, bootstrapTeamFromVerboMd } from '../src/commands/team.js';
+import { registerAuditCommand } from '../src/commands/audit.js';
+import { createRbacStore } from '../src/core/rbac.js';
+import { createAuditLogStore } from '../src/core/audit-log-store.js';
+import { createCostStore } from '../src/core/cost-store.js';
+import { createPipelineRunner } from '../src/core/pipeline-runner.js';
+import { createNotifications } from '../src/core/notifications.js';
+import { readCostConfig, readPipelineConfigs, readNotificationConfig } from '../src/core/verbo-md.js';
+import { readSession, clearSession } from '../src/auth/auth-store.js';
+import { checkLimit } from '../src/auth/plan-enforcer.js';
+import { AuthGate } from '../src/tui/components/auth-gate.js';
+import { startTui } from '../src/tui/tui.js';
+import { detectProject } from '../src/init/project-detector.js';
+import { ensureInit } from '../src/init/ensure-init.js';
+import { buildDefaults, runQuestionnaire } from '../src/init/questionnaire.js';
+import { renderVerboMd } from '../src/init/template.js';
+import { createTaskDecomposer } from '../src/intelligence/task-decomposer.js';
+import { isIntelligenceEnabled } from '../src/intelligence/kill-switch.js';
+import { render } from 'ink';
+import React from 'react';
+import { DecompositionReview } from '../src/tui/components/decomposition-review.js';
+// ---- Helpers ----
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// When installed via npm, points to dist/src/mcp/stdio-entry.js inside the package
+const MCP_SERVER_COMMAND = `node "${path.join(__dirname, '..', 'src', 'mcp', 'stdio-entry.js')}"`;
+async function ensureAuth() {
+    const session = readSession();
+    if (session)
+        return; // cached (may be stale — refresh is background-only for now)
+    await new Promise((resolve) => {
+        const { unmount } = render(React.createElement(AuthGate, {
+            onSuccess: () => {
+                unmount();
+                resolve();
+            },
+        }));
+    });
+}
+function resolveProjectDir() {
+    const opts = program.opts();
+    if (opts.project) {
+        return path.resolve(opts.project);
+    }
+    return process.cwd();
+}
+let _allCache = null;
+function _initAll() {
+    const projDir = resolveProjectDir();
+    const verboDir = path.join(projDir, '.verbo');
+    if (!fs.existsSync(verboDir))
+        fs.mkdirSync(verboDir, { recursive: true });
+    const dbFile = path.join(verboDir, 'verbo.db');
+    const db = createDatabase(dbFile);
+    const tasks = createTaskStore(db);
+    const sessions = createAgentSessionStore(db);
+    const detector = createConflictDetector(tasks);
+    const hotFileConfig = readHotFiles(projDir);
+    const hotFiles = createHotFiles({
+        projectDir: projDir,
+        configOverrides: hotFileConfig,
+    });
+    const parallelizer = createParallelizer(tasks, { maxAgents: 5 }, hotFiles);
+    const approvals = createApprovalStore(db);
+    const humanActions = createHumanActionStore(db);
+    const learnings = createLearningStore(db);
+    const orchestratorStore = createOrchestratorStore();
+    // Initialize cost store and pipeline runner
+    const costStore = createCostStore(db);
+    const pipelineRunner = createPipelineRunner(tasks);
+    // Read budget from VERBO.md cost section (seed pricing on startup)
+    const costConfig = readCostConfig(projDir);
+    const budgetPerTaskUsd = costConfig.budgetPerTaskUsd;
+    const launcher = createAgentLauncher({
+        projectDir: projDir,
+        mcpServerCommand: MCP_SERVER_COMMAND,
+        approvalPort: 5050,
+        budgetPerTaskUsd,
+        learningStore: learnings,
+    });
+    return {
+        projectDir: projDir, db, tasks, sessions, detector, parallelizer, hotFiles,
+        approvals, humanActions, learnings, orchestratorStore, launcher,
+        costStore, pipelineRunner, budgetPerTaskUsd,
+    };
+}
+function initAll() {
+    if (!_allCache)
+        _allCache = _initAll();
+    return _allCache;
+}
+function taskIcon(status) {
+    switch (status) {
+        case 'done': return '✓';
+        case 'in_progress': return '▸';
+        case 'blocked': return '✗';
+        default: return '○';
+    }
+}
+async function launchAgentForTask(taskId, tasks, sessions, launcher, approvals, projDir, trustLevel = 'medium', enforcer, orchestrator, extras) {
+    const task = tasks.get(taskId);
+    if (!task) {
+        console.error(`Task not found: ${taskId}`);
+        return;
+    }
+    // Guard: don't launch if already in progress — mark immediately to prevent race
+    if (task.status === 'in_progress' || task.status === 'done') {
+        return;
+    }
+    tasks.update(taskId, { status: 'in_progress' });
+    // Create a session record
+    const session = sessions.create({
+        taskId: task.id,
+        humanId: 'local',
+    });
+    // Set up log file for capturing agent output
+    const logDir = path.join(projDir, '.verbo', 'logs');
+    if (!fs.existsSync(logDir))
+        fs.mkdirSync(logDir, { recursive: true });
+    const logPath = path.join(logDir, `${task.id}.log`);
+    const logStream = fs.createWriteStream(logPath, { flags: 'a' });
+    logStream.write(`--- Agent launched at ${new Date().toISOString()} ---\n`);
+    try {
+        const launched = await launcher.launch({
+            taskId: task.id,
+            title: task.title,
+            description: task.description,
+            filePaths: task.filePaths,
+            trustLevel,
+        }, {
+            onOutput: (data) => {
+                logStream.write(data);
+                sessions.heartbeat(session.id);
+            },
+            onError: (data) => {
+                logStream.write(`[stderr] ${data}`);
+            },
+            onExit: (code) => {
+                logStream.write(`\n--- Agent exited with code ${code} at ${new Date().toISOString()} ---\n`);
+                logStream.end();
+                approvals.deleteBySession(session.id);
+                if (code === 0) {
+                    const completedSession = sessions.get(session.id);
+                    sessions.complete(session.id, 'Agent exited successfully');
+                    tasks.update(task.id, { status: 'done' });
+                    // Notify on task completion
+                    extras?.notifications?.send('task_complete', task.title).catch(() => { });
+                    // Advance any active pipeline runs that have this task as their current step
+                    if (extras?.pipelineRunner && extras.pipelineRunIds) {
+                        for (const runId of extras.pipelineRunIds) {
+                            try {
+                                extras.pipelineRunner.advance(runId);
+                            }
+                            catch {
+                                // Non-fatal: pipeline advance failures shouldn't block task completion
+                            }
+                        }
+                    }
+                    // Review diff, push branch, and open PR via the GitHub orchestrator
+                    if (orchestrator) {
+                        const baseBranch = readBaseBranch(projDir);
+                        const worktreeBranch = completedSession?.worktreeBranch ?? `verbo/${task.id}`;
+                        const worktreePath = completedSession?.worktreePath ?? launcher.getWorktreePath(task.id);
+                        orchestrator
+                            .reviewAndPush({
+                            taskId: task.id,
+                            taskTitle: task.title,
+                            summary: completedSession?.completionSummary ?? 'Task completed by Verbo agent',
+                            branch: worktreeBranch,
+                            baseBranch,
+                            worktreePath,
+                        })
+                            .then((result) => {
+                            if (result.prUrl) {
+                                tasks.update(task.id, { prUrl: result.prUrl });
+                            }
+                        })
+                            .catch(() => {
+                            // Failures surface via human_actions (blocking review) or are non-critical
+                        });
+                    }
+                    // Cleanup worktree after successful completion
+                    launcher.cleanupWorktree(task.id).catch(() => { });
+                    // Auto-relaunch tasks that were paused due to conflict with this task
+                    if (enforcer) {
+                        const toRelaunch = enforcer.checkRelaunch(task.id);
+                        for (const relaunchTaskId of toRelaunch) {
+                            launchAgentForTask(relaunchTaskId, tasks, sessions, launcher, approvals, projDir, trustLevel, enforcer, orchestrator, extras).catch((err) => {
+                                console.error(`Failed to auto-relaunch task ${relaunchTaskId}:`, err.message);
+                            });
+                        }
+                    }
+                }
+                else {
+                    sessions.error(session.id);
+                    tasks.unclaim(task.id);
+                    // Cleanup worktree on failure too
+                    launcher.cleanupWorktree(task.id).catch(() => { });
+                    // Advance pipeline runs on failure too (step will be marked failed, on_failure applied)
+                    if (extras?.pipelineRunner && extras.pipelineRunIds) {
+                        for (const runId of extras.pipelineRunIds) {
+                            try {
+                                extras.pipelineRunner.advance(runId);
+                            }
+                            catch {
+                                // Non-fatal
+                            }
+                        }
+                    }
+                }
+                // Emit bell / notifications — notifications.send() includes the bell
+                if (!extras?.notifications) {
+                    process.stderr.write('\x07');
+                }
+            },
+        });
+        // Store pid, worktree info, and fun name on the session
+        sessions.update(session.id, {
+            pid: launched.pid,
+            worktreePath: launched.worktreePath,
+            worktreeBranch: launched.worktreeBranch,
+            status: 'active',
+            funName: formatFunIdentity(launched.funIdentity),
+        });
+        // Set agentSessionId on the task so MCP claim_task can reuse it
+        tasks.update(task.id, {
+            agentSessionId: session.id,
+        });
+    }
+    catch (err) {
+        sessions.error(session.id);
+        throw err;
+    }
+}
+// ---- Program ----
+const program = new Command();
+program
+    .name('verbo')
+    .description('Orchestrate multiple Claude Code agents across your team')
+    .version('0.1.0')
+    .option('--project <path>', 'Target project directory (defaults to cwd)');
+// ---- Auth gate: enforce authentication on all commands except login/logout/init ----
+const AUTH_EXEMPT_COMMANDS = new Set(['login', 'logout', 'init']);
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+    if (!AUTH_EXEMPT_COMMANDS.has(actionCommand.name())) {
+        await ensureAuth();
+    }
+});
+// ---- verbo add <title> ----
+program
+    .command('add <title>')
+    .description('Add a new task')
+    .option('-p, --priority <level>', 'Task priority (p0, p1, p2, p3)', 'p2')
+    .option('-d, --description <text>', 'Task description')
+    .option('-f, --files <paths...>', 'Relevant file paths')
+    .action(async (title, opts) => {
+    const { tasks } = initAll();
+    const task = tasks.create({
+        title,
+        priority: opts.priority,
+        description: opts.description,
+        filePaths: opts.files ?? [],
+    });
+    console.log(`Created task ${task.id}: ${task.title} [${task.priority}]`);
+    // Offer decomposition if description has >= 50 words
+    const descriptionText = opts.description ?? '';
+    const wordCount = descriptionText.trim().split(/\s+/).filter(Boolean).length;
+    if (wordCount >= 50) {
+        const decomposer = createTaskDecomposer(tasks);
+        console.log('Long description detected — generating decomposition…');
+        const subtasks = await decomposer.decompose(descriptionText);
+        if (subtasks && subtasks.length > 0) {
+            await runDecomposeReview(subtasks, decomposer, task.id);
+        }
+    }
+});
+// ---- Decompose review helper (used by CLI commands) ----
+async function runDecomposeReview(subtasks, decomposer, parentTaskId) {
+    return new Promise((resolve) => {
+        const { unmount } = render(React.createElement(DecompositionReview, {
+            subtasks,
+            onConfirm: async () => {
+                unmount();
+                const created = await decomposer.confirm(subtasks, parentTaskId);
+                console.log(`\nCreated ${created.length} subtask${created.length !== 1 ? 's' : ''}:`);
+                for (const t of created) {
+                    console.log(`  ○ [${t.priority}] ${t.title} (${t.id.slice(0, 8)})`);
+                }
+                resolve();
+            },
+            onCancel: () => {
+                unmount();
+                console.log('Decomposition cancelled.');
+                resolve();
+            },
+        }));
+    });
+}
+// ---- verbo decompose <taskId> ----
+program
+    .command('decompose <taskId>')
+    .description('Decompose a task into subtasks using AI')
+    .action(async (taskId) => {
+    const { tasks } = initAll();
+    const task = tasks.get(taskId);
+    if (!task) {
+        console.error(`Task not found: ${taskId}`);
+        process.exit(1);
+    }
+    const input = [task.title, task.description].filter(Boolean).join('\n\n');
+    const decomposer = createTaskDecomposer(tasks);
+    console.log(`Decomposing task: ${task.title}`);
+    const subtasks = await decomposer.decompose(input);
+    if (!subtasks || subtasks.length === 0) {
+        const wordCount = input.trim().split(/\s+/).filter(Boolean).length;
+        if (wordCount < 50) {
+            console.log('Task description too short for decomposition (need ≥50 words).');
+        }
+        else if (!process.env.ANTHROPIC_API_KEY) {
+            console.log('No ANTHROPIC_API_KEY set — cannot decompose.');
+        }
+        else {
+            console.log('Could not decompose task.');
+        }
+        return;
+    }
+    await runDecomposeReview(subtasks, decomposer, task.id);
+});
+// ---- verbo list ----
+program
+    .command('list')
+    .description('List tasks')
+    .option('-s, --status <status>', 'Filter by status (todo, in_progress, done, blocked)')
+    .action((opts) => {
+    const { tasks } = initAll();
+    const filter = opts.status
+        ? { status: opts.status }
+        : undefined;
+    const list = tasks.list(filter);
+    if (list.length === 0) {
+        console.log('No tasks found.');
+        return;
+    }
+    for (const task of list) {
+        const icon = taskIcon(task.status);
+        const shortId = task.id.slice(0, 8);
+        console.log(`${icon} [${task.priority}] ${task.title} (${shortId})`);
+    }
+});
+// ---- verbo launch <taskId> ----
+program
+    .command('launch <taskId>')
+    .description('Launch agent on a specific task')
+    .option('--trust <level>', 'Trust level: low, medium, high (default: medium)', 'medium')
+    .action(async (taskId, opts) => {
+    const trust = opts.trust;
+    if (!['low', 'medium', 'high'].includes(trust)) {
+        console.error(`Invalid trust level: ${opts.trust}. Use low, medium, or high.`);
+        process.exit(1);
+    }
+    const { tasks, sessions, launcher, approvals, projectDir } = initAll();
+    try {
+        await launchAgentForTask(taskId, tasks, sessions, launcher, approvals, projectDir, trust);
+    }
+    catch (err) {
+        console.error('Failed to launch agent:', err.message);
+        process.exit(1);
+    }
+});
+// ---- verbo parallel ----
+program
+    .command('parallel')
+    .description('Show and launch safe parallel set of tasks')
+    .action(async () => {
+    const { tasks, sessions, parallelizer, launcher, approvals, projectDir } = initAll();
+    const batch = parallelizer.findSafeBatch();
+    if (batch.length === 0) {
+        console.log('No parallelizable tasks found.');
+        return;
+    }
+    console.log(`Found ${batch.length} tasks to run in parallel:`);
+    for (const task of batch) {
+        console.log(`  ${taskIcon(task.status)} [${task.priority}] ${task.title} (${task.id.slice(0, 8)})`);
+    }
+    console.log('');
+    for (const task of batch) {
+        try {
+            await launchAgentForTask(task.id, tasks, sessions, launcher, approvals, projectDir);
+        }
+        catch (err) {
+            console.error(`Failed to launch agent for task ${task.id}:`, err.message);
+        }
+    }
+});
+// ---- verbo status ----
+program
+    .command('status')
+    .description('One-line summary of current state')
+    .action(() => {
+    const { tasks, sessions } = initAll();
+    const activeSessions = sessions.listActive();
+    const allTasks = tasks.list();
+    const readyTasks = allTasks.filter((t) => t.status === 'todo');
+    console.log(`${activeSessions.length} agents running, ${readyTasks.length} tasks ready, ${allTasks.length} total`);
+});
+// ---- verbo team (list, invite, role, log) ----
+registerTeamCommand(program, () => {
+    const { db } = initAll();
+    const raw = db.raw();
+    const rbacStore = createRbacStore(raw);
+    const auditLog = createAuditLogStore(db);
+    return { db: raw, rbacStore, auditLog };
+});
+// ---- verbo audit (list, export) ----
+registerAuditCommand(program, () => {
+    const { db } = initAll();
+    const auditLog = createAuditLogStore(db);
+    return { auditLog };
+});
+// ---- verbo kill <agentNumber> ----
+program
+    .command('kill <agentNumber>')
+    .description('Kill agent by number (1-indexed)')
+    .action((agentNumberStr) => {
+    const agentNumber = parseInt(agentNumberStr, 10);
+    if (isNaN(agentNumber) || agentNumber < 1) {
+        console.error('Agent number must be a positive integer.');
+        process.exit(1);
+    }
+    const { sessions, launcher, approvals } = initAll();
+    const activeSessions = sessions.listActive();
+    if (activeSessions.length === 0) {
+        console.log('No active sessions.');
+        return;
+    }
+    const session = activeSessions[agentNumber - 1];
+    if (!session) {
+        console.error(`No agent #${agentNumber}. There are ${activeSessions.length} active agents.`);
+        process.exit(1);
+    }
+    if (session.pid !== null) {
+        launcher.kill(session.pid);
+        console.log(`Killed agent #${agentNumber} (PID ${session.pid})`);
+    }
+    else {
+        console.log(`Agent #${agentNumber} has no PID recorded — marking as errored.`);
+    }
+    approvals.deleteBySession(session.id);
+    sessions.error(session.id);
+});
+// ---- verbo sync ----
+program
+    .command('sync')
+    .description('Force re-sync with relay server')
+    .action(() => {
+    console.log('Sync requested. (Relay integration pending team setup)');
+});
+// ---- verbo stop ----
+program
+    .command('stop')
+    .description('Stop the daemon')
+    .action(() => {
+    const { projectDir } = initAll();
+    const pidFile = path.join(projectDir, '.verbo', 'daemon.pid');
+    if (!fs.existsSync(pidFile)) {
+        console.log('No daemon running (no PID file found).');
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    if (isNaN(pid)) {
+        console.error('Invalid PID in daemon.pid file.');
+        fs.unlinkSync(pidFile);
+        return;
+    }
+    try {
+        process.kill(pid);
+        console.log(`Stopped daemon (PID ${pid}).`);
+    }
+    catch {
+        console.log(`Daemon (PID ${pid}) was not running.`);
+    }
+    fs.unlinkSync(pidFile);
+});
+// ---- verbo yolo ----
+program
+    .command('yolo')
+    .description('Toggle YOLO mode — auto-approve all agent permissions')
+    .action(() => {
+    console.log('YOLO mode toggled. Use the TUI (!) to toggle in real-time.');
+});
+// ---- verbo memory ----
+const memoryCmd = program
+    .command('memory')
+    .description('View or manage project memory (learnings from agent tasks)');
+memoryCmd
+    .action(() => {
+    const { learnings, tasks } = initAll();
+    const all = learnings.list();
+    if (all.length === 0) {
+        console.log('No learnings stored yet.');
+        return;
+    }
+    // Group by category
+    const groups = new Map();
+    for (const l of all) {
+        if (!groups.has(l.category))
+            groups.set(l.category, []);
+        groups.get(l.category).push(l);
+    }
+    for (const [cat, items] of groups) {
+        console.log(`\n${cat.toUpperCase()}S (${items.length})`);
+        for (const l of items) {
+            const taskTitle = l.taskId ? tasks.get(l.taskId)?.title ?? l.taskId.slice(0, 8) : null;
+            const taskSuffix = taskTitle ? ` (${taskTitle})` : '';
+            const sourceSuffix = l.source ? ` [${l.source}]` : '';
+            console.log(`  · ${l.content}${sourceSuffix}${taskSuffix}`);
+        }
+    }
+    console.log(`\nTotal: ${all.length} learnings`);
+});
+memoryCmd
+    .command('clear')
+    .description('Clear all stored project memory')
+    .action(async () => {
+    const { learnings } = initAll();
+    const count = learnings.list().length;
+    if (count === 0) {
+        console.log('No learnings to clear.');
+        return;
+    }
+    const readline = await import('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+        rl.question(`Clear all ${count} learnings? (y/N) `, (answer) => {
+            rl.close();
+            if (answer.trim().toLowerCase() !== 'y') {
+                console.log('Aborted.');
+                process.exit(0);
+            }
+            resolve();
+        });
+    });
+    learnings.clear();
+    console.log(`Cleared ${count} learnings.`);
+});
+// ---- verbo config ----
+const configCmd = program
+    .command('config')
+    .description('Read or write VERBO.md configuration fields');
+configCmd
+    .command('set <field> <value>')
+    .description('Set a field in VERBO.md (e.g. verbo config set merge_mode auto)')
+    .action(async (field, value) => {
+    const projDir = resolveProjectDir();
+    const verboMdPath = path.join(projDir, 'VERBO.md');
+    const validationErr = validateFieldValue(field, value);
+    if (validationErr) {
+        console.error(validationErr);
+        process.exit(1);
+    }
+    const warning = requiresConfirmation(field, value);
+    if (warning) {
+        console.log(warning);
+        const readline = await import('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        await new Promise((resolve) => {
+            rl.question('Confirm? (y/N) ', (answer) => {
+                rl.close();
+                if (answer.trim().toLowerCase() !== 'y') {
+                    console.log('Aborted.');
+                    process.exit(0);
+                }
+                resolve();
+            });
+        });
+    }
+    setVerboMdField(verboMdPath, field, value);
+    console.log(`✓ VERBO.md updated: ${field} → ${value}`);
+});
+configCmd
+    .command('get [field]')
+    .description('Show current VERBO.md configuration (or a specific field)')
+    .action((field) => {
+    const projDir = resolveProjectDir();
+    const verboMdPath = path.join(projDir, 'VERBO.md');
+    if (field) {
+        if (!FIELD_REGISTRY[field]) {
+            const known = Object.keys(FIELD_REGISTRY).join(', ');
+            console.error(`Unknown field "${field}". Known fields: ${known}`);
+            process.exit(1);
+        }
+        const fields = getVerboMdFields(verboMdPath);
+        const val = fields[field];
+        if (val === undefined) {
+            console.log(`${field}: (not set)`);
+        }
+        else {
+            console.log(`${field}: ${val}`);
+        }
+        return;
+    }
+    const fields = getVerboMdFields(verboMdPath);
+    if (Object.keys(fields).length === 0) {
+        console.log('No configuration set. Run `verbo init` to create VERBO.md.');
+        return;
+    }
+    for (const [k, v] of Object.entries(fields)) {
+        console.log(`${k}: ${v}`);
+    }
+});
+// ---- verbo init ----
+program
+    .command('init')
+    .description('Initialize VERBO.md for your project')
+    .action(async () => {
+    const projDir = resolveProjectDir();
+    const verboMdPath = path.join(projDir, 'VERBO.md');
+    if (fs.existsSync(verboMdPath)) {
+        console.log('VERBO.md already exists. Delete it first to re-initialize.');
+        return;
+    }
+    console.log('Verbo Init — Setting up your project\n');
+    // Detect project
+    const info = detectProject(projDir);
+    const projectName = path.basename(projDir);
+    const defaults = buildDefaults(projectName, info);
+    // Check for gh CLI
+    try {
+        execSync('gh --version', { stdio: 'ignore' });
+    }
+    catch {
+        console.log('  Warning: gh CLI not found. Auto-PR creation requires it.');
+        console.log('  Install: https://cli.github.com/\n');
+    }
+    // Run questionnaire
+    const answers = await runQuestionnaire(defaults);
+    // Render and write
+    const md = renderVerboMd(answers);
+    fs.writeFileSync(verboMdPath, md, 'utf-8');
+    console.log(`\n  VERBO.md created at ${verboMdPath}`);
+    console.log('  Agents will follow these rules when launched with verbo start.\n');
+});
+// ---- verbo login ----
+program
+    .command('login')
+    .description('Log in to Verbo (opens browser)')
+    .action(async () => {
+    clearSession();
+    await ensureAuth();
+    const session = readSession();
+    if (session) {
+        console.log(`Logged in as ${session.email} (${session.plan} plan)`);
+    }
+});
+// ---- verbo logout ----
+program
+    .command('logout')
+    .description('Log out and clear local credentials')
+    .action(() => {
+    clearSession();
+    console.log('Logged out. Run verbo login to authenticate again.');
+});
+// ---- verbo cost ----
+function fmtUsd(n) {
+    return '$' + n.toFixed(4);
+}
+function fmtTokens(n) {
+    if (n >= 1_000_000)
+        return (n / 1_000_000).toFixed(2) + 'M';
+    if (n >= 1_000)
+        return (n / 1_000).toFixed(1) + 'k';
+    return String(n);
+}
+const costCmd = program
+    .command('cost')
+    .description('Show cost tracking summary and breakdowns');
+costCmd
+    .command('summary')
+    .description('Overall cost summary')
+    .action(() => {
+    const { costStore } = initAll();
+    const s = costStore.getSummary();
+    const today = costStore.getCostToday();
+    console.log('=== Cost Summary ===');
+    console.log(`Total spent:     ${fmtUsd(s.totalCostUsd)}`);
+    console.log(`Spent today:     ${fmtUsd(today)}`);
+    console.log(`Entries:         ${s.entryCount}`);
+    console.log(`Input tokens:    ${fmtTokens(s.totalInputTokens)}`);
+    console.log(`Output tokens:   ${fmtTokens(s.totalOutputTokens)}`);
+    console.log(`Cache read:      ${fmtTokens(s.totalCacheReadTokens)}`);
+    console.log(`Cache write:     ${fmtTokens(s.totalCacheWriteTokens)}`);
+});
+costCmd
+    .command('by-task')
+    .description('Cost breakdown by task')
+    .action(() => {
+    const { costStore, tasks } = initAll();
+    const groups = costStore.getCostByTask();
+    if (groups.length === 0) {
+        console.log('No cost data recorded yet.');
+        return;
+    }
+    console.log('=== Cost by Task ===');
+    for (const g of groups) {
+        const task = g.group !== '(no task)' ? tasks.get(g.group) : null;
+        const label = task ? `${g.group.slice(0, 8)}… ${task.title}` : g.group;
+        console.log(`  ${fmtUsd(g.costUsd).padStart(10)}  ${String(g.entryCount).padStart(4)} entries  ${label}`);
+    }
+});
+costCmd
+    .command('by-day')
+    .description('Cost breakdown by day')
+    .action(() => {
+    const { costStore } = initAll();
+    const groups = costStore.getCostByDay();
+    if (groups.length === 0) {
+        console.log('No cost data recorded yet.');
+        return;
+    }
+    console.log('=== Cost by Day ===');
+    for (const g of groups) {
+        console.log(`  ${g.group}  ${fmtUsd(g.costUsd).padStart(10)}  ${String(g.entryCount).padStart(4)} entries`);
+    }
+});
+costCmd
+    .command('by-model')
+    .description('Cost breakdown by model (requires cost_events data)')
+    .action(() => {
+    const { db } = initAll();
+    const raw = db.raw();
+    const rows = raw.prepare(`SELECT model, SUM(cost_usd) AS cost_usd, COUNT(*) AS entry_count
+       FROM cost_events GROUP BY model ORDER BY cost_usd DESC`).all();
+    if (rows.length === 0) {
+        console.log('No model-level cost data recorded yet.');
+        console.log('(Model tracking uses the cost_events table, populated by providers that report model info.)');
+        return;
+    }
+    console.log('=== Cost by Model ===');
+    for (const r of rows) {
+        console.log(`  ${fmtUsd(r.cost_usd).padStart(10)}  ${String(r.entry_count).padStart(4)} entries  ${r.model}`);
+    }
+});
+costCmd
+    .command('by-pipeline')
+    .description('Cost breakdown by pipeline run')
+    .action(() => {
+    const { costStore } = initAll();
+    const groups = costStore.getCostByPipeline();
+    if (groups.length === 0) {
+        console.log('No cost data recorded yet.');
+        return;
+    }
+    console.log('=== Cost by Pipeline Run ===');
+    for (const g of groups) {
+        console.log(`  ${fmtUsd(g.costUsd).padStart(10)}  ${String(g.entryCount).padStart(4)} entries  ${g.group}`);
+    }
+});
+costCmd
+    .command('update-prices <model>')
+    .description('Set or update pricing for a model (costs per 1M tokens)')
+    .option('--input <cost>', 'Input cost per 1M tokens', parseFloat)
+    .option('--output <cost>', 'Output cost per 1M tokens', parseFloat)
+    .option('--cache-read <cost>', 'Cache read cost per 1M tokens', parseFloat)
+    .option('--cache-write <cost>', 'Cache write cost per 1M tokens', parseFloat)
+    .action((model, opts) => {
+    if (opts.input == null || opts.output == null) {
+        console.error('--input and --output are required.');
+        process.exit(1);
+    }
+    const { costStore } = initAll();
+    costStore.updateModelPricing({
+        model,
+        inputCostPer1mTokens: opts.input,
+        outputCostPer1mTokens: opts.output,
+        cacheReadCostPer1mTokens: opts.cacheRead ?? null,
+        cacheWriteCostPer1mTokens: opts.cacheWrite ?? null,
+    });
+    console.log(`Pricing updated for model: ${model}`);
+    console.log(`  Input:       $${opts.input}/1M tokens`);
+    console.log(`  Output:      $${opts.output}/1M tokens`);
+    if (opts.cacheRead != null)
+        console.log(`  Cache read:  $${opts.cacheRead}/1M tokens`);
+    if (opts.cacheWrite != null)
+        console.log(`  Cache write: $${opts.cacheWrite}/1M tokens`);
+});
+costCmd
+    .command('prices')
+    .description('List all configured model prices')
+    .action(() => {
+    const { costStore } = initAll();
+    const prices = costStore.listModelPricing();
+    if (prices.length === 0) {
+        console.log('No custom model pricing configured.');
+        console.log('Using defaults: $3/1M input, $15/1M output, $0.30/1M cache-read, $3.75/1M cache-write');
+        return;
+    }
+    console.log('=== Model Pricing ===');
+    for (const p of prices) {
+        console.log(`  ${p.model}`);
+        console.log(`    Input: $${p.inputCostPer1mTokens}/1M  Output: $${p.outputCostPer1mTokens}/1M`);
+        if (p.cacheReadCostPer1mTokens != null)
+            console.log(`    Cache read: $${p.cacheReadCostPer1mTokens}/1M  Cache write: $${p.cacheWriteCostPer1mTokens}/1M`);
+    }
+});
+// Default: show summary when just `verbo cost` is run
+costCmd.action(() => {
+    const { costStore } = initAll();
+    const s = costStore.getSummary();
+    const today = costStore.getCostToday();
+    console.log('=== Cost Summary ===');
+    console.log(`Total spent:     ${fmtUsd(s.totalCostUsd)}`);
+    console.log(`Spent today:     ${fmtUsd(today)}`);
+    console.log(`Entries:         ${s.entryCount}`);
+    console.log(`Input tokens:    ${fmtTokens(s.totalInputTokens)}`);
+    console.log(`Output tokens:   ${fmtTokens(s.totalOutputTokens)}`);
+    console.log(`Cache read:      ${fmtTokens(s.totalCacheReadTokens)}`);
+    console.log(`Cache write:     ${fmtTokens(s.totalCacheWriteTokens)}`);
+    console.log('');
+    console.log('Subcommands: summary, by-task, by-day, by-model, by-pipeline, update-prices, prices');
+});
+// ---- verbo whoami ----
+program
+    .command('whoami')
+    .description('Show current authenticated user and plan')
+    .action(() => {
+    const session = readSession();
+    if (!session) {
+        console.log('Not logged in. Run verbo login.');
+        return;
+    }
+    console.log(`Email: ${session.email}`);
+    console.log(`Plan:  ${session.plan}`);
+    console.log(`Agents: ${session.limits.maxAgents === -1 ? 'unlimited' : session.limits.maxAgents}`);
+    console.log(`Tasks:  ${session.limits.maxTasks === -1 ? 'unlimited' : session.limits.maxTasks}`);
+});
+// ---- Default action: TUI ----
+program
+    .action(async () => {
+    // ensureAuth() is handled by the preAction hook
+    await ensureInit(resolveProjectDir());
+    const session = readSession();
+    let flashMessage = null;
+    const all = initAll();
+    const { projectDir, tasks, sessions, detector, parallelizer, hotFiles, approvals, humanActions, orchestratorStore, pipelineRunner, budgetPerTaskUsd, } = all;
+    const auditLogForTui = createAuditLogStore(all.db);
+    const pidFile = path.join(projectDir, '.verbo', 'daemon.pid');
+    fs.writeFileSync(pidFile, String(process.pid), 'utf-8');
+    const approvalServer = await createApprovalServer({
+        port: 5050,
+        approvals,
+        sessions,
+        pollIntervalMs: 500,
+        timeoutMs: 300000,
+    });
+    console.log(`Approval server running on http://localhost:${approvalServer.port()}`);
+    // Re-create launcher with the actual approval server port (and budget)
+    const launcher = createAgentLauncher({
+        projectDir,
+        mcpServerCommand: MCP_SERVER_COMMAND,
+        approvalPort: approvalServer.port(),
+        budgetPerTaskUsd,
+        learningStore: all.learnings,
+    });
+    // Initialize notifications from VERBO.md
+    const notificationConfig = readNotificationConfig(projectDir);
+    const notifications = createNotifications(notificationConfig);
+    // Sync pipelines from VERBO.md [pipelines] section: create runs for configured pipelines
+    const pipelineRunIds = new Set();
+    const pipelineConfigs = readPipelineConfigs(projectDir);
+    for (const pipelineConfig of pipelineConfigs) {
+        if (pipelineConfig.steps.length === 0)
+            continue;
+        // Map each step title to a matching task (first task whose title matches)
+        const allTasks = tasks.list();
+        const resolvedSteps = pipelineConfig.steps.map((step, i) => {
+            const match = allTasks.find((t) => t.title.toLowerCase() === step.title.toLowerCase());
+            return match ? {
+                id: `${pipelineConfig.name}-step-${i}`,
+                name: step.title,
+                taskId: match.id,
+                on_failure: (step.onFailure === 'notify' ? 'stop' : step.onFailure),
+                requires_approval: step.requiresApproval,
+            } : null;
+        });
+        // Only start a run if all steps have matching tasks
+        if (resolvedSteps.some((s) => s === null))
+            continue;
+        const pipeline = {
+            id: pipelineConfig.name,
+            name: pipelineConfig.title,
+            steps: resolvedSteps,
+        };
+        try {
+            const run = pipelineRunner.start(pipeline);
+            pipelineRunIds.add(run.id);
+        }
+        catch {
+            // Non-fatal: pipeline start failure doesn't block the TUI
+        }
+    }
+    // Clean up stale state from previous runs (orphaned worktrees, sessions, approvals)
+    const cleanupResult = await cleanStaleState({
+        tasks, sessions, approvals, launcher, projectDir,
+        pipelineRunner, pipelineRunIds,
+    });
+    if (cleanupResult.worktreesCleaned > 0) {
+        console.log(`Cleaned up ${cleanupResult.worktreesCleaned} orphaned worktree(s) from previous run`);
+    }
+    // Prune old audit log entries (retain 90 days by default)
+    const auditPruned = pruneAuditLog(all.db.raw(), 90);
+    if (auditPruned > 0) {
+        console.log(`Pruned ${auditPruned} audit log entries older than 90 days`);
+    }
+    // Bootstrap team members from VERBO.md [team] section
+    const verboMdPath = path.join(projectDir, 'VERBO.md');
+    if (fs.existsSync(verboMdPath)) {
+        const verboMdContent = fs.readFileSync(verboMdPath, 'utf-8');
+        const teamSeeded = bootstrapTeamFromVerboMd(all.db.raw(), verboMdContent);
+        if (teamSeeded > 0) {
+            console.log(`Bootstrapped ${teamSeeded} team member(s) from VERBO.md`);
+        }
+    }
+    // Create merge queue for sequential PR processing
+    const mergeQueue = createMergeQueue({
+        baseBranch: readBaseBranch(projectDir),
+        humanActions,
+        onMerged: () => {
+            hotFiles.refresh();
+        },
+    });
+    // Create orchestrator for review-and-push workflow
+    const orchestrator = createGitHubOrchestrator({
+        projectDir,
+        humanActions,
+        store: orchestratorStore,
+        mergeQueue,
+    });
+    // Kill session helper: kill PID, clean up approvals, mark errored
+    function killSessionById(sessionId) {
+        const session = sessions.get(sessionId);
+        if (session?.pid !== null && session?.pid !== undefined) {
+            launcher.kill(session.pid);
+        }
+        approvals.deleteBySession(sessionId);
+        sessions.error(sessionId);
+    }
+    // Create conflict enforcer for automatic conflict resolution
+    const enforcer = createConflictEnforcer({
+        tasks,
+        sessions,
+        detector,
+        killSession: killSessionById,
+    });
+    // Periodic conflict enforcement — check every 2 seconds
+    const enforcementInterval = setInterval(() => {
+        enforcer.enforce().then((actions) => {
+            for (const action of actions) {
+                // Terminal bell: conflict enforcement happened
+                process.stderr.write('\x07');
+            }
+        }).catch(() => { });
+    }, 2000);
+    // Factory mode — automatic task dispatch pipeline
+    const FACTORY_MAX_AGENTS = 4;
+    let factoryMode = false;
+    const factoryInterval = setInterval(() => {
+        const activeSessions = sessions.listActive();
+        if (activeSessions.length >= FACTORY_MAX_AGENTS)
+            return;
+        const allTasks = tasks.list();
+        const todoTasks = allTasks.filter((t) => t.status === 'todo' && !t.title.startsWith('HUMANO:'));
+        if (todoTasks.length === 0)
+            return;
+        const activeFiles = allTasks
+            .filter((t) => t.status === 'in_progress')
+            .flatMap((t) => t.filePaths);
+        // Find the first non-conflicting task to launch.
+        // Subtasks (parentTaskId set) are always launched regardless of factoryMode.
+        // Regular top-level tasks are only launched when factoryMode is on.
+        for (const candidate of todoTasks) {
+            const isSubtask = !!candidate.parentTaskId;
+            if (!isSubtask && !factoryMode)
+                continue;
+            if (activeFiles.length > 0 && candidate.filePaths.length > 0) {
+                if (hasFileOverlap(candidate.filePaths, activeFiles))
+                    continue;
+            }
+            launchAgentForTask(candidate.id, tasks, sessions, launcher, approvals, projectDir, 'medium', enforcer, orchestrator, { notifications, pipelineRunner, pipelineRunIds }).catch((err) => {
+                console.error(`Factory: failed to launch ${candidate.id}:`, err.message);
+            });
+            break;
+        }
+    }, 3000);
+    function getState() {
+        const allTasks = tasks.list();
+        const activeSessions = sessions.listActive();
+        const conflicts = detector.findOverlaps();
+        const parallelBatch = parallelizer.findSafeBatch();
+        // Group active sessions by humanId for teamMembers
+        const byHuman = new Map();
+        for (const session of activeSessions) {
+            if (!byHuman.has(session.humanId)) {
+                byHuman.set(session.humanId, []);
+            }
+            byHuman.get(session.humanId).push(session);
+        }
+        const teamMembers = Array.from(byHuman.entries()).map(([humanId, sArr]) => ({
+            humanId,
+            sessions: sArr,
+        }));
+        return {
+            tasks: allTasks,
+            activeSessions,
+            conflicts,
+            parallelBatch,
+            teamMembers,
+            syncStatus: 'disconnected',
+            pendingApprovals: approvals.listPending(),
+            resolvedApprovals: approvals.listResolved(),
+            humanActions: humanActions.listPending(),
+            orchestratorStates: orchestratorStore.list(),
+            yoloMode: approvalServer.isYoloMode(),
+            factoryMode,
+            flashMessage,
+            intelligenceEnabled: isIntelligenceEnabled(),
+            isCompliance: false,
+            sandboxEnabled: false,
+            mergeQueueItems: mergeQueue.getQueue(),
+            mergeQueueProcessing: mergeQueue.isProcessing(),
+        };
+    }
+    const tui = startTui({
+        getState,
+        teamName: 'local',
+        onCreateTask: (title) => {
+            const allTasks = tasks.list();
+            const check = checkLimit('maxTasks', allTasks.length, session.limits);
+            if (!check.allowed) {
+                flashMessage = check.message;
+                setTimeout(() => { flashMessage = null; }, 4000);
+                return;
+            }
+            tasks.create({ title });
+        },
+        onDeleteTask: (taskId) => {
+            tasks.delete(taskId);
+        },
+        onLaunchAgent: (taskId, trustLevel) => {
+            const activeSessions = sessions.listActive();
+            const check = checkLimit('maxAgents', activeSessions.length, session.limits);
+            if (!check.allowed) {
+                flashMessage = check.message;
+                setTimeout(() => { flashMessage = null; }, 4000);
+                return;
+            }
+            launchAgentForTask(taskId, tasks, sessions, launcher, approvals, projectDir, trustLevel ?? 'medium', enforcer, orchestrator, { notifications, pipelineRunner, pipelineRunIds }).catch((err) => {
+                const e = err;
+                const debugLine = `[${new Date().toISOString()}] LAUNCH FAILED: ${e.message}\n${e.stack}\n`;
+                fs.appendFileSync(path.join(projectDir, '.verbo', 'launch-debug.log'), debugLine);
+            });
+        },
+        onLaunchBatch: (taskIds, trustLevel) => {
+            const activeSessions = sessions.listActive();
+            const check = checkLimit('maxAgents', activeSessions.length, session.limits);
+            if (!check.allowed) {
+                flashMessage = check.message;
+                setTimeout(() => { flashMessage = null; }, 4000);
+                return;
+            }
+            for (const taskId of taskIds) {
+                launchAgentForTask(taskId, tasks, sessions, launcher, approvals, projectDir, trustLevel ?? 'medium', enforcer, orchestrator, { notifications, pipelineRunner, pipelineRunIds }).catch((err) => {
+                    console.error(`Failed to launch agent for ${taskId}:`, err.message);
+                });
+            }
+        },
+        onKillAgent: (sessionId) => {
+            killSessionById(sessionId);
+        },
+        onDismiss: () => {
+            clearInterval(enforcementInterval);
+            clearInterval(factoryInterval);
+            approvalServer.stop();
+            tui.unmount();
+            console.log('TUI dismissed. Daemon still running.');
+        },
+        onApproveRequest: (id) => {
+            approvals.approve(id);
+        },
+        onDenyRequest: (id) => {
+            approvals.deny(id);
+        },
+        onToggleYolo: () => {
+            approvalServer.setYoloMode(!approvalServer.isYoloMode());
+        },
+        onToggleFactory: () => {
+            factoryMode = !factoryMode;
+        },
+        onResolveHumanAction: (id) => {
+            humanActions.resolve(id);
+        },
+        onDecomposeTask: async (taskId) => {
+            const task = tasks.get(taskId);
+            if (!task)
+                return null;
+            const input = [task.title, task.description].filter(Boolean).join('\n\n');
+            const decomposer = createTaskDecomposer(tasks);
+            return decomposer.decompose(input);
+        },
+        onConfirmDecompose: (subtasks, parentTaskId) => {
+            const decomposer = createTaskDecomposer(tasks);
+            decomposer.confirm(subtasks, parentTaskId).catch((err) => {
+                console.error('Failed to create subtasks:', err.message);
+            });
+        },
+        onForcePush: (taskId) => {
+            orchestrator.forcePush(taskId).then((result) => {
+                if (result.prUrl) {
+                    tasks.update(taskId, { prUrl: result.prUrl });
+                }
+            }).catch((err) => {
+                console.error(`Force push failed for task ${taskId}:`, err.message);
+            });
+        },
+        getLearnings: () => all.learnings.list(),
+        getAuditEntries: () => auditLogForTui.query(),
+        getTaskTitleById: (taskId) => tasks.get(taskId)?.title ?? null,
+    });
+    await tui.waitUntilExit();
+});
+program.parse();
+//# sourceMappingURL=verbo.js.map