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

package/src/cli-handlers.ts

@@ -12,9 +12,11 @@ import { DashboardServer } from './bot/dashboard.js';
 import { openBrowser } from './bot/utils.js';
 import type { ExecutionEvent, WeaverConfig, RunRecord, RunOutcome, RunCostSummary, CostSummary, StageStatus, WorkflowResult, AuditEvent } from './bot/types.js';
 import { AuditStore } from './bot/audit-store.js';
+import { handleWeaverTool } from './ai-chat-provider.js';
 
 export interface ParsedArgs {
-  command: 'run' | 'history' | 'costs' | 'providers' | 'watch' | 'cron' | 'pipeline' | 'dashboard' | 'eject' | 'bot' | 'session' | 'steer' | 'queue' | 'status' | 'genesis' | 'audit' | 'init' | 'assistant' | 'examples' | 'doctor' | 'improve';
+  command: 'run' | 'history' | 'costs' | 'providers' | 'watch' | 'cron' | 'pipeline' | 'dashboard' | 'eject' | 'bot' | 'swarm' | 'task' | 'profile' | 'reset' | 'steer' | 'status' | 'genesis' | 'audit' | 'init' | 'assistant' | 'examples' | 'doctor' | 'improve';
+  subcommand?: string;
   file?: string;
   verbose: boolean;
   dryRun: boolean;
@@ -58,11 +60,17 @@ export interface ParsedArgs {
   genesisWatch: boolean;
   // eject
   ejectWorkflow?: string;
-  // session scheduling
-  sessionContinuous: boolean;
-  sessionUntil?: string;
-  sessionMaxTasks?: number;
-  sessionParallel?: number;
+  // swarm / task / profile
+  maxConcurrent?: number;
+  budgetTokens?: number;
+  budgetCost?: number;
+  profileId?: string;
+  costStrategy?: string;
+  botId?: string;
+  confirmFlag?: boolean;
+  taskDescription?: string;
+  complexity?: string;
+  autoRetry?: boolean;
   // assistant
   assistantNew?: boolean;
   assistantResume?: string;
@@ -102,7 +110,6 @@ export function parseArgs(argv: string[]): ParsedArgs {
     autoApprove: false,
     genesisInit: false,
     genesisWatch: false,
-    sessionContinuous: false,
   };
 
   const args = argv.slice(2);
@@ -207,13 +214,46 @@ export function parseArgs(argv: string[]): ParsedArgs {
       result.dashboard = true;
     } 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';
     } else if (arg === 'examples') {
@@ -224,27 +264,10 @@ export function parseArgs(argv: string[]): ParsedArgs {
       result.command = 'status';
     } 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) {
       i++;
@@ -292,17 +315,37 @@ export function parseArgs(argv: string[]): ParsedArgs {
     } else if (arg === '--delete' && i + 1 < args.length) {
       i++;
       result.assistantDelete = args[i];
-    } else if (arg === '--continuous') {
-      result.sessionContinuous = true;
-    } else if (arg === '--until' && i + 1 < args.length) {
+    } 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 === '--profile' && i + 1 < args.length) {
+      i++;
+      result.profileId = args[i];
+    } else if (arg === '--cost-strategy' && i + 1 < args.length) {
       i++;
-      result.sessionUntil = args[i];
-    } else if (arg === '--max-tasks' && i + 1 < args.length) {
+      result.costStrategy = args[i];
+    } else if (arg === '--bot' && i + 1 < args.length) {
       i++;
-      result.sessionMaxTasks = parseInt(args[i]!, 10) || undefined;
-    } else if (arg === '--parallel' && i + 1 < args.length) {
+      result.botId = args[i];
+    } else if (arg === '--confirm') {
+      result.confirmFlag = true;
+    } else if (arg === '--description' && i + 1 < args.length) {
       i++;
-      result.sessionParallel = Math.min(Math.max(parseInt(args[i]!, 10) || 1, 1), 5);
+      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++;
       result.file = args[i];
@@ -1342,300 +1385,198 @@ export async function handleBot(opts: ParsedArgs): Promise<void> {
   }
 }
 
-export async function handleSession(opts: ParsedArgs): Promise<void> {
-  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: number | undefined;
-  let deadlineStr: string | undefined;
-  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;
+// --- Swarm / Task / Profile / Reset handlers (thin wrappers around handleWeaverTool) ---
 
-  // 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)`);
+function colorStatus(status: string): string {
+  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;
   }
+}
 
-  // 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 {} }
+export async function handleSwarm(opts: ParsedArgs): Promise<void> {
+  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`);
     }
-  } 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);
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`\x1b[31m[weaver] Fatal: ${msg}\x1b[0m`);
-      process.exit(1);
+    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;
   }
 
-  // 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<string, Promise<void>>();
-  const filesInUse = new Set<string>();
-
-  const processTask = async (task: { id: string; title: string; description: string; context: { files: string[] } }) => {
-    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;
-      } else {
-        await taskStore.update(task.id, { status: 'failed' });
-        sessionFailed++;
-        consecutiveErrors++;
-        consecutiveNoOps = 0;
-      }
-
-      // Track cost from workflow result
-      if (result.cost) {
-        sessionInputTokens += result.cost.totalInputTokens ?? 0;
-        sessionOutputTokens += result.cost.totalOutputTokens ?? 0;
-        sessionCost += result.cost.totalCost ?? 0;
-      }
-
-    } catch (err: unknown) {
-      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++;
-      }
-    } finally {
-      for (const f of task.context.files) filesInUse.delete(f);
-      running.delete(task.id);
+  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;
     }
-  };
-
-  while (taskCount < maxTasks && !interrupted) {
-    if (deadline && Date.now() >= deadline) {
-      renderer.info('Deadline reached, stopping session.');
+    case 'stop': {
+      await handleWeaverTool('fw_weaver_swarm_stop', {}, projectDir);
+      console.log('\x1b[33m→ Swarm stopped\x1b[0m');
       break;
     }
-
-    if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-      renderer.error('Session stopped', `${MAX_CONSECUTIVE_ERRORS} consecutive errors — check your API key or provider config.`);
+    case 'pause': {
+      await handleWeaverTool('fw_weaver_swarm_pause', {}, projectDir);
+      console.log('\x1b[33m→ Swarm paused\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;
+    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`);
+  }
+}
 
-    // Wait if at capacity
-    if (running.size >= parallelism) {
-      await Promise.race(running.values());
-      continue;
+export async function handleTask(opts: ParsedArgs): Promise<void> {
+  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; }
+      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;
     }
-
-    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 '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;
       }
