@synergenius/flow-weaver-pack-weaver 0.9.80 → 0.9.82

package/dist/cli-handlers.js

@@ -11,6 +11,7 @@ import { PipelineRunner } from './bot/pipeline-runner.js';
 import { DashboardServer } from './bot/dashboard.js';
 import { openBrowser } from './bot/utils.js';
 import { AuditStore } from './bot/audit-store.js';
+import { handleWeaverTool } from './ai-chat-provider.js';
 export function parseArgs(argv) {
     const result = {
         command: 'run',
@@ -33,7 +34,6 @@ export function parseArgs(argv) {
         autoApprove: false,
         genesisInit: false,
         genesisWatch: false,
-        sessionContinuous: false,
     };
     const args = argv.slice(2);
     let i = 0;
@@ -169,14 +169,50 @@ export function parseArgs(argv) {
         }
         else if (arg === 'bot') {
             result.command = 'bot';
-            // Next non-flag arg is the task string
+            // Next non-flag arg is the task string or subcommand
             if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
                 i++;
-                result.botTask = args[i];
+                result.subcommand = args[i];
+                // For non-registry subcommands, treat as task string
+                if (!['list', 'register', 'validate'].includes(result.subcommand)) {
+                    result.botTask = result.subcommand;
+                    result.subcommand = undefined;
+                }
+            }
+        }
+        else if (arg === 'swarm') {
+            result.command = 'swarm';
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                i++;
+                result.subcommand = args[i];
+            }
+        }
+        else if (arg === 'task') {
+            result.command = 'task';
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                i++;
+                result.subcommand = args[i];
+                // For create/get/cancel/retry: next positional is the title/id
+                if (['create', 'get', 'cancel', 'retry'].includes(result.subcommand) && i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                    i++;
+                    result.botTask = args[i];
+                }
+            }
+        }
+        else if (arg === 'profile') {
+            result.command = 'profile';
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                i++;
+                result.subcommand = args[i];
+                // For create/delete: next positional is the name/id
+                if (['create', 'delete'].includes(result.subcommand) && i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                    i++;
+                    result.botTask = args[i];
+                }
             }
         }
