@fractary/faber-cli 1.5.31 → 1.5.34

package/dist/commands/workflow/index.d.ts

@@ -44,4 +44,12 @@ export declare function createWorkflowInspectCommand(): Command;
  * Create the workflow-debug command
  */
 export declare function createWorkflowDebugCommand(): Command;
+/**
+ * Create the workflow-batch-plan command
+ */
+export declare function createBatchPlanCommand(): Command;
+/**
+ * Create the workflow-batch-run command
+ */
+export declare function createBatchRunCommand(): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAkD1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAiF7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAoB5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA8B9C;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAoCrD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CA4BrD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CA0CtD;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAkDpD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAsJ1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAiF7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAoB5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA8B9C;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAoCrD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CA4BrD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CA0CtD;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAkDpD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAchD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAgB/C"}

package/dist/commands/workflow/index.js

@@ -12,46 +12,138 @@ import { parsePositiveInteger } from '../../utils/validation.js';
  */
 export function createRunCommand() {
     return new Command('workflow-run')
-        .description('Run FABER workflow')
-        .requiredOption('--work-id <id>', 'Work item ID to process')
+        .description('Run FABER workflow (supports comma-separated work IDs for batch execution)')
+        .requiredOption('--work-id <ids>', 'Work item ID(s) to process (comma-separated for batch, e.g., "258,259,260")')
         .option('--autonomy <level>', 'Autonomy level: supervised|assisted|autonomous', 'supervised')
+        .option('--phase <phases>', 'Execute only specified phase(s) - comma-separated')
+        .option('--force-new', 'Force fresh start, bypass auto-resume')
+        .option('--resume-batch', 'Resume a previously interrupted batch')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
         try {
-            const workflow = new FaberWorkflow();
-            if (!options.json) {
-                console.log(chalk.blue(`Starting FABER workflow for work item #${options.workId}`));
-                console.log(chalk.gray(`Autonomy: ${options.autonomy}`));
-            }
-            // Add event listener for progress updates
-            workflow.addEventListener((event, data) => {
-                if (options.json)
-                    return;
-                switch (event) {
-                    case 'phase:start':
-                        console.log(chalk.cyan(`\n→ Starting phase: ${String(data.phase || '').toUpperCase()}`));
-                        break;
-                    case 'phase:complete':
-                        console.log(chalk.green(`  ✓ Completed phase: ${data.phase}`));
-                        break;
-                    case 'workflow:fail':
-                    case 'phase:fail':
-                        console.error(chalk.red(`  ✗ Error: ${data.error || 'Unknown error'}`));
-                        break;
+            const workIds = options.workId.split(',').map((id) => id.trim()).filter(Boolean);
+            const isBatch = workIds.length > 1;
+            if (isBatch) {
+                // Batch mode: sequential execution
+                if (!options.json) {
+                    console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+                    console.log(chalk.blue.bold('  BATCH MODE: Sequential Multi-Workflow Execution'));
+                    console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+                    console.log(chalk.gray(`Work IDs: ${workIds.join(', ')}`));
+                    console.log(chalk.gray(`Autonomy: ${options.autonomy}`));
+                    if (options.phase)
+                        console.log(chalk.gray(`Phases: ${options.phase}`));
+                    console.log(chalk.gray(`Total workflows: ${workIds.length}`));
+                    console.log('');
+                }
+                const results = [];
+                for (let i = 0; i < workIds.length; i++) {
+                    const workId = workIds[i];
+                    if (!options.json) {
+                        console.log(chalk.blue(`\n═══ Workflow ${i + 1}/${workIds.length}: #${workId} ═══`));
+                    }
+                    try {
+                        const workflow = new FaberWorkflow();
+                        workflow.addEventListener((event, data) => {
+                            if (options.json)
+                                return;
+                            switch (event) {
+                                case 'phase:start':
+                                    console.log(chalk.cyan(`\n→ Starting phase: ${String(data.phase || '').toUpperCase()}`));
+                                    break;
+                                case 'phase:complete':
+                                    console.log(chalk.green(`  ✓ Completed phase: ${data.phase}`));
+                                    break;
+                                case 'workflow:fail':
+                                case 'phase:fail':
+                                    console.error(chalk.red(`  ✗ Error: ${data.error || 'Unknown error'}`));
+                                    break;
+                            }
+                        });
+                        const result = await workflow.run({
+                            workId,
+                            autonomy: options.autonomy,
+                            phase: options.phase,
+                            forceNew: options.forceNew,
+                        });
+                        results.push({ workId, status: result.status });
+                        if (!options.json) {
+                            console.log(chalk.green(`✓ Workflow ${i + 1}/${workIds.length} completed: #${workId}`));
+                        }
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        results.push({ workId, status: 'failed', error: message });
+                        if (!options.json) {
+                            console.error(chalk.red(`✗ Workflow ${i + 1}/${workIds.length} FAILED: #${workId}`));
+                            console.error(chalk.red(`  Error: ${message}`));
+                            console.error(chalk.yellow('\nBatch stopped due to error. Remaining workflows not executed.'));
+                        }
+                        break; // Stop batch on error
+                    }
+                }
+                // Batch summary
+                if (options.json) {
+                    console.log(JSON.stringify({ status: 'success', data: { batch: true, results } }, null, 2));
+                }
+                else {
+                    const completed = results.filter(r => r.status !== 'failed');
+                    const failed = results.filter(r => r.status === 'failed');
+                    console.log(chalk.blue.bold('\n═══════════════════════════════════════════════'));
+                    console.log(chalk.blue.bold('  BATCH COMPLETE'));
+                    console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+                    console.log(`Total: ${workIds.length} | Completed: ${completed.length} | Failed: ${failed.length}`);
+                    for (const r of results) {
+                        if (r.status === 'failed') {
+                            console.log(chalk.red(`  ✗ #${r.workId} — ${r.error}`));
+                        }
+                        else {
+                            console.log(chalk.green(`  ✓ #${r.workId} — ${r.status}`));
+                        }
+                    }
+                }
+                if (results.some(r => r.status === 'failed')) {
+                    process.exit(1);
                 }
-            });
-            const result = await workflow.run({
-                workId: options.workId,
-                autonomy: options.autonomy,
-            });
-            if (options.json) {
-                console.log(JSON.stringify({ status: 'success', data: result }, null, 2));
             }
             else {
-                console.log(chalk.green(`\n✓ Workflow ${result.status}`));
-                console.log(chalk.gray(`  Workflow ID: ${result.workflow_id}`));
-                console.log(chalk.gray(`  Duration: ${result.duration_ms}ms`));
-                console.log(chalk.gray(`  Phases: ${result.phases.map((p) => p.phase).join(' → ')}`));
+                // Single mode: original behavior
+                const workflow = new FaberWorkflow();
+                if (!options.json) {
+                    console.log(chalk.blue(`Starting FABER workflow for work item #${workIds[0]}`));
+                    console.log(chalk.gray(`Autonomy: ${options.autonomy}`));
+                }
+                workflow.addEventListener((event, data) => {
+                    if (options.json)
+                        return;
+                    switch (event) {
+                        case 'phase:start':
+                            console.log(chalk.cyan(`\n→ Starting phase: ${String(data.phase || '').toUpperCase()}`));
+                            break;
+                        case 'phase:complete':
+                            console.log(chalk.green(`  ✓ Completed phase: ${data.phase}`));
+                            break;
+                        case 'workflow:fail':
+                        case 'phase:fail':
+                            console.error(chalk.red(`  ✗ Error: ${data.error || 'Unknown error'}`));
+                            break;
+                    }
+                });
+                const result = await workflow.run({
+                    workId: workIds[0],
+                    autonomy: options.autonomy,
+                    phase: options.phase,
+                    forceNew: options.forceNew,
+                });
+                if (options.json) {
+                    console.log(JSON.stringify({ status: 'success', data: result }, null, 2));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ Workflow ${result.status}`));
+                    console.log(chalk.gray(`  Workflow ID: ${result.workflow_id}`));
+                    console.log(chalk.gray(`  Duration: ${result.duration_ms}ms`));
+                    console.log(chalk.gray(`  Phases: ${result.phases.map((p) => p.phase).join(' → ')}`));
+                }
             }
         }
         catch (error) {
@@ -437,6 +529,343 @@ export function createWorkflowDebugCommand() {
         }
     });
 }
+/**
+ * Create the workflow-batch-plan command
+ */
+export function createBatchPlanCommand() {
+    return new Command('workflow-batch-plan')
+        .description('Initialize a batch of workflows for sequential planning and unattended execution')
+        .requiredOption('--work-id <ids>', 'Comma-separated work item IDs (e.g., "258,259,260")')
+        .option('--name <batch-id>', 'Custom batch name/ID (default: auto-generated timestamp)')
+        .option('--autonomous', 'Continue on plan failures without prompting')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            await executeBatchPlanCommand(options);
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
+/**
+ * Create the workflow-batch-run command
+ */
+export function createBatchRunCommand() {
+    return new Command('workflow-batch-run')
+        .description('Execute a planned FABER batch sequentially with state tracking')
+        .requiredOption('--batch <batch-id>', 'Batch ID to execute (from workflow-batch-plan)')
+        .option('--autonomous', 'Auto-skip failed items without prompting (for overnight unattended runs)')
+        .option('--resume', 'Skip already-completed items (safe to re-run after interruption)')
+        .option('--phase <phases>', 'Execute only specified phase(s) - comma-separated')
+        .option('--force-new', 'Force fresh start for each item, bypass auto-resume')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            await executeBatchRunCommand(options);
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
+// ─── Batch Implementation ───────────────────────────────────────────────────
+import fs from 'fs/promises';
+import path from 'path';
+import { spawnSync } from 'child_process';
+function getBatchDir(batchId) {
+    return path.join(process.cwd(), '.fractary', 'faber', 'batches', batchId);
+}
+function generateBatchId() {
+    const now = new Date();
+    const ts = now.toISOString().replace(/:/g, '-').replace(/\.\d{3}Z$/, 'Z');
+    return `batch-${ts}`;
+}
+async function readBatchState(batchId) {
+    const statePath = path.join(getBatchDir(batchId), 'state.json');
+    const content = await fs.readFile(statePath, 'utf-8');
+    return JSON.parse(content);
+}
+async function writeBatchState(batchId, state) {
+    state.updated_at = new Date().toISOString();
+    const statePath = path.join(getBatchDir(batchId), 'state.json');
+    await fs.writeFile(statePath, JSON.stringify(state, null, 2));
+}
+async function executeBatchPlanCommand(options) {
+    const workIds = options.workId.split(',').map((id) => id.trim()).filter(Boolean);
+    if (workIds.length === 0) {
+        throw new Error('--work-id must contain at least one work item ID');
+    }
+    const batchId = options.name || generateBatchId();
+    const batchDir = getBatchDir(batchId);
+    const now = new Date().toISOString();
+    if (!options.json) {
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(chalk.blue.bold('  FABER BATCH PLAN'));
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(chalk.gray(`Batch ID: ${batchId}`));
+        console.log(chalk.gray(`Work IDs: ${workIds.join(', ')}`));
+        console.log(chalk.gray(`Items: ${workIds.length}`));
+        console.log('');
+    }
+    // Create batch directory
+    await fs.mkdir(batchDir, { recursive: true });
+    // Write queue.txt
+    const queueLines = [
+        '# FABER Batch Queue',
+        `# Batch ID: ${batchId}`,
+        `# Created: ${now}`,
+        '# Format: <work-id> [--workflow custom-workflow] [--phase build,evaluate]',
+        '',
+        ...workIds,
+    ];
+    await fs.writeFile(path.join(batchDir, 'queue.txt'), queueLines.join('\n'));
+    // Initialize state.json
+    const state = {
+        batch_id: batchId,
+        status: 'planning',
+        autonomous: options.autonomous ?? false,
+        created_at: now,
+        updated_at: now,
+        items: workIds.map((id) => ({
+            work_id: id,
+            status: 'pending',
+            plan_id: null,
+            run_id: null,
+            started_at: null,
+            completed_at: null,
+            skipped: false,
+            error: null,
+        })),
+    };
+    await writeBatchState(batchId, state);
+    if (!options.json) {
+        console.log(chalk.green(`✓ Batch created: ${batchId}`));
+        console.log(chalk.gray(`  Directory: ${batchDir}`));
+        console.log('');
+        console.log(chalk.cyan(`→ Planning ${workIds.length} item(s)...`));
+        console.log('');
+    }
+    // Plan each item
+    let planned = 0;
+    let failed = 0;
+    for (let i = 0; i < workIds.length; i++) {
+        const workId = workIds[i];
+        if (!options.json) {
+            console.log(chalk.blue(`[${i + 1}/${workIds.length}] Planning #${workId}...`));
+        }
+        try {
+            // Invoke the existing workflow-plan CLI command as a subprocess
+            const faberBin = process.argv[1];
+            const result = spawnSync(process.execPath, [faberBin, 'workflow-plan', '--work-id', workId, '--skip-confirm'], { stdio: options.json ? 'pipe' : 'inherit', encoding: 'utf-8' });
+            if (result.status !== 0) {
+                throw new Error(result.stderr || `workflow-plan exited with code ${result.status}`);
+            }
+            // Mark as planned
+            state.items[i].status = 'planned';
+            state.items[i].completed_at = new Date().toISOString();
+            await writeBatchState(batchId, state);
+            planned++;
+            if (!options.json) {
+                console.log(chalk.green(`  ✓ Planned: #${workId}`));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            state.items[i].status = 'plan_failed';
+            state.items[i].error = message;
+            state.items[i].completed_at = new Date().toISOString();
+            await writeBatchState(batchId, state);
+            failed++;
+            if (!options.json) {
+                console.error(chalk.red(`  ✗ Plan failed for #${workId}: ${message}`));
+            }
+        }
+    }
+    // Final state
+    state.status = failed === 0 ? 'planned' : 'planning_partial';
+    await writeBatchState(batchId, state);
+    if (options.json) {
+        console.log(JSON.stringify({
+            status: 'success',
+            data: { batch_id: batchId, total: workIds.length, planned, failed },
+        }, null, 2));
+    }
+    else {
+        console.log('');
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(chalk.blue.bold('  BATCH PLANNING COMPLETE'));
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(`Total: ${workIds.length} | Planned: ${planned} | Failed: ${failed}`);
+        console.log('');
+        console.log(chalk.cyan('To run this batch (unattended):'));
+        console.log(chalk.white(`  fractary-faber workflow-batch-run --batch ${batchId} --autonomous`));
+        console.log('');
+        console.log(chalk.cyan('Or in Claude Code:'));
+        console.log(chalk.white(`  /fractary-faber:workflow-batch-run --batch ${batchId} --autonomous`));
+    }
+}
+async function executeBatchRunCommand(options) {
+    const batchId = options.batch;
+    const batchDir = getBatchDir(batchId);
+    // Verify batch exists
+    try {
+        await fs.access(batchDir);
+    }
+    catch {
+        throw new Error(`Batch '${batchId}' not found.\nExpected: ${batchDir}\n\nCreate a batch first:\n  fractary-faber workflow-batch-plan --work-id <ids> --name ${batchId}`);
+    }
+    // Load state
+    let state = await readBatchState(batchId);
+    if (state.status === 'completed') {
+        if (options.json) {
+            console.log(JSON.stringify({ status: 'success', data: { batch_id: batchId, message: 'already completed', state } }, null, 2));
+        }
+        else {
+            console.log(chalk.green(`✓ Batch '${batchId}' already completed. Nothing to do.`));
+            const done = state.items.filter(i => i.status === 'completed').length;
+            console.log(chalk.gray(`  Completed: ${done}/${state.items.length}`));
+            console.log(chalk.gray('\nTo re-run, edit state.json and reset items to "pending".'));
+        }
+        return;
+    }
+    // Filter items to process
+    const toProcess = options.resume
+        ? state.items.filter(i => i.status !== 'completed' && i.status !== 'skipped')
+        : state.items.filter(i => i.status !== 'completed' && i.status !== 'skipped');
+    if (!options.json) {
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(chalk.blue.bold('  FABER BATCH RUN'));
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(chalk.gray(`Batch ID: ${batchId}`));
+        console.log(chalk.gray(`Mode: ${options.autonomous ? 'autonomous (unattended)' : 'interactive'}`));
+        if (options.resume) {
+            const completed = state.items.filter(i => i.status === 'completed').length;
+            console.log(chalk.gray(`Resume: ${completed}/${state.items.length} already completed`));
+        }
+        if (options.phase)
+            console.log(chalk.gray(`Phase filter: ${options.phase}`));
+        if (options.forceNew)
+            console.log(chalk.gray('Force new: yes'));
+        console.log(chalk.gray(`Remaining: ${toProcess.length} item(s)`));
+        console.log('');
+    }
+    const results = [];
+    for (let i = 0; i < toProcess.length; i++) {
+        const item = toProcess[i];
+        const workId = item.work_id;
+        const globalIndex = state.items.findIndex(s => s.work_id === workId);
+        if (!options.json) {
+            console.log(chalk.blue(`\n═══ Workflow ${i + 1}/${toProcess.length}: #${workId} ═══`));
+        }
+        // Mark in progress
+        state.items[globalIndex].status = 'in_progress';
+        state.items[globalIndex].started_at = new Date().toISOString();
+        await writeBatchState(batchId, state);
+        try {
+            const workflow = new FaberWorkflow();
+            workflow.addEventListener((event, data) => {
+                if (options.json)
+                    return;
+                switch (event) {
+                    case 'phase:start':
+                        console.log(chalk.cyan(`\n  → Phase: ${String(data.phase || '').toUpperCase()}`));
+                        break;
+                    case 'phase:complete':
+                        console.log(chalk.green(`  ✓ Phase: ${data.phase}`));
+                        break;
+                    case 'workflow:fail':
+                    case 'phase:fail':
+                        console.error(chalk.red(`  ✗ Error: ${data.error || 'Unknown error'}`));
+                        break;
+                }
+            });
+            const result = await workflow.run({
+                workId,
+                autonomy: options.autonomous ? 'autonomous' : 'guarded',
+                phase: options.phase,
+                forceNew: options.forceNew,
+            });
+            state.items[globalIndex].status = 'completed';
+            state.items[globalIndex].run_id = result.run_id || null;
+            state.items[globalIndex].completed_at = new Date().toISOString();
+            await writeBatchState(batchId, state);
+            results.push({ workId, status: 'completed' });
+            if (!options.json) {
+                console.log(chalk.green(`✓ Completed: #${workId}`));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            state.items[globalIndex].status = 'failed';
+            state.items[globalIndex].skipped = true;
+            state.items[globalIndex].error = message;
+            state.items[globalIndex].completed_at = new Date().toISOString();
+            await writeBatchState(batchId, state);
+            results.push({ workId, status: 'failed', error: message });
+            if (!options.json) {
+                console.error(chalk.red(`✗ Failed: #${workId} — ${message}`));
+            }
+            if (!options.autonomous) {
+                // Non-autonomous: stop on first failure
+                if (!options.json) {
+                    console.error(chalk.yellow('\nBatch stopped. Use --autonomous to auto-skip failures.'));
+                    console.error(chalk.gray(`Resume with: fractary-faber workflow-batch-run --batch ${batchId} --autonomous --resume`));
+                }
+                break;
+            }
+            // Autonomous: continue to next item
+            if (!options.json) {
+                console.log(chalk.yellow('  → Auto-skipping (autonomous mode). Continuing...'));
+            }
+        }
+    }
+    // Final state
+    const allCompleted = state.items.every(i => i.status === 'completed');
+    const anyFailed = state.items.some(i => i.status === 'failed');
+    state.status = allCompleted ? 'completed' : anyFailed ? 'completed_with_failures' : 'paused';
+    await writeBatchState(batchId, state);
+    if (options.json) {
+        const completed = state.items.filter(i => i.status === 'completed').length;
+        const failedCount = state.items.filter(i => i.status === 'failed').length;
+        console.log(JSON.stringify({
+            status: 'success',
+            data: { batch_id: batchId, total: state.items.length, completed, failed: failedCount, results },
+        }, null, 2));
+    }
+    else {
+        const completed = state.items.filter(i => i.status === 'completed').length;
+        const failedCount = state.items.filter(i => i.status === 'failed').length;
+        console.log('');
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(chalk.blue.bold('  BATCH RUN COMPLETE'));
+        console.log(chalk.blue.bold('═══════════════════════════════════════════════'));
+        console.log(`Total: ${state.items.length} | Completed: ${completed} | Failed: ${failedCount}`);
+        console.log('');
+        for (const item of state.items) {
+            if (item.status === 'completed') {
+                console.log(chalk.green(`  ✓ #${item.work_id} — completed`));
+            }
+            else if (item.status === 'failed') {
+                console.log(chalk.red(`  ✗ #${item.work_id} — failed: ${item.error}`));
+            }
+            else if (item.status === 'skipped') {
+                console.log(chalk.yellow(`  ○ #${item.work_id} — skipped`));
+            }
+            else {
+                console.log(chalk.gray(`  ○ #${item.work_id} — ${item.status}`));
+            }
+        }
+        if (failedCount > 0) {
+            console.log('');
+            console.log(chalk.cyan('To retry failed items:'));
+            console.log(chalk.white(`  fractary-faber workflow-batch-run --batch ${batchId} --autonomous --resume`));
+        }
+    }
+    if (anyFailed && !options.autonomous) {
+        process.exit(1);
+    }
+}
 // Helper functions
 function getStateColor(state) {
     switch (state) {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAsDxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAwDxC"}

package/dist/index.js

@@ -10,7 +10,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { createRunCommand, createStatusCommand, createResumeCommand, createPauseCommand, createRecoverCommand, createCleanupCommand, createWorkflowCreateCommand, createWorkflowUpdateCommand, createWorkflowInspectCommand, createWorkflowDebugCommand } from './commands/workflow/index.js';
+import { createRunCommand, createStatusCommand, createResumeCommand, createPauseCommand, createRecoverCommand, createCleanupCommand, createWorkflowCreateCommand, createWorkflowUpdateCommand, createWorkflowInspectCommand, createWorkflowDebugCommand, createBatchPlanCommand, createBatchRunCommand } from './commands/workflow/index.js';
 import { createSessionLoadCommand, createSessionSaveCommand } from './commands/session.js';
 import { createWorkCommand } from './commands/work/index.js';
 import { createRepoCommand } from './commands/repo/index.js';
@@ -53,6 +53,8 @@ export function createFaberCLI() {
     program.addCommand(createWorkflowUpdateCommand()); // workflow-update
     program.addCommand(createWorkflowInspectCommand()); // workflow-inspect
     program.addCommand(createWorkflowDebugCommand()); // workflow-debug
+    program.addCommand(createBatchPlanCommand()); // workflow-batch-plan
+    program.addCommand(createBatchRunCommand()); // workflow-batch-run
     program.addCommand(createSessionLoadCommand()); // session-load
     program.addCommand(createSessionSaveCommand()); // session-save
     // Subcommand trees

package/dist/lib/yaml-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yaml-config.d.ts","sourceRoot":"","sources":["../../src/lib/yaml-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,YAAY,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,WAAW,EACX,aAAa,EACb,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAgH3E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,iBAAsB,GAAG,aAAa,GAAG,IAAI,CAoDpF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI,CAkBN;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,UAAO,GAAG,MAAM,CAgD7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,QAAQ,GAAE,MAAsB,GAAG,MAAM,CAoDxE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAI/D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/D"}
+{"version":3,"file":"yaml-config.d.ts","sourceRoot":"","sources":["../../src/lib/yaml-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,YAAY,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,WAAW,EACX,aAAa,EACb,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAuH3E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,iBAAsB,GAAG,aAAa,GAAG,IAAI,CAoDpF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI,CAkBN;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,UAAO,GAAG,MAAM,CAgD7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,QAAQ,GAAE,MAAsB,GAAG,MAAM,CAoDxE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAI/D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/D"}

package/dist/lib/yaml-config.js

@@ -100,6 +100,13 @@ const unifiedConfigSchema = {
                     },
                     additionalProperties: false,
                 },
+                changelog: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                    },
+                    additionalProperties: false,
+                },
             },
             additionalProperties: false,
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fractary/faber-cli",
-  "version": "1.5.31",
+  "version": "1.5.34",
   "description": "FABER CLI - Command-line interface for FABER development toolkit",
   "main": "dist/index.js",
   "bin": {
@@ -37,8 +37,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@fractary/core": "^0.7.20",
-    "@fractary/faber": "^2.4.14",
+    "@fractary/core": "*",
+    "@fractary/faber": "*",
     "ajv": "^8.12.0",
     "chalk": "^5.0.0",
     "commander": "^12.0.0",