@synergenius/flowweaver-pack-weaver 0.3.1 → 0.5.0

package/dist/{cli.js → cli-handlers.js}

@@ -1,5 +1,6 @@
-#!/usr/bin/env node
 import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { runWorkflow } from './bot/runner.js';
 import { RunStore } from './bot/run-store.js';
 import { CostStore } from './bot/cost-store.js';
@@ -8,64 +9,7 @@ import { WatchDaemon } from './bot/watch-daemon.js';
 import { PipelineRunner } from './bot/pipeline-runner.js';
 import { DashboardServer } from './bot/dashboard.js';
 import { openBrowser } from './bot/utils.js';
-const HELP = `
-weaver - Autonomous workflow runner for Flow Weaver
-
-Usage:
-  weaver <file>                    Run a workflow file
-  weaver run <file>                Same as above
-  weaver history                   List recent runs
-  weaver history <id>              Show details of a specific run
-  weaver costs                     Show cost summary
-  weaver watch <file>               Watch file, re-run on change
-  weaver cron "<schedule>" <file>   Run on cron schedule
-  weaver pipeline <config.json>     Run multi-stage pipeline
-  weaver dashboard [file]           Start live dashboard (optionally run file)
-  weaver providers                  List available providers
-  weaver --help                     Show this help
-
-Options:
-  -v, --verbose                    Show detailed execution info
-  -n, --dry-run                    Preview without executing
-  -p, --params <json>              Input parameters as JSON
-  -c, --config <path>              Path to .weaver.json config
-  --quiet                          Suppress progress output
-  --version                        Show version
-  --dashboard                      Enable live dashboard for run
-  --port <number>                  Dashboard port (default 4242)
-  --open                           Auto-open browser
-  --approval <mode>                Override approval mode
-
-Watch/Cron options:
-  --cron "<schedule>"              Add cron trigger to watch mode
-  --debounce <ms>                  File watch debounce (default 500)
-  --log <path>                     Write output to log file
-
-Pipeline options:
-  --stage <id>                     Run single stage + its dependencies
-
-History options:
-  --limit <n>                      Number of entries (default: 20)
-  --outcome <type>                 Filter: completed|failed|error|skipped
-  --workflow <path>                Filter by workflow file
-  --since <date>                   Show runs after date (ISO-8601)
-  --json                           JSON output
-  --prune                          Prune old entries (keep 500, 90 days)
-  --clear                          Delete all history
-
-Cost options:
-  --since <duration|date>          Filter: 7d, 30d, or ISO-8601 date
-  --model <name>                   Filter by model
-
-Examples:
-  weaver my-workflow.ts
-  weaver run pipeline.ts --verbose --params '{"env":"prod"}'
-  weaver watch my-workflow.ts --cron "*/5 * * * *"
-  weaver pipeline deploy.json --stage test
-  weaver history --outcome failed --limit 10
-  weaver costs --since 7d
-`.trim();
-function parseArgs(argv) {
+export function parseArgs(argv) {
     const result = {
         command: 'run',
         file: undefined,
@@ -84,6 +28,7 @@ function parseArgs(argv) {
         dashboard: false,
         dashboardPort: 4242,
         dashboardOpen: false,
+        autoApprove: false,
     };
     const args = argv.slice(2);
     let i = 0;
@@ -161,6 +106,9 @@ function parseArgs(argv) {
         else if (arg === 'providers') {
             result.command = 'providers';
         }
+        else if (arg === 'eject') {
+            result.command = 'eject';
+        }
         else if (arg === 'watch') {
             result.command = 'watch';
         }
@@ -209,6 +157,62 @@ function parseArgs(argv) {
             result.command = 'dashboard';
             result.dashboard = true;
         }
+        else if (arg === 'bot') {
+            result.command = 'bot';
+            // Next non-flag arg is the task string
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                i++;
+                result.botTask = args[i];
+            }
+        }
+        else if (arg === 'session') {
+            result.command = 'session';
+        }
+        else if (arg === 'steer') {
+            result.command = 'steer';
+            // Next arg is the subcommand
+            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];
+                }
+            }
+        }
+        else if (arg === '--file' && i + 1 < args.length) {
+            i++;
+            result.botFile = args[i];
+        }
+        else if (arg === '--template' && i + 1 < args.length) {
+            i++;
+            result.botTemplate = args[i];
+        }
+        else if (arg === '--batch' && i + 1 < args.length) {
+            i++;
+            result.botBatch = parseInt(args[i], 10) || undefined;
+        }
+        else if (arg === '--auto-approve') {
+            result.autoApprove = true;
+        }
+        else if (arg === '--project-dir' && i + 1 < args.length) {
+            i++;
+            result.file = args[i];
+        }
         else if (arg === 'run') {
             // skip, next arg is the file
         }