-      // No pending or running tasks — wait and retry
-      await new Promise(r => setTimeout(r, 5_000));
-      continue;
-    }
-
-    // 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',
-        });
+      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}` : ''}`);
       }
-      renderer.info(`Decomposed into ${subtasks.length} per-file tasks`);
-      continue;
+      break;
     }
-
-    // File conflict check: if task targets overlap with files in use, wait
-    const taskTargets = task.context.files;
-    const hasConflict = taskTargets.some((f: string) => filesInUse.has(f));
-    if (hasConflict && running.size > 0) {
-      await Promise.race(running.values());
-      continue;
+    case 'get': {
+      const id = opts.botTask;
+      if (!id) { console.error('Usage: weaver task get <id>'); return; }
+      const { result } = await handleWeaverTool('fw_weaver_task_get', { id }, projectDir);
+      console.log(result);
+      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;
+    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;
     }
+    case 'cancel': {
+      const id = opts.botTask;
+      if (!id) { console.error('Usage: weaver task cancel <id>'); return; }
+      await handleWeaverTool('fw_weaver_task_cancel', { id }, projectDir);
+      console.log(`\x1b[33m→ Task ${id} cancelled\x1b[0m`);
+      break;
+    }
+    case 'retry': {
+      const id = opts.botTask;
+      if (!id) { console.error('Usage: weaver task retry <id>'); return; }
+      await handleWeaverTool('fw_weaver_task_retry', { id }, projectDir);
+      console.log(`\x1b[32m→ Task ${id} retried\x1b[0m`);
+      break;
+    }
+    default:
+      // Default: list
+      await handleTask({ ...opts, subcommand: 'list' });
   }
+}
 
-  // 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`);
-    } catch { /* non-fatal */ }
+export async function handleProfile(opts: ParsedArgs): Promise<void> {
+  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;
+    }
+    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;
+    }
+    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: { name: string }) => c.name).join(', ');
+        console.log(`  ${p.name} (${p.id}) [${p.preferences?.costStrategy ?? 'balanced'}] → ${p.botId} | ${caps || 'no capabilities'}`);
+      }
+      break;
+    }
   }
+}
 
-  // 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 as { webhook: string }).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
-      }
-    } catch { /* non-fatal */ }
+export async function handleReset(opts: ParsedArgs): Promise<void> {
+  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: ParsedArgs): Promise<void> {
@@ -1776,148 +1717,54 @@ export async function handleAssistant(opts: ParsedArgs): Promise<void> {
 }
 
 export async function handleSteer(opts: ParsedArgs): Promise<void> {
-  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 as 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue',
-    payload: opts.botFile,
-    timestamp: Date.now(),
-  };
-
-  await controller.write(command);
-  console.log(`[weaver] Steering command sent: ${subcommand}${opts.botFile ? ' "' + opts.botFile + '"' : ''}`);
+  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 handleQueue(opts: ParsedArgs): Promise<void> {
-  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);
-  }
+export async function handleStatus(opts: ParsedArgs): Promise<void> {
+  const projectDir = opts.file || process.cwd();
 
-  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;
-    }
-  }
-}
+  // Get swarm status
+  const { result: swarmResult } = await handleWeaverTool('fw_weaver_swarm_status', {}, projectDir);
+  const swarm = JSON.parse(swarmResult);
 
-export async function handleStatus(opts: ParsedArgs): Promise<void> {
-  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;
+  // 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`);
-  }
+  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: { status: string }) => t.status === 'pending').length;
+    const running = tasks.filter((t: { status: string }) => t.status === 'in-progress').length;
+    const done = tasks.filter((t: { status: string }) => t.status === 'done').length;
+    const failed = tasks.filter((t: { status: string }) => t.status === 'failed').length;
+    console.log(`  Tasks: ${pending} pending, ${running} running, ${done} done, ${failed} failed`);
 
-  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  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('');
 }