@supaku/agentfactory-cli 0.2.0 → 0.4.0

package/dist/src/orchestrator.d.ts

@@ -2,7 +2,7 @@
 /**
  * AgentFactory Orchestrator CLI
  *
- * Local script to spawn concurrent coding agents on backlog issues.
+ * Thin wrapper around the orchestrator runner.
  *
  * Usage:
  *   af-orchestrator [options]

package/dist/src/orchestrator.js

@@ -2,7 +2,7 @@
 /**
  * AgentFactory Orchestrator CLI
  *
- * Local script to spawn concurrent coding agents on backlog issues.
+ * Thin wrapper around the orchestrator runner.
  *
  * Usage:
  *   af-orchestrator [options]
@@ -18,22 +18,10 @@
  *   LINEAR_API_KEY      Required API key for Linear authentication
  */
 import path from 'path';
-import { execSync } from 'child_process';
 import { config } from 'dotenv';
 // Load environment variables from .env.local
 config({ path: path.resolve(process.cwd(), '.env.local') });
-import { createOrchestrator } from '@supaku/agentfactory';
-function getGitRoot() {
-    try {
-        return execSync('git rev-parse --show-toplevel', {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-    }
-    catch {
-        return process.cwd();
-    }
-}
+import { runOrchestrator } from './lib/orchestrator-runner.js';
 function parseArgs() {
     const args = process.argv.slice(2);
     const result = {
@@ -98,18 +86,6 @@ Examples:
   af-orchestrator --project MyProject --dry-run
 `);
 }
-function formatDuration(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-    }
-    if (minutes > 0) {
-        return `${minutes}m ${seconds % 60}s`;
-    }
-    return `${seconds}s`;
-}
 async function main() {
     const args = parseArgs();
     if (!process.env.LINEAR_API_KEY) {
@@ -122,95 +98,43 @@ async function main() {
     console.log(`Max concurrent: ${args.max}`);
     console.log(`Dry run: ${args.dryRun}`);
     console.log('');
-    const gitRoot = getGitRoot();
-    const orchestrator = createOrchestrator({
-        project: args.project,
-        maxConcurrent: args.max,
-        worktreePath: path.resolve(gitRoot, '.worktrees'),
-    }, {
-        onIssueSelected: (issue) => {
-            console.log(`Selected: ${issue.identifier} - ${issue.title}`);
-            console.log(`  URL: ${issue.url}`);
-            console.log(`  Labels: ${issue.labels.join(', ') || 'none'}`);
-        },
-        onAgentStart: (agent) => {
-            console.log(`Agent started: ${agent.identifier} (PID: ${agent.pid})`);
-            console.log(`  Worktree: ${agent.worktreePath}`);
-        },
-        onAgentComplete: (agent) => {
-            const duration = agent.completedAt
-                ? formatDuration(agent.completedAt.getTime() - agent.startedAt.getTime())
-                : 'unknown';
-            console.log(`Agent completed: ${agent.identifier} (${duration})`);
-        },
-        onAgentError: (agent, error) => {
-            console.error(`Agent failed: ${agent.identifier}`);
-            console.error(`  Error: ${error.message}`);
-        },
-        onAgentIncomplete: (agent) => {
-            const duration = agent.completedAt
-                ? formatDuration(agent.completedAt.getTime() - agent.startedAt.getTime())
-                : 'unknown';
-            console.warn(`Agent incomplete: ${agent.identifier} (${duration})`);
-            console.warn(`  Reason: ${agent.incompleteReason ?? 'unknown'}`);
-            console.warn(`  Worktree preserved: ${agent.worktreePath}`);
-        },
-    });
-    try {
-        if (args.single) {
-            console.log(`Processing single issue: ${args.single}`);
-            if (args.dryRun) {
-                console.log('[DRY RUN] Would spawn agent for:', args.single);
-                return;
-            }
-            await orchestrator.spawnAgentForIssue(args.single);
-            console.log(`Agent spawned for ${args.single}`);
-            if (args.wait) {
-                console.log('Waiting for agent to complete...');
-                await orchestrator.waitForAll();
-            }
-            return;
-        }
+    if (args.single) {
+        console.log(`Processing single issue: ${args.single}`);
         if (args.dryRun) {
-            const issues = await orchestrator.getBacklogIssues();
-            if (issues.length === 0) {
-                console.log('No backlog issues found');
-                return;
-            }
-            console.log(`[DRY RUN] Would process ${issues.length} issue(s):`);
-            for (const issue of issues) {
-                console.log(`  - ${issue.identifier}: ${issue.title}`);
-                console.log(`    Priority: ${issue.priority || 'none'}`);
-                console.log(`    Labels: ${issue.labels.join(', ') || 'none'}`);
-            }
+            console.log('[DRY RUN] Would spawn agent for:', args.single);
             return;
         }
-        const result = await orchestrator.run();
-        console.log('');
-        console.log('Orchestrator started');
-        console.log(`  Agents spawned: ${result.agents.length}`);
-        console.log(`  Errors: ${result.errors.length}`);
-        if (result.errors.length > 0) {
+    }
+    try {
+        const result = await runOrchestrator({
+            linearApiKey: process.env.LINEAR_API_KEY,
+            project: args.project,
+            max: args.max,
+            single: args.single,
+            wait: args.wait,
+            dryRun: args.dryRun,
+        });
+        if (!args.single && !args.dryRun) {
             console.log('');
-            console.log('Errors:');
-            for (const { issueId, error } of result.errors) {
-                console.log(`  ${issueId}: ${error.message}`);
+            console.log('Orchestrator started');
+            console.log(`  Agents spawned: ${result.agentsSpawned}`);
+            console.log(`  Errors: ${result.errors.length}`);
+            if (result.errors.length > 0) {
+                console.log('');
+                console.log('Errors:');
+                for (const { issueId, error } of result.errors) {
+                    console.log(`  ${issueId}: ${error.message}`);
+                }
             }
         }
-        if (args.wait && result.agents.length > 0) {
-            console.log('');
-            console.log('Waiting for all agents to complete...');
-            process.on('SIGINT', () => {
-                console.log('');
-                console.log('Received SIGINT, stopping agents...');
-                orchestrator.stopAll();
-                process.exit(1);
-            });
-            const completedAgents = await orchestrator.waitForAll();
+        if (args.single) {
+            console.log(`Agent spawned for ${args.single}`);
+        }
+        if (args.wait && result.completed.length > 0) {
             console.log('');
             console.log('All agents completed');
             console.log('Results:');
-            for (const agent of completedAgents) {
+            for (const agent of result.completed) {
                 const duration = agent.completedAt
                     ? formatDuration(agent.completedAt.getTime() - agent.startedAt.getTime())
                     : 'unknown';
@@ -224,6 +148,18 @@ async function main() {
         process.exit(1);
     }
 }
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+}
 main().catch((error) => {
     console.error('Fatal error:', error);
     process.exit(1);

package/dist/src/queue-admin.d.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /**
- * AgentFactory Queue Admin
+ * AgentFactory Queue Admin CLI
  *
- * Manage the Redis work queue, sessions, claims, and workers.
+ * Thin wrapper around the queue-admin runner. Handles dotenv, arg parsing,
+ * and process.exit so the runner stays process-agnostic.
  *
  * Usage:
  *   af-queue-admin <command>

package/dist/src/queue-admin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue-admin.d.ts","sourceRoot":"","sources":["../../src/queue-admin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;GAoBG"}
+{"version":3,"file":"queue-admin.d.ts","sourceRoot":"","sources":["../../src/queue-admin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/src/queue-admin.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /**
- * AgentFactory Queue Admin
+ * AgentFactory Queue Admin CLI
  *
- * Manage the Redis work queue, sessions, claims, and workers.
+ * Thin wrapper around the queue-admin runner. Handles dotenv, arg parsing,
+ * and process.exit so the runner stays process-agnostic.
  *
  * Usage:
  *   af-queue-admin <command>
@@ -24,329 +25,10 @@ import path from 'path';
 import { config } from 'dotenv';
 // Load environment variables from .env.local in CWD
 config({ path: path.resolve(process.cwd(), '.env.local') });
-import { getRedisClient, redisKeys, redisDel, redisGet, redisSet, redisZRangeByScore, redisHGetAll, disconnectRedis, } from '@supaku/agentfactory-server';
-// Redis key constants
-const WORK_QUEUE_KEY = 'work:queue';
-const WORK_ITEMS_KEY = 'work:items';
-const WORK_CLAIM_PREFIX = 'work:claim:';
-const SESSION_KEY_PREFIX = 'agent:session:';
-const WORKER_PREFIX = 'work:worker:';
-// ANSI colors
-const C = {
-    reset: '\x1b[0m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    cyan: '\x1b[36m',
-    gray: '\x1b[90m',
-};
-function ensureRedis() {
-    if (!process.env.REDIS_URL) {
-        console.error(`${C.red}Error: REDIS_URL not set${C.reset}`);
-        process.exit(1);
-    }
-    // Initialize the Redis client
-    getRedisClient();
-}
-async function listQueue() {
-    ensureRedis();
-    // Get items from sorted set (current queue format)
-    const queuedSessionIds = await redisZRangeByScore(WORK_QUEUE_KEY, '-inf', '+inf');
-    const workItems = await redisHGetAll(WORK_ITEMS_KEY);
-    const workItemCount = Object.keys(workItems).length;
-    console.log(`\n${C.cyan}Work Queue${C.reset} (${Math.max(queuedSessionIds.length, workItemCount)} items):`);
-    console.log('='.repeat(60));
-    if (workItemCount === 0 && queuedSessionIds.length === 0) {
-        console.log('(empty)');
-    }
-    else {
-        for (const [sessionId, itemJson] of Object.entries(workItems)) {
-            try {
-                const work = JSON.parse(itemJson);
-                console.log(`- ${work.issueIdentifier ?? sessionId.slice(0, 8)} (session: ${sessionId.slice(0, 8)}...)`);
-                console.log(`  Priority: ${work.priority ?? 'none'}, WorkType: ${work.workType ?? 'development'}`);
-                if (work.queuedAt) {
-                    console.log(`  Queued: ${new Date(work.queuedAt).toISOString()}`);
-                }
-                if (work.claudeSessionId) {
-                    console.log(`  ${C.yellow}Has claudeSessionId: ${work.claudeSessionId.substring(0, 12)}${C.reset}`);
-                }
-                if (work.prompt) {
-                    console.log(`  Prompt: "${work.prompt.slice(0, 50)}..."`);
-                }
-            }
-            catch {
-                console.log(`- [invalid JSON]: ${sessionId}`);
-            }
-        }
-    }
-    await disconnectRedis();
-}
-async function listSessions() {
-    ensureRedis();
-    const keys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
-    console.log(`\n${C.cyan}Sessions${C.reset} (${keys.length} total):`);
-    console.log('='.repeat(60));
-    if (keys.length === 0) {
-        console.log('(none)');
-    }
-    else {
-        for (const key of keys) {
-            const session = await redisGet(key);
-            if (session) {
-                const statusColors = {
-                    pending: C.yellow,
-                    claimed: C.cyan,
-                    running: C.cyan,
-                    completed: C.green,
-                    failed: C.red,
-                    stopped: C.yellow,
-                };
-                const statusColor = statusColors[session.status] || '';
-                console.log(`- ${session.issueIdentifier || session.issueId.slice(0, 8)} [${statusColor}${session.status}${C.reset}]`);
-                console.log(`  Session: ${session.linearSessionId.slice(0, 12)}...`);
-                if (session.workType) {
-                    console.log(`  WorkType: ${session.workType}`);
-                }
-                console.log(`  Updated: ${new Date(session.updatedAt * 1000).toISOString()}`);
-                if (session.workerId) {
-                    console.log(`  Worker: ${session.workerId}`);
-                }
-            }
-        }
-    }
-    await disconnectRedis();
-}
-async function listWorkersFn() {
-    ensureRedis();
-    const keys = await redisKeys(`${WORKER_PREFIX}*`);
-    console.log(`\n${C.cyan}Workers${C.reset} (${keys.length} total):`);
-    console.log('='.repeat(60));
-    if (keys.length === 0) {
-        console.log('(none)');
-    }
-    else {
-        for (const key of keys) {
-            const worker = await redisGet(key);
-            if (worker) {
-                const statusColor = worker.status === 'active' ? C.green : C.yellow;
-                console.log(`- ${worker.id.slice(0, 12)} [${statusColor}${worker.status}${C.reset}]`);
-                if (worker.hostname) {
-                    console.log(`  Hostname: ${worker.hostname}`);
-                }
-                console.log(`  Capacity: ${worker.activeCount ?? 0}/${worker.capacity ?? '?'}`);
-                if (worker.lastHeartbeat) {
-                    const ago = Math.round((Date.now() - worker.lastHeartbeat) / 1000);
-                    console.log(`  Last heartbeat: ${ago}s ago`);
-                }
-            }
-        }
-    }
-    await disconnectRedis();
-}
-async function clearClaims() {
-    ensureRedis();
-    console.log('Clearing work claims...');
-    const claimKeys = await redisKeys(`${WORK_CLAIM_PREFIX}*`);
-    console.log(`Found ${claimKeys.length} claim(s)`);
-    if (claimKeys.length === 0) {
-        console.log('No claims to clear');
-        await disconnectRedis();
-        return;
-    }
-    let deleted = 0;
-    for (const key of claimKeys) {
-        const result = await redisDel(key);
-        if (result > 0) {
-            console.log(`  Deleted: ${key}`);
-            deleted++;
-        }
-    }
-    console.log(`\nCleared ${deleted} claim(s)`);
-    await disconnectRedis();
-}
-async function clearQueue() {
-    ensureRedis();
-    console.log('Clearing work queue...');
-    const queuedSessionIds = await redisZRangeByScore(WORK_QUEUE_KEY, '-inf', '+inf');
-    console.log(`Found ${queuedSessionIds.length} item(s) in queue sorted set`);
-    const workItems = await redisHGetAll(WORK_ITEMS_KEY);
-    const workItemCount = Object.keys(workItems).length;
-    console.log(`Found ${workItemCount} item(s) in work items hash`);
-    // Show what we're clearing
-    for (const [sessionId, itemJson] of Object.entries(workItems)) {
-        try {
-            const work = JSON.parse(itemJson);
-            console.log(`  - ${work.issueIdentifier ?? sessionId.slice(0, 8)} (workType: ${work.workType || 'development'})`);
-            if (work.claudeSessionId) {
-                console.log(`    ${C.yellow}Has claudeSessionId: ${work.claudeSessionId.substring(0, 12)}${C.reset}`);
-            }
-        }
-        catch {
-            console.log(`  - [invalid JSON]: ${sessionId}`);
-        }
-    }
-    let cleared = 0;
-    if (queuedSessionIds.length > 0) {
-        await redisDel(WORK_QUEUE_KEY);
-        cleared++;
-    }
-    if (workItemCount > 0) {
-        await redisDel(WORK_ITEMS_KEY);
-        cleared++;
-    }
-    const totalItems = Math.max(queuedSessionIds.length, workItemCount);
-    if (cleared > 0) {
-        console.log(`\nCleared ${totalItems} item(s) from work queue`);
-    }
-    else {
-        console.log('\nQueue was already empty');
-    }
-    await disconnectRedis();
-}
-async function clearAll() {
-    ensureRedis();
-    console.log('Clearing ALL state...\n');
-    // Clear work queue
-    const queuedSessionIds = await redisZRangeByScore(WORK_QUEUE_KEY, '-inf', '+inf');
-    const workItems = await redisHGetAll(WORK_ITEMS_KEY);
-    if (queuedSessionIds.length > 0)
-        await redisDel(WORK_QUEUE_KEY);
-    if (Object.keys(workItems).length > 0)
-        await redisDel(WORK_ITEMS_KEY);
-    console.log(`Cleared ${Math.max(queuedSessionIds.length, Object.keys(workItems).length)} queue items`);
-    // Clear all sessions
-    const sessionKeys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
-    for (const key of sessionKeys) {
-        await redisDel(key);
-    }
-    console.log(`Cleared ${sessionKeys.length} sessions`);
-    // Clear all claims
-    const claimKeys = await redisKeys(`${WORK_CLAIM_PREFIX}*`);
-    for (const key of claimKeys) {
-        await redisDel(key);
-    }
-    console.log(`Cleared ${claimKeys.length} claims`);
-    // Clear all workers
-    const workerKeys = await redisKeys(`${WORKER_PREFIX}*`);
-    for (const key of workerKeys) {
-        await redisDel(key);
-    }
-    console.log(`Cleared ${workerKeys.length} worker registrations`);
-    console.log('\nAll cleared!');
-    await disconnectRedis();
-}
-async function resetWorkState() {
-    ensureRedis();
-    console.log('Resetting work state...');
-    console.log('-'.repeat(60));
-    let totalCleared = 0;
-    // 1. Clear work claims
-    console.log('\nClearing work claims...');
-    const claimKeys = await redisKeys(`${WORK_CLAIM_PREFIX}*`);
-    console.log(`  Found ${claimKeys.length} claim(s)`);
-    for (const key of claimKeys) {
-        const result = await redisDel(key);
-        if (result > 0) {
-            console.log(`  Deleted: ${key}`);
-            totalCleared++;
-        }
-    }
-    // 2. Clear work queue
-    console.log('\nClearing work queue...');
-    const queuedSessionIds = await redisZRangeByScore(WORK_QUEUE_KEY, '-inf', '+inf');
-    console.log(`  Found ${queuedSessionIds.length} queued item(s) in sorted set`);
-    const workItems = await redisHGetAll(WORK_ITEMS_KEY);
-    const workItemCount = Object.keys(workItems).length;
-    console.log(`  Found ${workItemCount} item(s) in work items hash`);
-    for (const [sessionId, itemJson] of Object.entries(workItems)) {
-        try {
-            const work = JSON.parse(itemJson);
-            console.log(`  - ${work.issueIdentifier ?? sessionId.slice(0, 8)} (workType: ${work.workType || 'development'})`);
-        }
-        catch {
-            console.log(`  - [invalid item: ${sessionId}]`);
-        }
-    }
-    if (queuedSessionIds.length > 0 || workItemCount > 0) {
-        await redisDel(WORK_QUEUE_KEY);
-        await redisDel(WORK_ITEMS_KEY);
-        totalCleared += Math.max(queuedSessionIds.length, workItemCount);
-        console.log(`  Cleared queue and items hash`);
-    }
-    // 3. Reset stuck sessions
-    console.log('\nResetting stuck sessions...');
-    const sessionKeys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
-    console.log(`  Found ${sessionKeys.length} session(s)`);
-    let sessionsReset = 0;
-    for (const key of sessionKeys) {
-        const session = await redisGet(key);
-        if (!session)
-            continue;
-        if (session.status === 'running' || session.status === 'claimed') {
-            console.log(`  Resetting: ${session.issueIdentifier || session.linearSessionId}`);
-            console.log(`    Status: ${session.status}, WorkerId: ${session.workerId || 'none'}`);
-            const updated = {
-                ...session,
-                status: 'pending',
-                workerId: undefined,
-                claimedAt: undefined,
-                claudeSessionId: undefined,
-                updatedAt: Math.floor(Date.now() / 1000),
-            };
-            await redisSet(key, updated, 24 * 60 * 60);
-            sessionsReset++;
-            console.log(`    Reset to pending`);
-        }
-    }
-    console.log('\n' + '-'.repeat(60));
-    console.log(`\nReset complete:`);
-    console.log(`   - Claims cleared: ${claimKeys.length}`);
-    console.log(`   - Queue items cleared: ${Math.max(queuedSessionIds.length, workItemCount)}`);
-    console.log(`   - Sessions reset: ${sessionsReset}`);
-    await disconnectRedis();
-}
-async function removeSession(sessionId) {
-    ensureRedis();
-    let found = false;
-    // Find session by partial ID match
-    const keys = await redisKeys(`${SESSION_KEY_PREFIX}*`);
-    for (const key of keys) {
-        if (key.includes(sessionId)) {
-            await redisDel(key);
-            console.log(`Removed session: ${key.replace(SESSION_KEY_PREFIX, '')}`);
-            found = true;
-        }
-    }
-    // Also remove from queue if present
-    const workItems = await redisHGetAll(WORK_ITEMS_KEY);
-    for (const [sid, itemJson] of Object.entries(workItems)) {
-        if (sid.includes(sessionId)) {
-            // Remove from hash via direct Redis command
-            const redis = getRedisClient();
-            await redis.hdel(WORK_ITEMS_KEY, sid);
-            // Remove from sorted set
-            const { redisZRem } = await import('@supaku/agentfactory-server');
-            await redisZRem(WORK_QUEUE_KEY, sid);
-            const work = JSON.parse(itemJson);
-            console.log(`Removed from queue: ${work.issueIdentifier ?? sid.slice(0, 8)}`);
-            found = true;
-        }
-    }
-    // Remove claim if present
-    const claimKeys = await redisKeys(`${WORK_CLAIM_PREFIX}*`);
-    for (const key of claimKeys) {
-        if (key.includes(sessionId)) {
-            await redisDel(key);
-            console.log(`Removed claim: ${key}`);
-            found = true;
-        }
-    }
-    if (!found) {
-        console.log(`No session found matching: ${sessionId}`);
-    }
-    await disconnectRedis();
-}
+import { runQueueAdmin, C } from './lib/queue-admin-runner.js';
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
 function printUsage() {
     console.log(`
 ${C.cyan}AgentFactory Queue Admin${C.reset} - Manage Redis work queue and sessions
@@ -372,45 +54,41 @@ ${C.yellow}Examples:${C.reset}
   af-queue-admin remove abc123
 `);
 }
+// ---------------------------------------------------------------------------
+// Valid commands
+// ---------------------------------------------------------------------------
+const VALID_COMMANDS = new Set([
+    'list',
+    'sessions',
+    'workers',
+    'clear-claims',
+    'clear-queue',
+    'clear-all',
+    'reset',
+    'remove',
+]);
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
 async function main() {
     const command = process.argv[2];
     const arg = process.argv[3];
-    switch (command) {
-        case 'list':
-            await listQueue();
-            break;
-        case 'sessions':
-            await listSessions();
-            break;
-        case 'workers':
-            await listWorkersFn();
-            break;
-        case 'clear-claims':
-            await clearClaims();
-            break;
-        case 'clear-queue':
-            await clearQueue();
-            break;
-        case 'clear-all':
-            await clearAll();
-            break;
-        case 'reset':
-            await resetWorkState();
-            break;
-        case 'remove':
-            if (!arg) {
-                console.error('Usage: af-queue-admin remove <session-id>');
-                process.exit(1);
-            }
-            await removeSession(arg);
-            break;
-        case '--help':
-        case '-h':
-        case 'help':
-        default:
-            printUsage();
-            break;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        printUsage();
+        return;
+    }
+    if (!VALID_COMMANDS.has(command)) {
+        printUsage();
+        return;
+    }
+    if (command === 'remove' && !arg) {
+        console.error('Usage: af-queue-admin remove <session-id>');
+        process.exit(1);
     }
+    await runQueueAdmin({
+        command: command,
+        sessionId: arg,
+    });
 }
 main().catch((error) => {
     console.error('Error:', error instanceof Error ? error.message : error);

package/dist/src/worker-fleet.d.ts

@@ -3,7 +3,7 @@
  * AgentFactory Worker Fleet Manager
  *
  * Spawns and manages multiple worker processes for parallel agent execution.
- * Each worker runs as a separate process with its own resources.
+ * Thin wrapper around the programmatic runner in ./lib/worker-fleet-runner.js.
  *
  * Usage:
  *   af-worker-fleet [options]