@@ -222,14 +226,15 @@ function parseArgs(argv) {
         }
         else {
             console.error(`[weaver] Unknown option: ${arg}`);
-            console.error('Run "weaver --help" for usage');
+            console.error('Run "flow-weaver weaver --help" for usage');
             process.exit(1);
         }
         i++;
     }
     return result;
 }
-function formatDuration(ms) {
+// --- Formatting helpers ---
+export function formatDuration(ms) {
     if (ms < 1000)
         return `${ms}ms`;
     return `${(ms / 1000).toFixed(1)}s`;
@@ -246,7 +251,13 @@ const OUTCOME_COLORS = {
     skipped: '\x1b[33m',
 };
 const RESET = '\x1b[0m';
-// --- History ---
+const STAGE_ICONS = {
+    running: '\x1b[36m>\x1b[0m',
+    completed: '\x1b[32m+\x1b[0m',
+    failed: '\x1b[31mx\x1b[0m',
+    skipped: '\x1b[33m-\x1b[0m',
+    cancelled: '\x1b[33m~\x1b[0m',
+};
 function printRunTable(records) {
     console.log('ID'.padEnd(10) +
         'OUTCOME'.padEnd(12) +
@@ -289,7 +300,57 @@ function printRunDetail(r) {
     }
     console.log('');
 }
-async function handleHistory(opts) {
+function parseSince(spec) {
+    if (!spec)
+        return undefined;
+    const match = spec.match(/^(\d+)([dhm])$/);
+    if (match) {
+        const n = parseInt(match[1], 10);
+        const unit = match[2];
+        const ms = unit === 'd' ? n * 86_400_000 : unit === 'h' ? n * 3_600_000 : n * 60_000;
+        return Date.now() - ms;
+    }
+    const ts = new Date(spec).getTime();
+    return isNaN(ts) ? undefined : ts;
+}
+function formatCostTable(summary) {
+    const lines = [];
+    lines.push(`Weaver Cost Summary (${summary.totalRuns} runs)`);
+    lines.push(`Total: ~$${summary.totalCost.toFixed(4)}`);
+    lines.push(`Tokens: ${summary.totalInputTokens.toLocaleString()} in / ${summary.totalOutputTokens.toLocaleString()} out`);
+    const models = Object.entries(summary.byModel);
+    if (models.length > 0) {
+        lines.push('');
+        lines.push('By model:');
+        for (const [model, data] of models) {
+            lines.push(`  ${model}: ${data.runs} runs, ~$${data.cost.toFixed(4)}, ${data.inputTokens.toLocaleString()} in / ${data.outputTokens.toLocaleString()} out`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatRunCost(cost) {
+    const inp = cost.totalInputTokens.toLocaleString();
+    const out = cost.totalOutputTokens.toLocaleString();
+    const usd = cost.totalCost < 0.01
+        ? `$${cost.totalCost.toFixed(4)}`
+        : `$${cost.totalCost.toFixed(2)}`;
+    return `tokens: ${inp} in / ${out} out | cost: ~${usd} (${cost.model})`;
+}
+async function loadConfig(configPath) {
+    if (!configPath)
+        return undefined;
+    try {
+        const { readFileSync } = await import('node:fs');
+        return JSON.parse(readFileSync(path.resolve(configPath), 'utf-8'));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[weaver] Failed to read config: ${msg}`);
+        process.exit(1);
+    }
+}
+// --- Handlers ---
+export async function handleHistory(opts) {
     const store = new RunStore();
     if (opts.historyClear) {
         const deleted = store.clear();
@@ -332,44 +393,7 @@ async function handleHistory(opts) {
         printRunTable(records);
     }
 }
-// --- Costs ---
-function parseSince(spec) {
-    if (!spec)
-        return undefined;
-    const match = spec.match(/^(\d+)([dhm])$/);
-    if (match) {
-        const n = parseInt(match[1], 10);
-        const unit = match[2];
-        const ms = unit === 'd' ? n * 86_400_000 : unit === 'h' ? n * 3_600_000 : n * 60_000;
-        return Date.now() - ms;
-    }
-    const ts = new Date(spec).getTime();
-    return isNaN(ts) ? undefined : ts;
-}
-function formatCostTable(summary) {
-    const lines = [];
-    lines.push(`Weaver Cost Summary (${summary.totalRuns} runs)`);
-    lines.push(`Total: ~$${summary.totalCost.toFixed(4)}`);
-    lines.push(`Tokens: ${summary.totalInputTokens.toLocaleString()} in / ${summary.totalOutputTokens.toLocaleString()} out`);
-    const models = Object.entries(summary.byModel);
-    if (models.length > 0) {
-        lines.push('');
-        lines.push('By model:');
-        for (const [model, data] of models) {
-            lines.push(`  ${model}: ${data.runs} runs, ~$${data.cost.toFixed(4)}, ${data.inputTokens.toLocaleString()} in / ${data.outputTokens.toLocaleString()} out`);
-        }
-    }
-    return lines.join('\n');
-}
-function formatRunCost(cost) {
-    const inp = cost.totalInputTokens.toLocaleString();
-    const out = cost.totalOutputTokens.toLocaleString();
-    const usd = cost.totalCost < 0.01
-        ? `$${cost.totalCost.toFixed(4)}`
-        : `$${cost.totalCost.toFixed(2)}`;
-    return `tokens: ${inp} in / ${out} out | cost: ~${usd} (${cost.model})`;
-}
-async function handleCosts(opts) {
+export async function handleCosts(opts) {
     const store = new CostStore();
     const sinceTs = parseSince(opts.costsSince);
     const summary = store.summarize({ since: sinceTs, model: opts.costsModel });
@@ -379,21 +403,7 @@ async function handleCosts(opts) {
     }
     console.log(formatCostTable(summary));
 }
-async function loadConfig(configPath) {
-    if (!configPath)
-        return undefined;
-    try {
-        const { readFileSync } = await import('node:fs');
-        return JSON.parse(readFileSync(path.resolve(configPath), 'utf-8'));
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`[weaver] Failed to read config: ${msg}`);
-        process.exit(1);
-    }
-}
-// --- Watch/Cron ---
-async function handleWatch(opts) {
+export async function handleWatch(opts) {
     if (!opts.file) {
         console.error('[weaver] No workflow file specified for watch');
         process.exit(1);
@@ -412,10 +422,10 @@ async function handleWatch(opts) {
     });
     await daemon.start();
 }
-async function handleCron(opts) {
+export async function handleCron(opts) {
     if (!opts.cronSchedule) {
         console.error('[weaver] No cron schedule specified');
-        console.error('Usage: weaver cron "*/5 * * * *" <file>');
+        console.error('Usage: flow-weaver weaver cron "*/5 * * * *" <file>');
         process.exit(1);
     }
     if (!opts.file) {
@@ -436,18 +446,10 @@ async function handleCron(opts) {
     });
     await daemon.start();
 }
-// --- Pipeline ---
-const STAGE_ICONS = {
-    running: '\x1b[36m>\x1b[0m',
-    completed: '\x1b[32m+\x1b[0m',
-    failed: '\x1b[31mx\x1b[0m',
-    skipped: '\x1b[33m-\x1b[0m',
-    cancelled: '\x1b[33m~\x1b[0m',
-};
-async function handlePipeline(opts) {
+export async function handlePipeline(opts) {
     if (!opts.file) {
         console.error('[weaver] No pipeline config specified');
-        console.error('Usage: weaver pipeline <config.json>');
+        console.error('Usage: flow-weaver weaver pipeline <config.json>');
         process.exit(1);
     }
     let config;
@@ -508,8 +510,7 @@ async function handlePipeline(opts) {
         process.exit(1);
     }
 }
-// --- Dashboard ---
-async function handleDashboard(opts) {
+export async function handleDashboard(opts) {
     const dashboard = new DashboardServer({ port: opts.dashboardPort });
     const port = await dashboard.start();
     const url = dashboard.getUrl();
@@ -596,8 +597,7 @@ async function handleDashboard(opts) {
         process.exit(1);
     }
 }
-// --- Providers ---
-async function handleProviders() {
+export async function handleProviders() {
     await discoverProviders(defaultRegistry);
     const providers = defaultRegistry.list();
     if (providers.length === 0) {
@@ -622,64 +622,94 @@ async function handleProviders() {
         console.log('');
     }
 }
-// --- Main ---
-async function main() {
-    const opts = parseArgs(process.argv);
-    // Recover orphaned runs from previous crashes
+export async function handleEject() {
+    // Resolve the pack's own workflows/weaver.ts relative to this file
+    const packRoot = new URL('..', import.meta.url);
+    const srcPath = new URL('src/workflows/weaver.ts', packRoot);
+    let source;
     try {
-        const store = new RunStore();
-        const orphans = store.checkOrphans();
-        for (const orphan of orphans) {
-            console.error(`[weaver] Recovered orphaned run ${orphan.id.slice(0, 8)} (${orphan.workflowFile}) killed at PID ${orphan.pid}`);
-        }
-    }
-    catch { /* non-fatal */ }
-    if (opts.showHelp) {
-        console.log(HELP);
-        process.exit(0);
+        source = fs.readFileSync(srcPath, 'utf-8');
     }
-    if (opts.showVersion) {
+    catch {
+        // Fallback: try dist location (when running from compiled output)
+        const distPath = new URL('dist/workflows/weaver.ts', packRoot);
         try {
-            const pkgPath = new URL('../package.json', import.meta.url);
-            const { default: pkg } = await import(pkgPath.href, { with: { type: 'json' } });
-            console.log(`weaver v${pkg.version}`);
+            source = fs.readFileSync(distPath, 'utf-8');
         }
         catch {
-            console.log('weaver (version unknown)');
+            // Last resort: read the .js and note it
+            const jsPath = new URL('dist/workflows/weaver.js', packRoot);
+            try {
+                source = fs.readFileSync(jsPath, 'utf-8');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[weaver] Could not find managed workflow source: ${msg}`);
+                process.exit(1);
+                return;
+            }
         }
-        process.exit(0);
     }
-    if (opts.command === 'history') {
-        await handleHistory(opts);
-        process.exit(0);
-    }
-    if (opts.command === 'costs') {
-        await handleCosts(opts);
-        process.exit(0);
-    }
-    if (opts.command === 'providers') {
-        await handleProviders();
-        process.exit(0);
-    }
-    if (opts.command === 'watch') {
-        await handleWatch(opts);
-        process.exit(0);
-    }
-    if (opts.command === 'cron') {
-        await handleCron(opts);
-        process.exit(0);
-    }
-    if (opts.command === 'pipeline') {
-        await handlePipeline(opts);
-        return;
+    // Replace pack-relative imports with package imports
+    const rewritten = source
+        .replace(/from\s+['"]\.\.\/node-types\/load-config\.js['"]/g, "from '@synergenius/flowweaver-pack-weaver/node-types'")
+        .replace(/from\s+['"]\.\.\/node-types\/detect-provider\.js['"]/g, "from '@synergenius/flowweaver-pack-weaver/node-types'")
+        .replace(/from\s+['"]\.\.\/node-types\/resolve-target\.js['"]/g, "from '@synergenius/flowweaver-pack-weaver/node-types'")
+        .replace(/from\s+['"]\.\.\/node-types\/execute-target\.js['"]/g, "from '@synergenius/flowweaver-pack-weaver/node-types'")
+        .replace(/from\s+['"]\.\.\/node-types\/send-notify\.js['"]/g, "from '@synergenius/flowweaver-pack-weaver/node-types'")
+        .replace(/from\s+['"]\.\.\/node-types\/report\.js['"]/g, "from '@synergenius/flowweaver-pack-weaver/node-types'");
+    // Deduplicate import lines: collapse multiple imports from the same module
+    const lines = rewritten.split('\n');
+    const importMap = new Map();
+    const nonImportLines = [];
+    let pastImports = false;
+    for (const line of lines) {
+        const importMatch = line.match(/^import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]\s*;?\s*$/);
+        if (importMatch && !pastImports) {
+            const names = importMatch[1].split(',').map((s) => s.trim()).filter(Boolean);
+            const mod = importMatch[2];
+            if (!importMap.has(mod))
+                importMap.set(mod, new Set());
+            for (const n of names)
+                importMap.get(mod).add(n);
+        }
+        else {
+            if (line.trim() !== '' && !line.match(/^import\s/))
+                pastImports = true;
+            nonImportLines.push(line);
+        }
     }
-    if (opts.command === 'dashboard' || opts.dashboard) {
-        await handleDashboard(opts);
-        return;
+    const dedupedImports = [];
+    for (const [mod, names] of importMap) {
+        dedupedImports.push(`import { ${[...names].join(', ')} } from '${mod}';`);
     }
+    const finalSource = [...dedupedImports, ...nonImportLines].join('\n');
+    const destPath = path.resolve(process.cwd(), 'weaver.ts');
+    fs.writeFileSync(destPath, finalSource, 'utf-8');
+    // Read pack version
+    let packVersion = 'unknown';
+    try {
+        const pkgPath = new URL('package.json', packRoot);
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        packVersion = pkg.version;
+    }
+    catch { /* ignore */ }
+    // Write/update .weaver-meta.json
+    const metaPath = path.resolve(process.cwd(), '.weaver-meta.json');
+    const meta = {
+        ejected: true,
+        packVersion,
+        workflowFile: 'weaver.ts',
+    };
+    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + '\n', 'utf-8');
+    console.log(`[weaver] Ejected managed workflow to ${destPath}`);
+    console.log(`[weaver] Metadata written to ${metaPath}`);
+    console.log('[weaver] You can now customize weaver.ts freely.');
+}
+export async function handleRun(opts) {
     if (!opts.file) {
         console.error('[weaver] No workflow file specified');
-        console.error('Run "weaver --help" for usage');
+        console.error('Run "flow-weaver weaver --help" for usage');
         process.exit(1);
     }
     const filePath = path.resolve(opts.file);
@@ -745,5 +775,207 @@ async function main() {
         process.exit(1);
     }
 }
-main();
-//# sourceMappingURL=cli.js.map
+export async function handleBot(opts) {
+    if (!opts.botTask) {
+        console.error('[weaver] No task specified');
+        console.error('Usage: flow-weaver weaver bot "Create a workflow that..."');
+        process.exit(1);
+    }
+    const task = {
+        instruction: opts.botTask,
+        mode: opts.botFile ? 'modify' : 'create',
+        targets: opts.botFile ? [opts.botFile] : undefined,
+        options: {
+            template: opts.botTemplate,
+            batchCount: opts.botBatch,
+            dryRun: opts.dryRun,
+            autoApprove: opts.autoApprove,
+        },
+    };
+    // Use the batch workflow if --batch specified
+    const workflowName = opts.botBatch ? 'weaver-bot-batch' : 'weaver-bot';
+    // Find the workflow file in the pack
+    const packRoot = new URL('..', import.meta.url);
+    let workflowPath;
+    try {
+        workflowPath = fileURLToPath(new URL(`src/workflows/${workflowName}.ts`, packRoot));
+        const { existsSync } = await import('node:fs');
+        if (!existsSync(workflowPath)) {
+            workflowPath = fileURLToPath(new URL(`dist/workflows/${workflowName}.js`, packRoot));
+        }
+    }
+    catch {
+        workflowPath = fileURLToPath(new URL(`dist/workflows/${workflowName}.js`, packRoot));
+    }
+    const config = await loadConfig(opts.configPath);
+    const nodeTimings = new Map();
+    // Start dashboard if requested
+    let dashboard = null;
+    if (opts.dashboard) {
+        dashboard = new DashboardServer({ port: opts.dashboardPort ?? 4242 });
+        const port = await dashboard.start();
+        console.log(`[weaver] Dashboard: http://127.0.0.1:${port}`);
+        openBrowser(`http://127.0.0.1:${port}`);
+        dashboard.broadcastWorkflowStart(workflowPath);
+    }
+    const onEvent = opts.quiet
+        ? undefined
+        : (event) => {
+            const icon = STATUS_ICONS[event.type] ?? ' ';
+            const label = event.nodeType ? `${event.nodeId} (${event.nodeType})` : event.nodeId;
+            if (dashboard)
+                dashboard.broadcastExecution(event);
+            if (event.type === 'node-start') {
+                nodeTimings.set(event.nodeId, event.timestamp);
+                if (opts.verbose)
+                    console.log(`  ${icon} ${label}`);
+            }
+            else if (event.type === 'node-complete') {
+                const start = nodeTimings.get(event.nodeId);
+                const dur = start ? ` ${formatDuration(event.timestamp - start)}` : '';
+                console.log(`  ${icon} ${label}${dur}`);
+            }
+            else if (event.type === 'node-error') {
+                console.log(`  ${icon} ${label}: ${event.error ?? 'unknown error'}`);
+            }
+        };
+    const startTime = Date.now();
+    if (!opts.quiet) {
+        console.log(`[weaver] Bot: ${opts.botTask.slice(0, 80)}`);
+    }
+    try {
+        const result = await runWorkflow(workflowPath, {
+            params: { taskJson: JSON.stringify(task), projectDir: opts.file ?? process.cwd() },
+            verbose: opts.verbose,
+            dryRun: opts.dryRun,
+            config,
+            onEvent,
+            onNotificationError: (channel, _event, error) => {
+                console.error(`[weaver] Notification error (${channel}): ${error}`);
+            },
+        });
+        const elapsed = formatDuration(Date.now() - startTime);
+        if (!opts.quiet) {
+            const color = result.success ? '\x1b[32m' : '\x1b[31m';
+            console.log(`\n${color}Bot: ${result.outcome}\x1b[0m (${elapsed})`);
+            console.log(`  ${result.summary}`);
+        }
+        if (dashboard) {
+            dashboard.broadcastWorkflowComplete(result.summary ?? '', result.success);
+            await dashboard.stop();
+        }
+        process.exit(result.success ? 0 : 1);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\x1b[31m[weaver] Fatal: ${msg}\x1b[0m`);
+        if (dashboard) {
+            dashboard.broadcastWorkflowError(msg);
+            await dashboard.stop();
+        }
+        process.exit(1);
+    }
+}
+export async function handleSession(opts) {
+    const packRoot = new URL('..', import.meta.url);
+    let workflowPath;
+    try {
+        workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot-session.ts', packRoot));
+        const { existsSync } = await import('node:fs');
+        if (!existsSync(workflowPath)) {
+            workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot-session.js', packRoot));
+        }
+    }
+    catch {
+        workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot-session.js', packRoot));
+    }
+    const config = await loadConfig(opts.configPath);
+    if (!opts.quiet) {
+        console.log('[weaver] Starting bot session (Ctrl+C to stop)');
+        console.log('[weaver] Add tasks with: flow-weaver weaver queue add "task"');
+    }
+    try {
+        const result = await runWorkflow(workflowPath, {
+            params: { projectDir: opts.file ?? process.cwd() },
+            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) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\x1b[31m[weaver] Fatal: ${msg}\x1b[0m`);
+        process.exit(1);
+    }
+}
+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]');
+        process.exit(1);
+    }
+    const command = {
+        command: subcommand,
+        payload: opts.botFile,
+        timestamp: Date.now(),
+    };
+    controller.write(command);
+    console.log(`[weaver] Steering command sent: ${subcommand}${opts.botFile ? ' "' + opts.botFile + '"' : ''}`);
+}
+export async function handleQueue(opts) {
+    const { TaskQueue } = await import('./bot/task-queue.js');
+    const queue = new TaskQueue();
+    const action = opts.botTask;
+    if (!action || !['add', 'list', 'clear', 'remove'].includes(action)) {
+        console.error('[weaver] Usage: flow-weaver weaver queue <add|list|clear|remove> [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 id = queue.add({ instruction, priority: 0 });
+            console.log(`[weaver] Task added: ${id}`);
+            break;
+        }
+        case 'list': {
+            const tasks = queue.list();
+            if (tasks.length === 0) {
+                console.log('No tasks in queue.');
+            }
+            else {
+                console.log('ID'.padEnd(10) + 'STATUS'.padEnd(12) + 'INSTRUCTION');
+                for (const t of tasks) {
+                    console.log(t.id.padEnd(10) + t.status.padEnd(12) + t.instruction.slice(0, 60));
+                }
+            }
+            break;
+        }
+        case 'clear': {
+            const count = queue.clear();
+            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);
+            }
+            const removed = queue.remove(id);
+            console.log(removed ? `Removed task ${id}.` : `No task found with id "${id}".`);
+            break;
+        }
+    }
+}
+//# sourceMappingURL=cli-handlers.js.map