-        else if (arg === 'session') {
-            result.command = 'session';
+        else if (arg === 'reset') {
+            result.command = 'reset';
         }
         else if (arg === 'assistant') {
             result.command = 'assistant';
@@ -192,28 +228,10 @@ export function parseArgs(argv) {
         }
         else if (arg === 'steer') {
             result.command = 'steer';
-            // Next arg is the subcommand
+            // Next arg is the subcommand (pause/resume/cancel)
             if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
                 i++;
-                result.botTask = args[i];
-                // Next arg after redirect/queue is payload
-                if ((args[i] === 'redirect' || args[i] === 'queue') && i + 1 < args.length && !args[i + 1].startsWith('-')) {
-                    i++;
-                    result.botFile = args[i];
-                }
-            }
-        }
-        else if (arg === 'queue') {
-            result.command = 'queue';
-            // Next arg is action (add/list/clear/remove)
-            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
-                i++;
-                result.botTask = args[i];
-                // Next arg is task/id
-                if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
-                    i++;
-                    result.botFile = args[i];
-                }
+                result.subcommand = args[i];
             }
         }
         else if (arg === '--file' && i + 1 < args.length) {
@@ -279,20 +297,47 @@ export function parseArgs(argv) {
             i++;
             result.assistantDelete = args[i];
         }
-        else if (arg === '--continuous') {
-            result.sessionContinuous = true;
+        else if (arg === '--max-concurrent' && i + 1 < args.length) {
+            i++;
+            result.maxConcurrent = parseInt(args[i], 10) || undefined;
+        }
+        else if (arg === '--budget-tokens' && i + 1 < args.length) {
+            i++;
+            result.budgetTokens = parseInt(args[i], 10) || undefined;
+        }
+        else if (arg === '--budget-cost' && i + 1 < args.length) {
+            i++;
+            result.budgetCost = parseFloat(args[i]) || undefined;
         }
-        else if (arg === '--until' && i + 1 < args.length) {
+        else if (arg === '--profile' && i + 1 < args.length) {
             i++;
-            result.sessionUntil = args[i];
+            result.profileId = args[i];
         }
-        else if (arg === '--max-tasks' && i + 1 < args.length) {
+        else if (arg === '--cost-strategy' && i + 1 < args.length) {
             i++;
-            result.sessionMaxTasks = parseInt(args[i], 10) || undefined;
+            result.costStrategy = args[i];
         }
-        else if (arg === '--parallel' && i + 1 < args.length) {
+        else if (arg === '--bot' && i + 1 < args.length) {
             i++;
-            result.sessionParallel = Math.min(Math.max(parseInt(args[i], 10) || 1, 1), 5);
+            result.botId = args[i];
+        }
+        else if (arg === '--confirm') {
+            result.confirmFlag = true;
+        }
+        else if (arg === '--description' && i + 1 < args.length) {
+            i++;
+            result.taskDescription = args[i];
+        }
+        else if (arg === '--complexity' && i + 1 < args.length) {
+            i++;
+            result.complexity = args[i];
+        }
+        else if (arg === '--auto-retry') {
+            result.autoRetry = true;
+        }
+        else if (arg === '--status' && i + 1 < args.length) {
+            i++;
+            result.historyOutcome = args[i];
         }
         else if (arg === '--project-dir' && i + 1 < args.length) {
             i++;
@@ -1260,286 +1305,213 @@ export async function handleBot(opts) {
         process.exit(1);
     }
 }
-export async function handleSession(opts) {
-    const projectDir = opts.file ?? process.cwd();
-    // Set project dir for per-project queue isolation
-    process.env.WEAVER_PROJECT_DIR = projectDir;
-    const config = await loadConfig(opts.configPath);
-    const workflowPath = resolveWorkflowPath('agent', projectDir);
-    // Create terminal renderer for all session output
-    const { TerminalRenderer } = await import('./bot/terminal-renderer.js');
-    const renderer = new TerminalRenderer({ verbose: opts.verbose, quiet: opts.quiet });
-    // Parse --until HH:MM into a deadline timestamp
-    let deadline;
-    let deadlineStr;
-    if (opts.sessionUntil) {
-        const match = opts.sessionUntil.match(/^(\d{1,2}):(\d{2})$/);
-        if (match) {
-            const now = new Date();
-            const target = new Date(now);
-            target.setHours(parseInt(match[1], 10), parseInt(match[2], 10), 0, 0);
-            if (target.getTime() <= now.getTime())
-                target.setDate(target.getDate() + 1);
-            deadline = target.getTime();
-            deadlineStr = target.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-        }
-    }
-    const maxTasks = opts.sessionMaxTasks ?? Infinity;
-    const continuous = opts.sessionContinuous || !!opts.sessionUntil || maxTasks < Infinity;
-    const parallelism = opts.sessionParallel ?? 1;
-    // Crash recovery
-    if (continuous) {
-        const { TaskStore } = await import('./bot/task-store.js');
-        const recoveryStore = new TaskStore(projectDir);
-        // Recover orphaned in-progress tasks back to pending
-        const inProgressTasks = await recoveryStore.list({ status: 'in-progress' });
-        let recovered = 0;
-        for (const t of inProgressTasks) {
-            await recoveryStore.update(t.id, { status: 'pending' });
-            recovered++;
-        }
-        if (recovered > 0)
-            renderer.info(`Recovered ${recovered} orphaned task(s)`);
-    }
-    // Clean stale cache files
-    try {
-        const { execSync: execSyncClean } = await import('node:child_process');
-        const staleOutput = execSyncClean(`find "${projectDir}" -name "fw-exec-*" -type f`, { encoding: 'utf-8', timeout: 5000 }).trim();
-        if (staleOutput) {
-            const staleFiles = staleOutput.split('\n').filter(Boolean);
-            for (const f of staleFiles) {
-                try {
-                    fs.unlinkSync(f);
-                }
-                catch { }
-            }
+// --- Swarm / Task / Profile / Reset handlers (thin wrappers around handleWeaverTool) ---
+function colorStatus(status) {
+    switch (status) {
+        case 'running': return '\x1b[32m' + status + '\x1b[0m';
+        case 'paused': return '\x1b[33m' + status + '\x1b[0m';
+        case 'stopped':
+        case 'idle': return '\x1b[90m' + status + '\x1b[0m';
+        default: return status;
+    }
+}
+export async function handleSwarm(opts) {
+    const projectDir = opts.file || process.cwd();
+    const sub = opts.subcommand;
+    if (!sub || sub === 'status') {
+        const { result } = await handleWeaverTool('fw_weaver_swarm_status', {}, projectDir);
+        const data = JSON.parse(result);
+        console.log(`\x1b[1mSwarm: ${colorStatus(data.status)}\x1b[0m`);
+        if (data.instances !== undefined)
+            console.log(`  Instances: ${data.instances}`);
+        if (data.maxConcurrent !== undefined)
+            console.log(`  Max concurrent: ${data.maxConcurrent}`);
+        if (data.taskCounts) {
+            const tc = data.taskCounts;
+            console.log(`  Tasks: ${tc.pending ?? 0} pending, ${tc.running ?? 0} running, ${tc.done ?? 0} done, ${tc.failed ?? 0} failed`);
+        }
+        if (data.budget) {
+            const b = data.budget;
+            if (b.tokensUsed !== undefined)
+                console.log(`  Tokens: ${b.tokensUsed.toLocaleString()} / ${(b.tokensLimit ?? '∞').toLocaleString()}`);
+            if (b.costUsed !== undefined)
+                console.log(`  Cost: $${b.costUsed.toFixed(4)} / $${(b.costLimit ?? '∞')}`);
         }
+        return;
     }
-    catch { /* non-fatal */ }
-    // Detect provider label for session start
-    const providerType = config?.provider ?? 'auto';
-    const providerLabel = typeof providerType === 'object' ? providerType.name : String(providerType);
-    const sessionStartTime = Date.now();
-    renderer.sessionStart({ provider: providerLabel, parallel: parallelism, deadline: deadlineStr });
-    // Single-run mode (backwards compatible)
-    if (!continuous) {
-        try {
-            const result = await runWorkflow(workflowPath, {
-                params: { projectDir },
-                verbose: opts.verbose,
-                dryRun: opts.dryRun,
-                config,
-            });
-            if (!opts.quiet) {
-                const color = result.success ? '\x1b[32m' : '\x1b[31m';
-                console.log(`${color}Session: ${result.outcome}\x1b[0m`);
-            }
-            process.exit(result.success ? 0 : 1);
+    switch (sub) {
+        case 'start': {
+            await handleWeaverTool('fw_weaver_swarm_start', {
+                maxConcurrent: opts.maxConcurrent,
+                sessionBudgetTokens: opts.budgetTokens,
+                sessionBudgetCost: opts.budgetCost,
+            }, projectDir);
+            console.log('\x1b[32m→ Swarm started\x1b[0m');
+            break;
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`\x1b[31m[weaver] Fatal: ${msg}\x1b[0m`);
-            process.exit(1);
+        case 'stop': {
+            await handleWeaverTool('fw_weaver_swarm_stop', {}, projectDir);
+            console.log('\x1b[33m→ Swarm stopped\x1b[0m');
+            break;
         }
-        return;
+        case 'pause': {
+            await handleWeaverTool('fw_weaver_swarm_pause', {}, projectDir);
+            console.log('\x1b[33m→ Swarm paused\x1b[0m');
+            break;
+        }
+        case 'config': {
+            await handleWeaverTool('fw_weaver_swarm_config', {
+                maxConcurrent: opts.maxConcurrent,
+                workspaceBudgetTokens: opts.budgetTokens,
+                workspaceBudgetCost: opts.budgetCost,
+                autoRetry: opts.autoRetry,
+            }, projectDir);
+            console.log('\x1b[32m→ Config updated\x1b[0m');
+            break;
+        }
+        default:
+            console.error(`Unknown swarm command: ${sub}. Use: start, stop, pause, status, config`);
     }
-    // Continuous mode: loop until deadline/maxTasks/interrupt
-    const { TaskStore } = await import('./bot/task-store.js');
-    const { isTransientError, getErrorGuidance } = await import('./bot/error-classifier.js');
-    const taskStore = new TaskStore(projectDir);
-    let taskCount = 0;
-    let interrupted = false;
-    let consecutiveErrors = 0;
-    let consecutiveNoOps = 0;
-    const MAX_CONSECUTIVE_ERRORS = 3;
-    const MAX_CONSECUTIVE_NO_OPS = 5;
-    // Session stats
-    let sessionCompleted = 0, sessionFailed = 0, sessionNoOp = 0;
-    let sessionInputTokens = 0, sessionOutputTokens = 0, sessionCost = 0;
-    process.on('SIGINT', () => { interrupted = true; });
-    process.on('SIGTERM', () => { interrupted = true; });
-    // Parallel task tracking
-    const running = new Map();
-    const filesInUse = new Set();
-    const processTask = async (task) => {
-        const taskPayload = { id: task.id, instruction: task.title, description: task.description, targets: task.context.files };
-        try {
-            const result = await runWorkflow(workflowPath, {
-                params: { projectDir, taskJson: JSON.stringify(taskPayload) },
-                verbose: opts.verbose,
-                dryRun: opts.dryRun,
-                config,
-            });
-            // Classify outcome: the summary contains "no changes" or "0 files" for no-ops
-            const isNoOp = result.success && (result.summary.includes('no changes') ||
-                result.summary.includes('0 file') ||
-                result.summary.includes("doesn't exist") ||
-                result.summary.includes('does not exist') ||
-                result.summary.includes('nothing to') ||
-                result.outcome === 'no-op');
-            if (isNoOp) {
-                await taskStore.update(task.id, { status: 'done' });
-                sessionNoOp++;
-                consecutiveNoOps++;
-                consecutiveErrors = 0;
-            }
-            else if (result.success) {
-                await taskStore.update(task.id, { status: 'done' });
-                sessionCompleted++;
-                consecutiveErrors = 0;
-                consecutiveNoOps = 0;
+}
+export async function handleTask(opts) {
+    const projectDir = opts.file || process.cwd();
+    const sub = opts.subcommand;
+    switch (sub) {
+        case 'create': {
+            const title = opts.botTask;
+            if (!title) {
+                console.error('Usage: weaver task create "title"');
+                return;
             }
-            else {
-                await taskStore.update(task.id, { status: 'failed' });
-                sessionFailed++;
-                consecutiveErrors++;
-                consecutiveNoOps = 0;
+            const { result } = await handleWeaverTool('fw_weaver_task_create', {
+                title,
+                description: opts.taskDescription,
+                priority: opts.historyOutcome, // reuse for priority if needed
+                assignedProfile: opts.profileId,
+                complexity: opts.complexity,
+            }, projectDir);
+            const data = JSON.parse(result);
+            console.log(`\x1b[32m→ Task created: ${data.task?.id ?? data.id ?? 'unknown'}\x1b[0m`);
+            break;
+        }
+        case 'list': {
+            const { result } = await handleWeaverTool('fw_weaver_task_list', {
+                status: opts.historyOutcome,
+                limit: opts.historyLimit,
+            }, projectDir);
+            const tasks = JSON.parse(result);
+            if (!Array.isArray(tasks) || tasks.length === 0) {
+                console.log('  No tasks.');
+                return;
             }
-            // Track cost from workflow result
-            if (result.cost) {
-                sessionInputTokens += result.cost.totalInputTokens ?? 0;
-                sessionOutputTokens += result.cost.totalOutputTokens ?? 0;
-                sessionCost += result.cost.totalCost ?? 0;
+            for (const t of tasks) {
+                const icon = t.status === 'done' ? '\x1b[32m✓\x1b[0m' : t.status === 'failed' ? '\x1b[31m✗\x1b[0m' : t.status === 'in-progress' ? '\x1b[36m▸\x1b[0m' : '○';
+                console.log(`  ${icon} ${(t.id ?? '').slice(0, 8)} ${t.title ?? ''} [${t.status ?? ''}] ${t.assignedProfile ? `→ ${t.assignedProfile}` : ''}`);
             }
+            break;
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const guidance = getErrorGuidance(msg);
-            renderer.error(`Task ${task.id.slice(0, 8)} error`, guidance ? `${msg}\n  Hint: ${guidance}` : msg);
-            await taskStore.update(task.id, { status: 'failed' });
-            sessionFailed++;
-            if (!isTransientError(err)) {
-                consecutiveErrors++;
+        case 'get': {
+            const id = opts.botTask;
+            if (!id) {
+                console.error('Usage: weaver task get <id>');
+                return;
             }
-        }
-        finally {
-            for (const f of task.context.files)
-                filesInUse.delete(f);
-            running.delete(task.id);
-        }
-    };
-    while (taskCount < maxTasks && !interrupted) {
-        if (deadline && Date.now() >= deadline) {
-            renderer.info('Deadline reached, stopping session.');
+            const { result } = await handleWeaverTool('fw_weaver_task_get', { id }, projectDir);
+            console.log(result);
             break;
         }
-        if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-            renderer.error('Session stopped', `${MAX_CONSECUTIVE_ERRORS} consecutive errors — check your API key or provider config.`);
+        case 'clear': {
+            const filter = opts.confirmFlag ? 'all' : 'completed';
+            const { result } = await handleWeaverTool('fw_weaver_tasks_clear', { filter }, projectDir);
+            const data = JSON.parse(result);
+            console.log(`\x1b[32m→ Cleared ${data.cleared} tasks\x1b[0m`);
             break;
         }
-        // Pause on consecutive no-ops (bot is spinning without doing anything)
-        if (consecutiveNoOps >= MAX_CONSECUTIVE_NO_OPS) {
-            renderer.warn(`${MAX_CONSECUTIVE_NO_OPS} consecutive no-op tasks — pausing 60s`);
-            await new Promise(r => setTimeout(r, 60_000));
-            consecutiveNoOps = 0;
-        }
-        // Wait if at capacity
-        if (running.size >= parallelism) {
-            await Promise.race(running.values());
-            continue;
-        }
-        const pendingTasks = await taskStore.list({ status: 'pending', limit: 1 });
-        const task = pendingTasks[0] ?? null;
-        if (!task) {
-            if (running.size > 0) {
-                // Tasks still running — wait for one to finish
-                await Promise.race(running.values());
-                continue;
+        case 'cancel': {
+            const id = opts.botTask;
+            if (!id) {
+                console.error('Usage: weaver task cancel <id>');
+                return;
             }
-            // No pending or running tasks — wait and retry
-            await new Promise(r => setTimeout(r, 5_000));
-            continue;
+            await handleWeaverTool('fw_weaver_task_cancel', { id }, projectDir);
+            console.log(`\x1b[33m→ Task ${id} cancelled\x1b[0m`);
+            break;
         }
-        // Auto-decompose broad tasks into per-file tasks
-        const { decomposeTask } = await import('./bot/task-decomposer.js');
-        const decomposable = { id: task.id, instruction: task.title, targets: task.context.files, priority: task.priority };
-        const { decomposed, tasks: subtasks } = decomposeTask(decomposable, projectDir);
-        if (decomposed && subtasks.length > 1) {
-            // Replace the broad task with per-file tasks
-            await taskStore.update(task.id, { status: 'done' });
-            for (const st of subtasks) {
-                await taskStore.create({
-                    title: st.instruction,
-                    description: st.instruction,
-                    priority: st.priority ?? 0,
-                    createdBy: 'ai',
-                });
+        case 'retry': {
+            const id = opts.botTask;
+            if (!id) {
+                console.error('Usage: weaver task retry <id>');
+                return;
             }
-            renderer.info(`Decomposed into ${subtasks.length} per-file tasks`);
-            continue;
+            await handleWeaverTool('fw_weaver_task_retry', { id }, projectDir);
+            console.log(`\x1b[32m→ Task ${id} retried\x1b[0m`);
+            break;
         }
-        // File conflict check: if task targets overlap with files in use, wait
-        const taskTargets = task.context.files;
-        const hasConflict = taskTargets.some((f) => filesInUse.has(f));
-        if (hasConflict && running.size > 0) {
-            await Promise.race(running.values());
-            continue;
+        default:
+            // Default: list
+            await handleTask({ ...opts, subcommand: 'list' });
+    }
+}
+export async function handleProfile(opts) {
+    const projectDir = opts.file || process.cwd();
+    const sub = opts.subcommand;
+    switch (sub) {
+        case 'create': {
+            const name = opts.botTask;
+            if (!name) {
+                console.error('Usage: weaver profile create "name" --bot <botId>');
+                return;
+            }
+            await handleWeaverTool('fw_weaver_profile_create', {
+                name,
+                botId: opts.botId,
+                costStrategy: opts.costStrategy ?? 'balanced',
+                instructions: opts.taskDescription,
+            }, projectDir);
+            console.log(`\x1b[32m→ Profile created\x1b[0m`);
+            break;
         }
-        taskCount++;
-        if (opts.verbose)
-            process.env.WEAVER_VERBOSE = '1';
-        renderer.taskStart(taskCount, task.title ?? task.id);
-        await taskStore.update(task.id, { status: 'in-progress' });
-        // Reserve files
-        for (const f of taskTargets)
-            filesInUse.add(f);
-        // Launch task (parallel or sequential based on parallelism setting)
-        const promise = processTask(task);
-        running.set(task.id, promise);
-        // In sequential mode (parallelism=1), await immediately
-        if (parallelism <= 1) {
-            await promise;
-        }
-    }
-    // Wait for all remaining parallel tasks
-    if (running.size > 0) {
-        await Promise.allSettled(running.values());
-    }
-    const elapsed = Date.now() - sessionStartTime;
-    renderer.sessionEnd({
-        tasks: taskCount,
-        completed: sessionCompleted,
-        failed: sessionFailed,
-        totalInputTokens: sessionInputTokens,
-        totalOutputTokens: sessionOutputTokens,
-        totalCost: sessionCost,
-        elapsed,
-    });
-    // Desktop notification on session end (cross-platform)
-    if (taskCount > 0) {
-        try {
-            const { sendDesktopNotification } = await import('./bot/bot-manager.js');
-            sendDesktopNotification('Weaver Session Complete', `${sessionCompleted} done, ${sessionFailed} failed, ${sessionNoOp} no-op`);
+        case 'delete': {
+            const id = opts.botTask;
+            if (!id) {
+                console.error('Usage: weaver profile delete <id>');
+                return;
+            }
+            await handleWeaverTool('fw_weaver_profile_delete', { id }, projectDir);
+            console.log(`\x1b[32m→ Profile deleted\x1b[0m`);
+            break;
         }
-        catch { /* non-fatal */ }
-    }
-    // Webhook notification if configured
-    if (config?.notify) {
-        try {
-            const webhookUrl = typeof config.notify === 'string' ? config.notify
-                : typeof config.notify === 'object' && 'webhook' in config.notify ? config.notify.webhook
-                    : null;
-            if (webhookUrl) {
-                fetch(webhookUrl, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        event: 'session.completed',
-                        timestamp: new Date().toISOString(),
-                        tasks: taskCount,
-                        completed: sessionCompleted,
-                        failed: sessionFailed,
-                        noOp: sessionNoOp,
-                        tokens: sessionInputTokens + sessionOutputTokens,
-                        cost: sessionCost,
-                        elapsed: Date.now() - sessionStartTime,
-                    }),
-                }).catch(() => { }); // fire-and-forget
+        default: {
+            // Default: list
+            const { result } = await handleWeaverTool('fw_weaver_profile_list', {}, projectDir);
+            const profiles = JSON.parse(result);
+            if (!Array.isArray(profiles) || profiles.length === 0) {
+                console.log('  No profiles.');
+                return;
             }
+            for (const p of profiles) {
+                const caps = (p.capabilities || []).map((c) => c.name).join(', ');
+                console.log(`  ${p.name} (${p.id}) [${p.preferences?.costStrategy ?? 'balanced'}] → ${p.botId} | ${caps || 'no capabilities'}`);
+            }
+            break;
         }
-        catch { /* non-fatal */ }
     }
 }
+export async function handleReset(opts) {
+    if (!opts.confirmFlag) {
+        console.error('This will delete ALL tasks, profiles, history, and config.');
+        console.error('Use --confirm to proceed: weaver reset --confirm');
+        return;
+    }
+    const projectDir = opts.file || process.cwd();
+    const { result } = await handleWeaverTool('fw_weaver_reset_all', {}, projectDir);
+    const data = JSON.parse(result);
+    console.log(`\x1b[32m→ Reset complete\x1b[0m`);
+    console.log(`  Tasks cleared: ${data.tasksCleared ?? 0}`);
+    console.log(`  Profiles cleared: ${data.profilesCleared ?? 0}`);
+    console.log(`  Bots registered: ${data.botsRegistered ?? 0}`);
+    console.log(`  Profiles created: ${data.profilesCreated ?? 0}`);
+}
 export async function handleAssistant(opts) {
     const projectDir = opts.file ?? process.cwd();
     // Handle --list and --delete before creating provider
@@ -1673,143 +1645,48 @@ export async function handleAssistant(opts) {
     });
 }
 export async function handleSteer(opts) {
-    const { SteeringController } = await import('./bot/steering.js');
-    const controller = new SteeringController();
-    const subcommand = opts.botTask;
-    if (!subcommand || !['pause', 'resume', 'cancel', 'redirect', 'queue'].includes(subcommand)) {
-        console.error('[weaver] Usage: flow-weaver weaver steer <pause|resume|cancel|redirect|queue> [payload]');
+    const projectDir = opts.file || process.cwd();
+    const sub = opts.subcommand;
+    if (!sub || !['pause', 'resume', 'cancel'].includes(sub)) {
+        console.error('[weaver] Usage: flow-weaver weaver steer <pause|resume|cancel> [--bot <id>]');
         process.exit(1);
     }
-    const command = {
-        command: subcommand,
-        payload: opts.botFile,
-        timestamp: Date.now(),
-    };
-    await controller.write(command);
-    console.log(`[weaver] Steering command sent: ${subcommand}${opts.botFile ? ' "' + opts.botFile + '"' : ''}`);
-}
-export async function handleQueue(opts) {
-    const { TaskStore } = await import('./bot/task-store.js');
-    const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
-    const store = new TaskStore(projectDir);
-    const action = opts.botTask;
-    if (!action || !['add', 'list', 'clear', 'remove', 'retry'].includes(action)) {
-        console.error('[weaver] Usage: flow-weaver weaver queue <add|list|clear|remove|retry> [task|id]');
-        process.exit(1);
-    }
-    switch (action) {
-        case 'add': {
-            const instruction = opts.botFile;
-            if (!instruction) {
-                console.error('[weaver] Usage: flow-weaver weaver queue add "task instruction"');
-                process.exit(1);
-            }
-            const task = await store.create({ title: instruction, description: instruction, priority: 0, createdBy: 'user' });
-            console.log(`[weaver] Task added: ${task.id}`);
-            break;
-        }
-        case 'list': {
-            const tasks = await store.list();
-            if (opts.historyJson) {
-                console.log(JSON.stringify(tasks, null, 2));
-            }
-            else if (tasks.length === 0) {
-                console.log('No tasks in queue.');
-            }
-            else {
-                console.log('ID'.padEnd(10) + 'STATUS'.padEnd(14) + 'PRIORITY'.padEnd(10) + 'TITLE');
-                for (const t of tasks) {
-                    console.log(t.id.padEnd(10) + t.status.padEnd(14) + String(t.priority).padEnd(10) + t.title.slice(0, 60));
-                }
-            }
-            break;
-        }
-        case 'clear': {
-            const tasks = await store.list();
-            let count = 0;
-            for (const t of tasks) {
-                await store.update(t.id, { status: 'cancelled' });
-                count++;
-            }
-            console.log(`Cleared ${count} task(s).`);
-            break;
-        }
-        case 'remove': {
-            const id = opts.botFile;
-            if (!id) {
-                console.error('[weaver] Usage: flow-weaver weaver queue remove <id>');
-                process.exit(1);
-            }
-            try {
-                await store.update(id, { status: 'cancelled' });
-                console.log(`Cancelled task ${id}.`);
-            }
-            catch {
-                console.log(`No task found with id "${id}".`);
-            }
-            break;
-        }
-        case 'retry': {
-            const id = opts.botFile;
-            if (id) {
-                try {
-                    await store.update(id, { status: 'pending' });
-                    console.log(`Task ${id} reset to pending.`);
-                }
-                catch {
-                    console.log(`No task found with id "${id}".`);
-                }
-            }
-            else {
-                const failed = await store.list({ status: 'failed' });
-                let count = 0;
-                for (const t of failed) {
-                    await store.update(t.id, { status: 'pending' });
-                    count++;
-                }
-                console.log(`Reset ${count} failed task(s) to pending.`);
-            }
-            break;
-        }
-    }
+    await handleWeaverTool('fw_weaver_steer', {
+        command: sub,
+        botId: opts.botId,
+    }, projectDir);
+    console.log(`\x1b[33m→ Steer: ${sub}${opts.botId ? ` (bot: ${opts.botId})` : ''}\x1b[0m`);
 }
 export async function handleStatus(opts) {
-    const store = new RunStore();
-    const { TaskStore } = await import('./bot/task-store.js');
-    const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
-    const taskStore = new TaskStore(projectDir);
-    const orphans = store.checkOrphans();
-    const recentRuns = store.list({ limit: 5 });
-    const tasks = await taskStore.list();
-    const pending = tasks.filter(t => t.status === 'pending').length;
-    const running = tasks.filter(t => t.status === 'in-progress').length;
-    const completed = tasks.filter(t => t.status === 'done').length;
-    const failed = tasks.filter(t => t.status === 'failed').length;
+    const projectDir = opts.file || process.cwd();
+    // Get swarm status
+    const { result: swarmResult } = await handleWeaverTool('fw_weaver_swarm_status', {}, projectDir);
+    const swarm = JSON.parse(swarmResult);
+    // Get task list
+    const { result: taskResult } = await handleWeaverTool('fw_weaver_task_list', { limit: 10 }, projectDir);
+    const tasks = JSON.parse(taskResult);
     if (opts.historyJson) {
-        console.log(JSON.stringify({
-            queue: { pending, running, completed, failed, total: tasks.length },
-            orphanedRuns: orphans.length,
-            recentRuns: recentRuns.map(r => ({
-                id: r.id, outcome: r.outcome, summary: r.summary,
-                startedAt: r.startedAt, durationMs: r.durationMs,
-            })),
-        }, null, 2));
+        console.log(JSON.stringify({ swarm, tasks }, null, 2));
         return;
     }
-    console.log('\n\x1b[1mWeaver Status\x1b[0m\n');
-    console.log(`  Queue:  ${pending} pending, ${running} running, ${completed} completed, ${failed} failed`);
-    if (orphans.length > 0) {
-        console.log(`  \x1b[33mOrphaned runs: ${orphans.length} (recovered)\x1b[0m`);
-    }
-    if (recentRuns.length > 0) {
-        console.log(`\n  Recent runs:`);
-        for (const r of recentRuns) {
-            const icon = r.success ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
-            console.log(`    ${icon} ${r.id.slice(0, 8)} ${r.outcome.padEnd(9)} ${formatDuration(r.durationMs).padEnd(8)} ${r.summary.slice(0, 60)}`);
+    console.log(`\n\x1b[1mWeaver Status\x1b[0m\n`);
+    console.log(`  Swarm: ${colorStatus(swarm.status ?? 'unknown')}`);
+    if (swarm.maxConcurrent !== undefined)
+        console.log(`  Max concurrent: ${swarm.maxConcurrent}`);
+    if (Array.isArray(tasks) && tasks.length > 0) {
+        const pending = tasks.filter((t) => t.status === 'pending').length;
+        const running = tasks.filter((t) => t.status === 'in-progress').length;
+        const done = tasks.filter((t) => t.status === 'done').length;
+        const failed = tasks.filter((t) => t.status === 'failed').length;
+        console.log(`  Tasks: ${pending} pending, ${running} running, ${done} done, ${failed} failed`);
+        console.log(`\n  Recent tasks:`);
+        for (const t of tasks.slice(0, 5)) {
+            const icon = t.status === 'done' ? '\x1b[32m✓\x1b[0m' : t.status === 'failed' ? '\x1b[31m✗\x1b[0m' : t.status === 'in-progress' ? '\x1b[36m▸\x1b[0m' : '○';
+            console.log(`    ${icon} ${(t.id ?? '').slice(0, 8)} [${t.status}] ${(t.title ?? '').slice(0, 60)}`);
         }
     }
     else {
-        console.log('\n  No recent runs.');
+        console.log('  Tasks: none');
     }
     console.log('');
 }