@covibes/zeroshot 1.0.1

package/cli/index.js

@@ -0,0 +1,3990 @@
+#!/usr/bin/env node
+
+/**
+ * zeroshot CLI
+ *
+ * Commands:
+ * - run: Start a multi-agent cluster
+ * - list: List all clusters and tasks
+ * - status: Get cluster/task status
+ * - logs: View cluster/task logs
+ * - stop: Stop a cluster gracefully
+ * - kill: Force kill a task or cluster
+ * - kill-all: Kill all running tasks and clusters
+ * - export: Export cluster conversation
+ */
+
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const chalk = require('chalk');
+const Orchestrator = require('../src/orchestrator');
+const { setupCompletion } = require('../lib/completion');
+const { parseChunk } = require('../lib/stream-json-parser');
+const {
+  loadSettings,
+  saveSettings,
+  validateSetting,
+  coerceValue,
+  DEFAULT_SETTINGS,
+} = require('../lib/settings');
+
+const program = new Command();
+
+// =============================================================================
+// GLOBAL ERROR HANDLERS - Prevent silent process death
+// =============================================================================
+// Track active cluster ID for cleanup on crash
+/** @type {string | null} */
+let activeClusterId = null;
+/** @type {import('../src/orchestrator') | null} */
+let orchestratorInstance = null;
+
+/**
+ * Handle fatal errors: log, cleanup cluster state, exit
+ * @param {string} type - 'uncaughtException' or 'unhandledRejection'
+ * @param {Error|unknown} error - The error that caused the crash
+ */
+function handleFatalError(type, error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorStack = error instanceof Error ? error.stack : '';
+
+  console.error(chalk.red(`\n${'='.repeat(80)}`));
+  console.error(chalk.red.bold(`🔴 FATAL: ${type}`));
+  console.error(chalk.red(`${'='.repeat(80)}`));
+  console.error(chalk.red(`Error: ${errorMessage}`));
+  if (errorStack) {
+    console.error(chalk.dim(errorStack));
+  }
+  console.error(chalk.red(`${'='.repeat(80)}\n`));
+
+  // Try to update cluster state to 'failed' before exiting
+  if (activeClusterId && orchestratorInstance) {
+    try {
+      console.error(chalk.yellow(`Attempting to mark cluster ${activeClusterId} as failed...`));
+      const cluster = orchestratorInstance.clusters.get(activeClusterId);
+      if (cluster) {
+        cluster.state = 'failed';
+        cluster.pid = null;
+        cluster.failureInfo = {
+          type,
+          error: errorMessage,
+          timestamp: Date.now(),
+        };
+        orchestratorInstance._saveClusters();
+        console.error(chalk.yellow(`Cluster ${activeClusterId} marked as failed.`));
+      }
+    } catch (cleanupErr) {
+      const errMsg = cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr);
+      console.error(chalk.red(`Failed to update cluster state: ${errMsg}`));
+    }
+  }
+
+  process.exit(1);
+}
+
+process.on('uncaughtException', (error) => {
+  handleFatalError('Uncaught Exception', error);
+});
+
+process.on('unhandledRejection', (reason) => {
+  handleFatalError('Unhandled Promise Rejection', reason);
+});
+// =============================================================================
+
+// Package root directory (for resolving default config paths)
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+/**
+ * Detect git repository root from current directory
+ * Critical for CWD propagation - agents must work in the target repo, not where CLI was invoked
+ * @returns {string} Git repo root, or process.cwd() if not in a git repo
+ */
+function detectGitRepoRoot() {
+  const { execSync } = require('child_process');
+  try {
+    const root = execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    return root;
+  } catch {
+    // Not in a git repo - use current directory
+    return process.cwd();
+  }
+}
+
+// Lazy-loaded orchestrator (quiet by default) - created on first use
+/** @type {import('../src/orchestrator') | null} */
+let _orchestrator = null;
+/**
+ * @returns {import('../src/orchestrator')}
+ */
+function getOrchestrator() {
+  if (!_orchestrator) {
+    _orchestrator = new Orchestrator({ quiet: true });
+  }
+  return _orchestrator;
+}
+
+/**
+ * @typedef {Object} TaskLogMessage
+ * @property {string} topic
+ * @property {string} sender
+ * @property {Object} content
+ * @property {number} timestamp
+ */
+
+/**
+ * Read task logs from zeroshot task log files for agents in a cluster
+ * Returns messages in cluster message format (topic, sender, content, timestamp)
+ * @param {Object} cluster - Cluster object from orchestrator
+ * @returns {TaskLogMessage[]} Messages from task logs
+ */
+function readAgentTaskLogs(cluster) {
+  /** @type {TaskLogMessage[]} */
+  const messages = [];
+  const zeroshotLogsDir = path.join(os.homedir(), '.claude-zeroshot', 'logs');
+
+  if (!fs.existsSync(zeroshotLogsDir)) {
+    return messages;
+  }
+
+  // Strategy 1: Find task IDs from AGENT_LIFECYCLE messages
+  const lifecycleMessages = cluster.messageBus.query({
+    cluster_id: cluster.id,
+    topic: 'AGENT_LIFECYCLE',
+  });
+
+  const taskIds = new Set(); // All task IDs we've found
+  for (const msg of lifecycleMessages) {
+    const taskId = msg.content?.data?.taskId;
+    if (taskId) {
+      taskIds.add(taskId);
+    }
+  }
+
+  // Strategy 2: Find task IDs from current agent state
+  for (const agent of cluster.agents) {
+    const state = agent.getState();
+    if (state.currentTaskId) {
+      taskIds.add(state.currentTaskId);
+    }
+  }
+
+  // Strategy 3: Scan for log files matching cluster start time (catch orphaned tasks)
+  // This handles the case where TASK_ID_ASSIGNED wasn't published to cluster DB
+  const clusterStartTime = cluster.createdAt;
+  const logFiles = fs.readdirSync(zeroshotLogsDir);
+
+  for (const logFile of logFiles) {
+    if (!logFile.endsWith('.log')) continue;
+    const taskId = logFile.replace(/\.log$/, '');
+
+    // Check file modification time - only include logs modified after cluster started
+    const logPath = path.join(zeroshotLogsDir, logFile);
+    try {
+      const stats = fs.statSync(logPath);
+      if (stats.mtimeMs >= clusterStartTime) {
+        taskIds.add(taskId);
+      }
+    } catch {
+      // Skip files we can't stat
+    }
+  }
+
+  // Read logs for all discovered tasks
+  for (const taskId of taskIds) {
+    const logPath = path.join(zeroshotLogsDir, `${taskId}.log`);
+    if (!fs.existsSync(logPath)) {
+      continue;
+    }
+
+    try {
+      const content = fs.readFileSync(logPath, 'utf8');
+      const lines = content.split('\n').filter((line) => line.trim());
+
+      // Try to match task to agent (best effort, may not find a match for orphaned tasks)
+      let matchedAgent = null;
+      for (const agent of cluster.agents) {
+        const state = agent.getState();
+        if (state.currentTaskId === taskId) {
+          matchedAgent = agent;
+          break;
+        }
+      }
+
+      // If no agent match, try to infer from lifecycle messages
+      if (!matchedAgent) {
+        for (const msg of lifecycleMessages) {
+          if (msg.content?.data?.taskId === taskId) {
+            const agentId = msg.content?.data?.agent || msg.sender;
+            matchedAgent = cluster.agents.find((a) => a.id === agentId);
+            break;
+          }
+        }
+      }
+
+      // Default to first agent if no match found (best effort for orphaned tasks)
+      const agent = matchedAgent || cluster.agents[0];
+      if (!agent) {
+        continue;
+      }
+
+      const state = agent.getState();
+
+      for (const line of lines) {
+        // Lines are prefixed with [timestamp] - parse that first
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('[')) {
+          continue;
+        }
+
+        try {
+          // Parse timestamp-prefixed line: [1733301234567]{json...} or [1733301234567][SYSTEM]...
+          let timestamp = Date.now();
+          let jsonContent = trimmed;
+
+          const timestampMatch = jsonContent.match(/^\[(\d{13})\](.*)$/);
+          if (timestampMatch) {
+            timestamp = parseInt(timestampMatch[1], 10);
+            jsonContent = timestampMatch[2];
+          }
+
+          // Skip non-JSON (e.g., [SYSTEM] lines)
+          if (!jsonContent.startsWith('{')) {
+            continue;
+          }
+
+          // Parse JSON
+          const parsed = JSON.parse(jsonContent);
+
+          // Skip system init messages
+          if (parsed.type === 'system' && parsed.subtype === 'init') {
+            continue;
+          }
+
+          // Convert to cluster message format
+          messages.push({
+            id: `task-${taskId}-${timestamp}`,
+            timestamp,
+            topic: 'AGENT_OUTPUT',
+            sender: agent.id,
+            receiver: 'broadcast',
+            cluster_id: cluster.id,
+            content: {
+              text: jsonContent,
+              data: {
+                type: 'stdout',
+                line: jsonContent,
+                agent: agent.id,
+                role: agent.role,
+                iteration: state.iteration,
+                fromTaskLog: true, // Mark as coming from task log
+              },
+            },
+          });
+        } catch {
+          // Skip invalid JSON
+        }
+      }
+    } catch (err) {
+      // Log file read error - skip this task
+      console.warn(`Warning: Could not read log for ${taskId}: ${err.message}`);
+    }
+  }
+
+  return messages;
+}
+
+// Setup shell completion
+setupCompletion();
+
+// Banner disabled
+function showBanner() {
+  // Banner removed for cleaner output
+}
+
+// Show banner on startup (but not for completion, help, or daemon child)
+const shouldShowBanner =
+  !process.env.CREW_DAEMON &&
+  !process.argv.includes('--completion') &&
+  !process.argv.includes('-h') &&
+  !process.argv.includes('--help') &&
+  process.argv.length > 2;
+if (shouldShowBanner) {
+  showBanner();
+}
+
+// Color palette for agents (avoid green/red - reserved for APPROVED/REJECTED)
+const COLORS = [chalk.cyan, chalk.yellow, chalk.magenta, chalk.blue, chalk.white, chalk.gray];
+
+// Map agent IDs to colors
+const agentColors = new Map();
+
+program
+  .name('zeroshot')
+  .description('Multi-agent orchestration and task management for Claude')
+  .version('1.0.0')
+  .addHelpText(
+    'after',
+    `
+Examples:
+  ${chalk.cyan('zeroshot auto 123')}                   Full automation: isolated + auto-merge PR
+  ${chalk.cyan('zeroshot run 123')}                    Run cluster and attach to first agent
+  ${chalk.cyan('zeroshot run 123 -d')}                 Run cluster in background (detached)
+  ${chalk.cyan('zeroshot run "Implement feature X"')}  Run cluster on plain text task
+  ${chalk.cyan('zeroshot run 123 --isolation')}        Run in Docker container (safe for e2e tests)
+  ${chalk.cyan('zeroshot task run "Fix the bug"')}     Run single-agent background task
+  ${chalk.cyan('zeroshot list')}                       List all tasks and clusters
+  ${chalk.cyan('zeroshot task list')}                  List tasks only
+  ${chalk.cyan('zeroshot task watch')}                 Interactive TUI - navigate tasks, view logs
+  ${chalk.cyan('zeroshot attach <id>')}                Attach to running task (Ctrl+B d to detach)
+  ${chalk.cyan('zeroshot logs -f')}                    Stream logs in real-time (like tail -f)
+  ${chalk.cyan('zeroshot logs -w')}                    Interactive watch mode (for tasks)
+  ${chalk.cyan('zeroshot logs <id> -f')}               Stream logs for specific cluster/task
+  ${chalk.cyan('zeroshot status <id>')}                Detailed status of task or cluster
+  ${chalk.cyan('zeroshot finish <id>')}                Convert cluster to completion task (creates and merges PR)
+  ${chalk.cyan('zeroshot kill <id>')}                  Kill a running task or cluster
+  ${chalk.cyan('zeroshot clear')}                      Kill all processes and delete all data (with confirmation)
+  ${chalk.cyan('zeroshot clear -y')}                   Clear everything without confirmation
+  ${chalk.cyan('zeroshot settings')}                   Show/manage zeroshot settings (default model, config, etc.)
+  ${chalk.cyan('zeroshot settings set <key> <val>')}   Set a setting (e.g., defaultModel haiku)
+  ${chalk.cyan('zeroshot config list')}                List available cluster configs
+  ${chalk.cyan('zeroshot config show <name>')}         Visualize a cluster config (agents, triggers, flow)
+  ${chalk.cyan('zeroshot export <id>')}                Export cluster conversation to file
+
+Cluster vs Task:
+  ${chalk.yellow('zeroshot auto')}      → Full automation (isolated + auto-merge PR)
+  ${chalk.yellow('zeroshot run')}       → Multi-agent cluster (auto-attaches, Ctrl+B d to detach)
+  ${chalk.yellow('zeroshot run -d')}    → Multi-agent cluster (background/detached)
+  ${chalk.yellow('zeroshot task run')}  → Single-agent background task (simpler, faster)
+
+Shell completion:
+  ${chalk.dim('zeroshot --completion >> ~/.bashrc && source ~/.bashrc')}
+`
+  );
+
+// Run command - CLUSTER with auto-detection
+program
+  .command('run <input>')
+  .description('Start a multi-agent cluster (auto-detects GitHub issue or plain text)')
+  .option('--config <file>', 'Path to cluster config JSON (default: conductor-bootstrap)')
+  .option('-m, --model <model>', 'Model for all agents: opus, sonnet, haiku (default: from config)')
+  .option('--isolation', 'Run cluster inside Docker container (for e2e testing)')
+  .option(
+    '--isolation-image <image>',
+    'Docker image for isolation (default: zeroshot-cluster-base)'
+  )
+  .option(
+    '--strict-schema',
+    'Enforce JSON schema via CLI (no live streaming). Default: live streaming with local validation'
+  )
+  .option('--pr', 'Create PR and merge on successful completion (requires --isolation)')
+  .option('--full', 'Shorthand for --isolation --pr (full automation)')
+  .option('--workers <n>', 'Max sub-agents for worker to spawn in parallel', parseInt)
+  .option('-d, --detach', 'Run in background (default: attach to first agent)')
+  .addHelpText(
+    'after',
+    `
+Input formats:
+  123                              GitHub issue number (uses current repo)
+  org/repo#123                     GitHub issue with explicit repo
+  https://github.com/.../issues/1  Full GitHub issue URL
+  "Implement feature X"            Plain text task description
+`
+  )
+  .action(async (inputArg, options) => {
+    try {
+      // Expand --full to --isolation + --pr
+      if (options.full) {
+        options.isolation = true;
+        options.pr = true;
+      }
+
+      // Auto-detect input type
+      let input = {};
+
+      // Check if it's a GitHub issue URL
+      if (inputArg.match(/^https?:\/\/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/)) {
+        input.issue = inputArg;
+      }
+      // Check if it's a GitHub issue number (just digits)
+      else if (/^\d+$/.test(inputArg)) {
+        input.issue = inputArg;
+      }
+      // Check if it's org/repo#123 format
+      else if (inputArg.match(/^[\w-]+\/[\w-]+#\d+$/)) {
+        input.issue = inputArg;
+      }
+      // Otherwise, treat as plain text
+      else {
+        input.text = inputArg;
+      }
+
+      // === CLUSTER MODE ===
+      // Validate --pr requires --isolation
+      if (options.pr && !options.isolation) {
+        console.error(chalk.red('Error: --pr requires --isolation flag for safety'));
+        console.error(chalk.dim('  Usage: zeroshot run 123 --isolation --pr'));
+        process.exit(1);
+      }
+
+      const { generateName } = require('../src/name-generator');
+
+      // === DETACHED MODE (-d flag) ===
+      // Spawn daemon and exit immediately
+      if (options.detach && !process.env.CREW_DAEMON) {
+        const { spawn } = require('child_process');
+
+        // Generate cluster ID in parent so we can display it
+        const clusterId = generateName('cluster');
+
+        // Output cluster ID and help
+        if (options.isolation) {
+          console.log(`Started ${clusterId} (isolated)`);
+        } else {
+          console.log(`Started ${clusterId}`);
+        }
+        console.log(`Monitor: zeroshot logs ${clusterId} -f`);
+        console.log(`Attach:  zeroshot attach ${clusterId}`);
+
+        // Create log file for daemon output (captures startup errors)
+        const osModule = require('os');
+        const storageDir = path.join(osModule.homedir(), '.zeroshot');
+        if (!fs.existsSync(storageDir)) {
+          fs.mkdirSync(storageDir, { recursive: true });
+        }
+        const logPath = path.join(storageDir, `${clusterId}-daemon.log`);
+        const logFd = fs.openSync(logPath, 'w');
+
+        // Detect git repo root for CWD propagation
+        // CRITICAL: Agents must work in the target repo, not where CLI was invoked
+        const targetCwd = detectGitRepoRoot();
+
+        // Spawn ourselves as daemon (detached, logs to file)
+        const daemon = spawn(process.execPath, process.argv.slice(1), {
+          detached: true,
+          stdio: ['ignore', logFd, logFd], // stdout + stderr go to log file
+          cwd: targetCwd, // Daemon inherits correct working directory
+          env: {
+            ...process.env,
+            CREW_DAEMON: '1',
+            CREW_CLUSTER_ID: clusterId,
+            CREW_MODEL: options.model || '',
+            CREW_ISOLATION: options.isolation ? '1' : '',
+            CREW_ISOLATION_IMAGE: options.isolationImage || '',
+            CREW_PR: options.pr ? '1' : '',
+            CREW_WORKERS: options.workers?.toString() || '',
+            CREW_CWD: targetCwd, // Explicit CWD for orchestrator
+          },
+        });
+
+        daemon.unref();
+        fs.closeSync(logFd);
+        process.exit(0);
+      }
+
+      // === FOREGROUND MODE (default) or DAEMON CHILD ===
+      // Load user settings
+      const settings = loadSettings();
+
+      // Use cluster ID from env (daemon mode) or generate new one (foreground mode)
+      // IMPORTANT: Set env var so orchestrator picks it up
+      const clusterId = process.env.CREW_CLUSTER_ID || generateName('cluster');
+      process.env.CREW_CLUSTER_ID = clusterId;
+
+      // === LOAD CONFIG ===
+      // Priority: CLI --config > settings.defaultConfig
+      let config;
+      const configName = options.config || settings.defaultConfig;
+
+      // Resolve config path (check examples/ directory if not absolute/relative path)
+      let configPath;
+      if (
+        path.isAbsolute(configName) ||
+        configName.startsWith('./') ||
+        configName.startsWith('../')
+      ) {
+        configPath = path.resolve(process.cwd(), configName);
+      } else if (configName.endsWith('.json')) {
+        // If it has .json extension, check examples/ directory
+        configPath = path.join(PACKAGE_ROOT, 'cluster-templates', configName);
+      } else {
+        // Otherwise assume it's a template name (add .json)
+        configPath = path.join(PACKAGE_ROOT, 'cluster-templates', `${configName}.json`);
+      }
+
+      // Create orchestrator with clusterId override for foreground mode
+      const orchestrator = getOrchestrator();
+      config = orchestrator.loadConfig(configPath);
+
+      // Track for global error handler cleanup
+      activeClusterId = clusterId;
+      orchestratorInstance = orchestrator;
+
+      // In foreground mode, show startup info
+      if (!process.env.CREW_DAEMON) {
+        if (options.isolation) {
+          console.log(`Starting ${clusterId} (isolated)`);
+        } else {
+          console.log(`Starting ${clusterId}`);
+        }
+        console.log(chalk.dim(`Config: ${configName}`));
+        console.log(chalk.dim('Ctrl+C to stop following (cluster keeps running)\n'));
+      }
+
+      // Override model (CLI > settings > config)
+      const modelOverride = process.env.CREW_MODEL || options.model || settings.defaultModel;
+      if (modelOverride) {
+        for (const agent of config.agents) {
+          // Only override if agent doesn't already specify a model
+          if (!agent.model || modelOverride) {
+            agent.model = modelOverride;
+          }
+        }
+      }
+
+      // Apply strictSchema setting to all agents (CLI > env > settings)
+      const strictSchema =
+        options.strictSchema || process.env.CREW_STRICT_SCHEMA === '1' || settings.strictSchema;
+      if (strictSchema) {
+        for (const agent of config.agents) {
+          agent.strictSchema = true;
+        }
+      }
+
+      // Build start options (CLI flags > env vars > settings)
+      // In foreground mode, use CLI options directly; in daemon mode, use env vars
+      // CRITICAL: cwd must be passed to orchestrator for agent CWD propagation
+      const targetCwd = process.env.CREW_CWD || detectGitRepoRoot();
+      const startOptions = {
+        cwd: targetCwd, // Target working directory for agents
+        isolation:
+          options.isolation || process.env.CREW_ISOLATION === '1' || settings.defaultIsolation,
+        isolationImage: options.isolationImage || process.env.CREW_ISOLATION_IMAGE || undefined,
+        autoPr: options.pr || process.env.CREW_PR === '1',
+        autoMerge: process.env.CREW_MERGE === '1',
+        autoPush: process.env.CREW_PUSH === '1',
+      };
+
+      // Start cluster
+      const cluster = await orchestrator.start(config, input, startOptions);
+
+      // === FOREGROUND MODE: Stream logs in real-time ===
+      // Subscribe to message bus directly (same process) for instant output
+      if (!process.env.CREW_DAEMON) {
+        // Track senders that have output (for periodic flushing)
+        const sendersWithOutput = new Set();
+        // Track messages we've already processed (to avoid duplicates between history and subscription)
+        const processedMessageIds = new Set();
+
+        // Message handler - processes messages, deduplicates by ID
+        const handleMessage = (msg) => {
+          if (msg.cluster_id !== clusterId) return;
+          if (processedMessageIds.has(msg.id)) return;
+          processedMessageIds.add(msg.id);
+
+          if (msg.topic === 'AGENT_OUTPUT' && msg.sender) {
+            sendersWithOutput.add(msg.sender);
+          }
+          printMessage(msg, false, false, true);
+        };
+
+        // Subscribe to NEW messages
+        const unsubscribe = cluster.messageBus.subscribe(handleMessage);
+
+        // CRITICAL: Replay historical messages that may have been published BEFORE we subscribed
+        // This fixes the race condition where fast-completing clusters miss output
+        const historicalMessages = cluster.messageBus.getAll(clusterId);
+        for (const msg of historicalMessages) {
+          handleMessage(msg);
+        }
+
+        // Periodic flush of text buffers (streaming text may not have newlines)
+        const flushInterval = setInterval(() => {
+          for (const sender of sendersWithOutput) {
+            const prefix = getColorForSender(sender)(`${sender.padEnd(15)} |`);
+            flushLineBuffer(prefix, sender);
+          }
+        }, 250);
+
+        // Wait for cluster to complete
+        await new Promise((resolve) => {
+          const checkInterval = setInterval(() => {
+            try {
+              const status = orchestrator.getStatus(clusterId);
+              if (status.state !== 'running') {
+                clearInterval(checkInterval);
+                clearInterval(flushInterval);
+                // Final flush
+                for (const sender of sendersWithOutput) {
+                  const prefix = getColorForSender(sender)(`${sender.padEnd(15)} |`);
+                  flushLineBuffer(prefix, sender);
+                }
+                unsubscribe();
+                resolve();
+              }
+            } catch {
+              // Cluster may have been removed
+              clearInterval(checkInterval);
+              clearInterval(flushInterval);
+              unsubscribe();
+              resolve();
+            }
+          }, 500);
+
+          // Handle Ctrl+C: Stop cluster since foreground mode has no daemon
+          // CRITICAL: In foreground mode, the cluster runs IN this process.
+          // If we exit without stopping, the cluster becomes a zombie (state=running but no process).
+          process.on('SIGINT', async () => {
+            console.log(chalk.dim('\n\n--- Interrupted ---'));
+            clearInterval(checkInterval);
+            clearInterval(flushInterval);
+            unsubscribe();
+
+            // Stop the cluster properly so state is updated
+            try {
+              console.log(chalk.dim(`Stopping cluster ${clusterId}...`));
+              await orchestrator.stop(clusterId);
+              console.log(chalk.dim(`Cluster ${clusterId} stopped.`));
+            } catch (stopErr) {
+              console.error(chalk.red(`Failed to stop cluster: ${stopErr.message}`));
+            }
+
+            process.exit(0);
+          });
+        });
+
+        console.log(chalk.dim(`\nCluster ${clusterId} completed.`));
+      }
+
+      // Daemon mode: cluster runs in background, stay alive via orchestrator's setInterval
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Auto command - full automation (isolation + PR)
+program
+  .command('auto <input>')
+  .description('Full automation: isolated + auto-merge PR (shorthand for run --isolation --pr)')
+  .option('--config <file>', 'Path to cluster config JSON (default: conductor-bootstrap)')
+  .option('-m, --model <model>', 'Model for all agents: opus, sonnet, haiku (default: from config)')
+  .option(
+    '--isolation-image <image>',
+    'Docker image for isolation (default: zeroshot-cluster-base)'
+  )
+  .option(
+    '--strict-schema',
+    'Enforce JSON schema via CLI (no live streaming). Default: live streaming with local validation'
+  )
+  .option('--workers <n>', 'Max sub-agents for worker to spawn in parallel', parseInt)
+  .option('-d, --detach', 'Run in background (default: attach to first agent)')
+  .addHelpText(
+    'after',
+    `
+Input formats:
+  123                              GitHub issue number (uses current repo)
+  org/repo#123                     GitHub issue with explicit repo
+  https://github.com/.../issues/1  Full GitHub issue URL
+  "Implement feature X"            Plain text task description
+
+Examples:
+  ${chalk.cyan('zeroshot auto 123')}              Auto-resolve issue (isolated + PR)
+  ${chalk.cyan('zeroshot auto 123 -d')}           Same, but detached/background
+`
+  )
+  .action((inputArg, options) => {
+    // Auto command is shorthand for: zeroshot run <input> --isolation --pr [options]
+    // Re-invoke CLI with the correct flags to avoid Commander.js internal API issues
+    const { spawn } = require('child_process');
+
+    const args = ['run', inputArg, '--isolation', '--pr'];
+
+    // Forward other options
+    if (options.config) args.push('--config', options.config);
+    if (options.model) args.push('--model', options.model);
+    if (options.isolationImage) args.push('--isolation-image', options.isolationImage);
+    if (options.strictSchema) args.push('--strict-schema');
+    if (options.workers) args.push('--workers', String(options.workers));
+    if (options.detach) args.push('--detach');
+
+    // Spawn zeroshot run with inherited stdio
+    const proc = spawn(process.execPath, [process.argv[1], ...args], {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+      env: process.env,
+    });
+
+    proc.on('close', (code) => {
+      process.exit(code || 0);
+    });
+
+    proc.on('error', (err) => {
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    });
+  });
+
+// === TASK COMMANDS ===
+// Task run - single-agent background task
+const taskCmd = program.command('task').description('Single-agent task management');
+
+taskCmd
+  .command('run <prompt>')
+  .description('Run a single-agent background task')
+  .option('-C, --cwd <path>', 'Working directory for task')
+  .option(
+    '-m, --model <model>',
+    'Model to use: opus, sonnet, haiku (default: sonnet or ANTHROPIC_MODEL env)'
+  )
+  .option('-r, --resume <sessionId>', 'Resume a specific Claude session')
+  .option('-c, --continue', 'Continue the most recent session')
+  .option(
+    '-o, --output-format <format>',
+    'Output format: stream-json (default), text, json',
+    'stream-json'
+  )
+  .option('--json-schema <schema>', 'JSON schema for structured output')
+  .option('--silent-json-output', 'Log ONLY final structured output')
+  .action(async (prompt, options) => {
+    try {
+      // Dynamically import task command (ESM module)
+      const { runTask } = await import('../task-lib/commands/run.js');
+      await runTask(prompt, options);
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command('list')
+  .alias('ls')
+  .description('List all tasks (use "zeroshot list" to see both tasks and clusters)')
+  .option('-s, --status <status>', 'Filter tasks by status (running, completed, failed)')
+  .option('-n, --limit <n>', 'Limit number of results', parseInt)
+  .option('-v, --verbose', 'Show detailed information (default: table view)')
+  .action(async (options) => {
+    try {
+      // Get tasks only (dynamic import)
+      const { listTasks } = await import('../task-lib/commands/list.js');
+      await listTasks(options);
+    } catch (error) {
+      console.error('Error listing tasks:', error.message);
+      process.exit(1);
+    }
+  });
+
+taskCmd
+  .command('watch')
+  .description('Interactive TUI for tasks (navigate and view logs)')
+  .option('--refresh-rate <ms>', 'Refresh interval in milliseconds', '1000')
+  .action(async (options) => {
+    try {
+      const TaskTUI = (await import('../task-lib/tui.js')).default;
+      const tui = new TaskTUI({
+        refreshRate: parseInt(options.refreshRate, 10),
+      });
+      await tui.start();
+    } catch (error) {
+      console.error('Error starting task TUI:', error.message);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  });
+
+// List command - unified (shows both tasks and clusters)
+program
+  .command('list')
+  .alias('ls')
+  .description('List all tasks and clusters')
+  .option('-s, --status <status>', 'Filter tasks by status (running, completed, failed)')
+  .option('-n, --limit <n>', 'Limit number of results', parseInt)
+  .action(async (options) => {
+    try {
+      // Get clusters
+      const clusters = getOrchestrator().listClusters();
+
+      // Get tasks (dynamic import)
+      const { listTasks } = await import('../task-lib/commands/list.js');
+
+      // Capture task output (listTasks prints directly, we need to capture)
+      // For now, let's list them separately
+
+      // Print clusters
+      if (clusters.length > 0) {
+        console.log(chalk.bold('\n=== Clusters ==='));
+        console.log(
+          `${'ID'.padEnd(25)} ${'State'.padEnd(15)} ${'Agents'.padEnd(10)} ${'Msgs'.padEnd(8)} Created`
+        );
+        console.log('-'.repeat(100));
+
+        for (const cluster of clusters) {
+          const created = new Date(cluster.createdAt).toLocaleString();
+
+          // Highlight zombie clusters in red
+          const stateDisplay =
+            cluster.state === 'zombie'
+              ? chalk.red(cluster.state.padEnd(15))
+              : cluster.state.padEnd(15);
+
+          const rowColor = cluster.state === 'zombie' ? chalk.red : (s) => s;
+
+          console.log(
+            `${rowColor(cluster.id.padEnd(25))} ${stateDisplay} ${cluster.agentCount.toString().padEnd(10)} ${cluster.messageCount.toString().padEnd(8)} ${created}`
+          );
+        }
+      } else {
+        console.log(chalk.dim('\n=== Clusters ==='));
+        console.log('No active clusters');
+      }
+
+      // Print tasks
+      console.log(chalk.bold('\n=== Tasks ==='));
+      await listTasks(options);
+    } catch (error) {
+      console.error('Error listing:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Status command - smart (works for both tasks and clusters)
+program
+  .command('status <id>')
+  .description('Get detailed status of a task or cluster')
+  .action(async (id) => {
+    try {
+      const { detectIdType } = require('../lib/id-detector');
+      const type = detectIdType(id);
+
+      if (!type) {
+        console.error(`ID not found: ${id}`);
+        console.error('Not found in tasks or clusters');
+        process.exit(1);
+      }
+
+      if (type === 'cluster') {
+        // Show cluster status
+        const status = getOrchestrator().getStatus(id);
+
+        console.log(`\nCluster: ${status.id}`);
+        if (status.isZombie) {
+          console.log(
+            chalk.red(
+              `State: ${status.state} (process ${status.pid} died, cluster has no backing process)`
+            )
+          );
+          console.log(
+            chalk.yellow(
+              `  → Run 'zeroshot kill ${id}' to clean up, or 'zeroshot resume ${id}' to restart`
+            )
+          );
+        } else {
+          console.log(`State: ${status.state}`);
+        }
+        if (status.pid) {
+          console.log(`PID: ${status.pid}`);
+        }
+        console.log(`Created: ${new Date(status.createdAt).toLocaleString()}`);
+        console.log(`Messages: ${status.messageCount}`);
+        console.log(`\nAgents:`);
+
+        for (const agent of status.agents) {
+          // Check if subcluster
+          if (agent.type === 'subcluster') {
+            console.log(`  - ${agent.id} (${agent.role}) [SubCluster]`);
+            console.log(`    State: ${agent.state}`);
+            console.log(`    Iteration: ${agent.iteration}`);
+            console.log(`    Child Cluster: ${agent.childClusterId || 'none'}`);
+            console.log(`    Child Running: ${agent.childRunning ? 'Yes' : 'No'}`);
+          } else {
+            const modelLabel = agent.model ? ` [${agent.model}]` : '';
+            console.log(`  - ${agent.id} (${agent.role})${modelLabel}`);
+            console.log(`    State: ${agent.state}`);
+            console.log(`    Iteration: ${agent.iteration}`);
+            console.log(`    Running task: ${agent.currentTask ? 'Yes' : 'No'}`);
+          }
+        }
+
+        console.log('');
+      } else {
+        // Show task status
+        const { showStatus } = await import('../task-lib/commands/status.js');
+        await showStatus(id);
+      }
+    } catch (error) {
+      console.error('Error getting status:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Logs command - smart (works for both tasks and clusters)
+program
+  .command('logs [id]')
+  .description('View logs (omit ID for all clusters)')
+  .option('-f, --follow', 'Follow logs in real-time (stream output like tail -f)')
+  .option('-n, --limit <number>', 'Number of recent messages to show (default: 50)', '50')
+  .option('--lines <number>', 'Number of lines to show (task mode)', parseInt)
+  .option('-w, --watch', 'Watch mode: interactive TUI for tasks, high-level events for clusters')
+  .action(async (id, options) => {
+    try {
+      // If ID provided, detect type
+      if (id) {
+        const { detectIdType } = require('../lib/id-detector');
+        const type = detectIdType(id);
+
+        if (!type) {
+          console.error(`ID not found: ${id}`);
+          process.exit(1);
+        }
+
+        if (type === 'task') {
+          // Show task logs
+          const { showLogs } = await import('../task-lib/commands/logs.js');
+          await showLogs(id, options);
+          return;
+        }
+        // Fall through to cluster logs below
+      }
+
+      // === CLUSTER LOGS ===
+      const limit = parseInt(options.limit);
+      const quietOrchestrator = new Orchestrator({ quiet: true });
+
+      // No ID: show/follow ALL clusters
+      if (!id) {
+        const allClusters = quietOrchestrator.listClusters();
+        const activeClusters = allClusters.filter((c) => c.state === 'running');
+
+        if (allClusters.length === 0) {
+          if (options.follow) {
+            console.log('No clusters found. Waiting for new clusters...\n');
+            console.log(chalk.dim('--- Waiting for clusters (Ctrl+C to stop) ---\n'));
+          } else {
+            console.log('No clusters found');
+            return;
+          }
+        }
+
+        // Track if multiple clusters
+        const multiCluster = allClusters.length > 1;
+
+        // Follow mode: show header
+        if (options.follow && allClusters.length > 0) {
+          if (activeClusters.length === 0) {
+            console.log(
+              chalk.dim(
+                `--- Showing history from ${allClusters.length} cluster(s), waiting for new activity (Ctrl+C to stop) ---\n`
+              )
+            );
+          } else if (activeClusters.length === 1) {
+            console.log(chalk.dim(`--- Following ${activeClusters[0].id} (Ctrl+C to stop) ---\n`));
+          } else {
+            console.log(
+              chalk.dim(
+                `--- Following ${activeClusters.length} active clusters (Ctrl+C to stop) ---`
+              )
+            );
+            for (const c of activeClusters) {
+              console.log(chalk.dim(`    • ${c.id} [${c.state}]`));
+            }
+            console.log('');
+          }
+        }
+
+        // Show recent messages from ALL clusters (history)
+        // In follow mode, poll will handle new messages - this shows initial history
+        for (const clusterInfo of allClusters) {
+          const cluster = quietOrchestrator.getCluster(clusterInfo.id);
+          if (cluster) {
+            const messages = cluster.messageBus.getAll(clusterInfo.id);
+            const recentMessages = messages.slice(-limit);
+            const isActive = clusterInfo.state === 'running';
+            for (const msg of recentMessages) {
+              printMessage(msg, clusterInfo.id, options.watch, isActive);
+            }
+          }
+        }
+
+        // Follow mode: poll SQLite for new messages (cross-process support)
+        if (options.follow) {
+          // Set terminal title based on task(s)
+          const taskTitles = [];
+          for (const clusterInfo of allClusters) {
+            const cluster = quietOrchestrator.getCluster(clusterInfo.id);
+            if (cluster) {
+              const messages = cluster.messageBus.getAll(clusterInfo.id);
+              const issueOpened = messages.find((m) => m.topic === 'ISSUE_OPENED');
+              if (issueOpened) {
+                taskTitles.push({
+                  id: clusterInfo.id,
+                  summary: formatTaskSummary(issueOpened, 30),
+                });
+              }
+            }
+          }
+          if (taskTitles.length === 1) {
+            setTerminalTitle(`zeroshot [${taskTitles[0].id}]: ${taskTitles[0].summary}`);
+          } else if (taskTitles.length > 1) {
+            setTerminalTitle(`zeroshot: ${taskTitles.length} clusters`);
+          } else {
+            setTerminalTitle('zeroshot: waiting...');
+          }
+
+          // In watch mode, show the initial task for each cluster (after history)
+          if (options.watch) {
+            for (const clusterInfo of allClusters) {
+              const cluster = quietOrchestrator.getCluster(clusterInfo.id);
+              if (cluster) {
+                const messages = cluster.messageBus.getAll(clusterInfo.id);
+                const issueOpened = messages.find((m) => m.topic === 'ISSUE_OPENED');
+                if (issueOpened) {
+                  const clusterLabel = multiCluster ? `[${clusterInfo.id}] ` : '';
+                  const taskSummary = formatTaskSummary(issueOpened);
+                  console.log(chalk.cyan(`${clusterLabel}Task: ${chalk.bold(taskSummary)}\n`));
+                }
+              }
+            }
+          }
+
+          const stopPollers = [];
+          const messageBuffer = [];
+
+          // Track cluster states (for dim coloring of inactive clusters)
+          const clusterStates = new Map(); // cluster_id -> state
+          for (const c of allClusters) {
+            clusterStates.set(c.id, c.state);
+          }
+
+          // Track agent states from AGENT_LIFECYCLE messages (cross-process compatible)
+          const agentStates = new Map(); // agent -> { state, timestamp }
+
+          // Track if status line is currently displayed (to clear before printing logs)
+          let statusLineShown = false;
+
+          // Buffered message handler - collects messages and sorts by timestamp
+          const flushMessages = () => {
+            if (messageBuffer.length === 0) return;
+            // Sort by timestamp
+            messageBuffer.sort((a, b) => a.timestamp - b.timestamp);
+
+            // Track senders with pending output
+            const sendersWithOutput = new Set();
+            for (const msg of messageBuffer) {
+              if (msg.topic === 'AGENT_OUTPUT' && msg.sender) {
+                sendersWithOutput.add(msg.sender);
+              }
+              // Track agent state from AGENT_LIFECYCLE messages
+              if (msg.topic === 'AGENT_LIFECYCLE' && msg.sender && msg.content?.data?.state) {
+                agentStates.set(msg.sender, {
+                  state: msg.content.data.state,
+                  model: msg.sender_model, // sender_model is always set by agent-wrapper._publish
+                  timestamp: msg.timestamp || Date.now(),
+                });
+              }
+
+              // Clear status line before printing message
+              if (statusLineShown) {
+                process.stdout.write('\r' + ' '.repeat(120) + '\r');
+                statusLineShown = false;
+              }
+
+              const isActive = clusterStates.get(msg.cluster_id) === 'running';
+              printMessage(msg, true, options.watch, isActive);
+            }
+
+            // Save cluster ID before clearing buffer
+            const firstClusterId = messageBuffer[0]?.cluster_id;
+            messageBuffer.length = 0;
+
+            // Flush pending line buffers for all senders that had output
+            // This ensures streaming text without newlines gets displayed
+            for (const sender of sendersWithOutput) {
+              const senderLabel = `${firstClusterId || ''}/${sender}`;
+              const prefix = getColorForSender(sender)(`${senderLabel.padEnd(25)} |`);
+              flushLineBuffer(prefix, sender);
+            }
+          };
+
+          // Flush buffer every 250ms
+          const flushInterval = setInterval(flushMessages, 250);
+
+          // Blinking status indicator (follow/watch mode) - uses AGENT_LIFECYCLE state
+          let blinkState = false;
+          let statusInterval = null;
+          if (options.follow || options.watch) {
+            statusInterval = setInterval(() => {
+              blinkState = !blinkState;
+
+              // Get active agents from tracked states
+              const activeList = [];
+              for (const [agentId, info] of agentStates.entries()) {
+                // Agent is active if not idle and not stopped
+                if (info.state !== 'idle' && info.state !== 'stopped') {
+                  activeList.push({
+                    id: agentId,
+                    state: info.state,
+                    model: info.model,
+                  });
+                }
+              }
+
+              // Build status line - only show when agents are actively working
+              if (activeList.length > 0) {
+                const indicator = blinkState ? chalk.yellow('●') : chalk.dim('○');
+                const agents = activeList
+                  .map((a) => {
+                    // Show state only for non-standard states (error, etc.)
+                    const showState = a.state === 'error';
+                    const stateLabel = showState ? chalk.red(` (${a.state})`) : '';
+                    // Always show model
+                    const modelLabel = a.model ? chalk.dim(` [${a.model}]`) : '';
+                    return getColorForSender(a.id)(a.id) + modelLabel + stateLabel;
+                  })
+                  .join(', ');
+                process.stdout.write(`\r${indicator} Active: ${agents}` + ' '.repeat(20));
+                statusLineShown = true;
+              } else {
+                // Clear status line when no agents actively working
+                if (statusLineShown) {
+                  process.stdout.write('\r' + ' '.repeat(60) + '\r');
+                  statusLineShown = false;
+                }
+              }
+            }, 500);
+          }
+
+          for (const clusterInfo of allClusters) {
+            const cluster = quietOrchestrator.getCluster(clusterInfo.id);
+            if (cluster) {
+              // Use polling for cross-process message detection
+              const stopPoll = cluster.ledger.pollForMessages(
+                clusterInfo.id,
+                (msg) => {
+                  messageBuffer.push(msg);
+                },
+                300
+              );
+              stopPollers.push(stopPoll);
+            }
+          }
+
+          const stopWatching = quietOrchestrator.watchForNewClusters((newCluster) => {
+            console.log(chalk.green(`\n✓ New cluster detected: ${newCluster.id}\n`));
+            // Track new cluster as active
+            clusterStates.set(newCluster.id, 'running');
+            // Poll new cluster's ledger
+            const stopPoll = newCluster.ledger.pollForMessages(
+              newCluster.id,
+              (msg) => {
+                messageBuffer.push(msg);
+              },
+              300
+            );
+            stopPollers.push(stopPoll);
+          });
+
+          keepProcessAlive(() => {
+            clearInterval(flushInterval);
+            if (statusInterval) clearInterval(statusInterval);
+            flushMessages();
+            stopPollers.forEach((stop) => stop());
+            stopWatching();
+            // Clear status line on exit
+            if (statusLineShown) {
+              process.stdout.write('\r' + ' '.repeat(120) + '\r');
+            }
+            // Restore terminal title
+            restoreTerminalTitle();
+          });
+        }
+        return;
+      }
+
+      // Specific cluster ID provided
+      const cluster = quietOrchestrator.getCluster(id);
+      if (!cluster) {
+        console.error(`Cluster ${id} not found`);
+        process.exit(1);
+      }
+
+      // Check if cluster is active
+      const allClustersList = quietOrchestrator.listClusters();
+      const clusterInfo = allClustersList.find((c) => c.id === id);
+      const isActive = clusterInfo?.state === 'running';
+
+      // Get messages from cluster database
+      const dbMessages = cluster.messageBus.getAll(id);
+
+      // Get messages from agent task logs
+      const taskLogMessages = readAgentTaskLogs(cluster);
+
+      // Merge and sort by timestamp
+      const allMessages = [...dbMessages, ...taskLogMessages].sort(
+        (a, b) => a.timestamp - b.timestamp
+      );
+      const recentMessages = allMessages.slice(-limit);
+
+      // Print messages
+      for (const msg of recentMessages) {
+        printMessage(msg, true, options.watch, isActive);
+      }
+
+      // Follow mode for specific cluster (poll SQLite AND task logs)
+      if (options.follow) {
+        // Set terminal title based on task
+        const issueOpened = dbMessages.find((m) => m.topic === 'ISSUE_OPENED');
+        if (issueOpened) {
+          setTerminalTitle(`zeroshot [${id}]: ${formatTaskSummary(issueOpened, 30)}`);
+        } else {
+          setTerminalTitle(`zeroshot [${id}]`);
+        }
+
+        console.log('\n--- Following logs (Ctrl+C to stop) ---\n');
+
+        // Poll cluster database for new messages
+        const stopDbPoll = cluster.ledger.pollForMessages(
+          id,
+          (msg) => {
+            printMessage(msg, true, options.watch, isActive);
+
+            // Flush pending line buffer for streaming text without newlines
+            if (msg.topic === 'AGENT_OUTPUT' && msg.sender) {
+              const senderLabel = `${msg.cluster_id || ''}/${msg.sender}`;
+              const prefix = getColorForSender(msg.sender)(`${senderLabel.padEnd(25)} |`);
+              flushLineBuffer(prefix, msg.sender);
+            }
+          },
+          500
+        );
+
+        // Poll agent task logs for new output
+        const taskLogSizes = new Map(); // taskId -> last size
+        const pollTaskLogs = () => {
+          for (const agent of cluster.agents) {
+            const state = agent.getState();
+            const taskId = state.currentTaskId;
+            if (!taskId) continue;
+
+            const logPath = path.join(os.homedir(), '.claude-zeroshot', 'logs', `${taskId}.log`);
+            if (!fs.existsSync(logPath)) continue;
+
+            try {
+              const stats = fs.statSync(logPath);
+              const currentSize = stats.size;
+              const lastSize = taskLogSizes.get(taskId) || 0;
+
+              if (currentSize > lastSize) {
+                // Read new content
+                const fd = fs.openSync(logPath, 'r');
+                const buffer = Buffer.alloc(currentSize - lastSize);
+                fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+                fs.closeSync(fd);
+
+                const newContent = buffer.toString('utf-8');
+                const lines = newContent.split('\n').filter((line) => line.trim());
+
+                for (const line of lines) {
+                  if (!line.trim().startsWith('{')) continue;
+
+                  try {
+                    // Parse timestamp-prefixed line
+                    let timestamp = Date.now();
+                    let jsonContent = line.trim();
+
+                    const timestampMatch = jsonContent.match(/^\[(\d{13})\](.*)$/);
+                    if (timestampMatch) {
+                      timestamp = parseInt(timestampMatch[1], 10);
+                      jsonContent = timestampMatch[2];
+                    }
+
+                    if (!jsonContent.startsWith('{')) continue;
+
+                    // Parse and validate JSON
+                    const parsed = JSON.parse(jsonContent);
+                    if (parsed.type === 'system' && parsed.subtype === 'init') continue;
+
+                    // Create message and print immediately
+                    const msg = {
+                      id: `task-${taskId}-${timestamp}`,
+                      timestamp,
+                      topic: 'AGENT_OUTPUT',
+                      sender: agent.id,
+                      receiver: 'broadcast',
+                      cluster_id: cluster.id,
+                      content: {
+                        text: jsonContent,
+                        data: {
+                          type: 'stdout',
+                          line: jsonContent,
+                          agent: agent.id,
+                          role: agent.role,
+                          iteration: state.iteration,
+                          fromTaskLog: true,
+                        },
+                      },
+                    };
+
+                    printMessage(msg, true, options.watch, isActive);
+
+                    // Flush line buffer
+                    const senderLabel = `${cluster.id}/${agent.id}`;
+                    const prefix = getColorForSender(agent.id)(`${senderLabel.padEnd(25)} |`);
+                    flushLineBuffer(prefix, agent.id);
+                  } catch {
+                    // Skip invalid JSON
+                  }
+                }
+
+                taskLogSizes.set(taskId, currentSize);
+              }
+            } catch {
+              // File read error - skip
+            }
+          }
+        };
+
+        // Poll task logs every 300ms (same as agent-wrapper)
+        const taskLogInterval = setInterval(pollTaskLogs, 300);
+
+        keepProcessAlive(() => {
+          stopDbPoll();
+          clearInterval(taskLogInterval);
+          restoreTerminalTitle();
+        });
+      }
+    } catch (error) {
+      console.error('Error viewing logs:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Stop command (cluster-only)
+program
+  .command('stop <cluster-id>')
+  .description('Stop a cluster gracefully')
+  .action(async (clusterId) => {
+    try {
+      console.log(`Stopping cluster ${clusterId}...`);
+      await getOrchestrator().stop(clusterId);
+      console.log('Cluster stopped successfully');
+    } catch (error) {
+      console.error('Error stopping cluster:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Kill command - smart (works for both tasks and clusters)
+program
+  .command('kill <id>')
+  .description('Kill a task or cluster')
+  .action(async (id) => {
+    try {
+      const { detectIdType } = require('../lib/id-detector');
+      const type = detectIdType(id);
+
+      if (!type) {
+        console.error(`ID not found: ${id}`);
+        process.exit(1);
+      }
+
+      if (type === 'cluster') {
+        console.log(`Killing cluster ${id}...`);
+        await getOrchestrator().kill(id);
+        console.log('Cluster killed successfully');
+      } else {
+        // Kill task
+        const { killTaskCommand } = await import('../task-lib/commands/kill.js');
+        await killTaskCommand(id);
+      }
+    } catch (error) {
+      console.error('Error killing:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Attach command - tmux-style attach to running task or cluster agent
+program
+  .command('attach [id]')
+  .description('Attach to a running task or cluster agent (Ctrl+C to detach, task keeps running)')
+  .option('-a, --agent <name>', 'Attach to specific agent in cluster (required for clusters)')
+  .addHelpText(
+    'after',
+    `
+Examples:
+  ${chalk.cyan('zeroshot attach')}                           List attachable tasks/clusters
+  ${chalk.cyan('zeroshot attach task-xxx')}                  Attach to task
+  ${chalk.cyan('zeroshot attach cluster-xxx --agent worker')} Attach to specific agent in cluster
+
+Key bindings:
+  ${chalk.yellow('Ctrl+C')}      Detach (task continues running)
+  ${chalk.yellow('Ctrl+B d')}    Also detach (for tmux muscle memory)
+  ${chalk.yellow('Ctrl+B ?')}    Show help
+  ${chalk.yellow('Ctrl+B c')}    Interrupt agent (sends SIGINT) - USE WITH CAUTION
+`
+  )
+  .action(async (id, options) => {
+    try {
+      const { AttachClient, socketDiscovery } = require('../src/attach');
+
+      // If no ID provided, list attachable processes
+      if (!id) {
+        const tasks = await socketDiscovery.listAttachableTasks();
+        const clusters = await socketDiscovery.listAttachableClusters();
+
+        if (tasks.length === 0 && clusters.length === 0) {
+          console.log(chalk.dim('No attachable tasks or clusters found.'));
+          console.log(chalk.dim('Start a task with: zeroshot task run "prompt"'));
+          return;
+        }
+
+        console.log(chalk.bold('\nAttachable processes:\n'));
+
+        if (tasks.length > 0) {
+          console.log(chalk.cyan('Tasks:'));
+          for (const taskId of tasks) {
+            console.log(`  ${taskId}`);
+          }
+        }
+
+        if (clusters.length > 0) {
+          console.log(chalk.yellow('\nClusters:'));
+          const OrchestratorModule = require('../src/orchestrator');
+          for (const clusterId of clusters) {
+            const agents = await socketDiscovery.listAttachableAgents(clusterId);
+            console.log(`  ${clusterId}`);
+            // Get agent models from orchestrator (if available)
+            let agentModels = {};
+            try {
+              const orchestrator = OrchestratorModule.getInstance();
+              const status = orchestrator.getStatus(clusterId);
+              for (const a of status.agents) {
+                agentModels[a.id] = a.model;
+              }
+            } catch {
+              /* orchestrator not running - models unavailable */
+            }
+            for (const agent of agents) {
+              const modelLabel = agentModels[agent] ? chalk.dim(` [${agentModels[agent]}]`) : '';
+              console.log(chalk.dim(`    --agent ${agent}`) + modelLabel);
+            }
+          }
+        }
+
+        console.log(chalk.dim('\nUsage: zeroshot attach <id> [--agent <name>]'));
+        return;
+      }
+
+      // Determine socket path
+      let socketPath;
+
+      if (id.startsWith('task-')) {
+        socketPath = socketDiscovery.getTaskSocketPath(id);
+      } else if (id.startsWith('cluster-')) {
+        // Clusters use the task system - each agent spawns a task with its own socket
+        // Get cluster status to find which task each agent is running
+        const store = require('../lib/store');
+        const cluster = store.getCluster(id);
+
+        if (!cluster) {
+          console.error(chalk.red(`Cluster ${id} not found`));
+          process.exit(1);
+        }
+
+        if (cluster.state !== 'running') {
+          console.error(chalk.red(`Cluster ${id} is not running (state: ${cluster.state})`));
+          console.error(chalk.dim('Only running clusters have attachable agents.'));
+          process.exit(1);
+        }
+
+        // Get orchestrator instance to query agent states
+        const OrchestratorModule = require('../src/orchestrator');
+        const orchestrator = OrchestratorModule.getInstance();
+
+        try {
+          const status = orchestrator.getStatus(id);
+          const activeAgents = status.agents.filter(
+            (a) => a.currentTaskId && a.state === 'executing_task'
+          );
+
+          if (activeAgents.length === 0) {
+            console.error(chalk.yellow(`No agents currently executing tasks in cluster ${id}`));
+            console.log(chalk.dim('\nAgent states:'));
+            for (const agent of status.agents) {
+              const modelLabel = agent.model ? chalk.dim(` [${agent.model}]`) : '';
+              console.log(
+                chalk.dim(
+                  `  ${agent.id}${modelLabel}: ${agent.state}${agent.currentTaskId ? ` (last task: ${agent.currentTaskId})` : ''}`
+                )
+              );
+            }
+            return;
+          }
+
+          if (!options.agent) {
+            // Show list of agents and their task IDs
+            console.log(chalk.yellow(`\nCluster ${id} - attachable agents:\n`));
+            for (const agent of activeAgents) {
+              const modelLabel = agent.model ? chalk.dim(` [${agent.model}]`) : '';
+              console.log(
+                `  ${chalk.cyan(agent.id)}${modelLabel} → task ${chalk.green(agent.currentTaskId)}`
+              );
+              console.log(chalk.dim(`    zeroshot attach ${agent.currentTaskId}`));
+            }
+            console.log(chalk.dim('\nAttach to an agent by running: zeroshot attach <taskId>'));
+            return;
+          }
+
+          // Find the specified agent
+          const agent = status.agents.find((a) => a.id === options.agent);
+          if (!agent) {
+            console.error(chalk.red(`Agent '${options.agent}' not found in cluster ${id}`));
+            console.log(
+              chalk.dim('Available agents: ' + status.agents.map((a) => a.id).join(', '))
+            );
+            process.exit(1);
+          }
+
+          if (!agent.currentTaskId) {
+            console.error(chalk.yellow(`Agent '${options.agent}' is not currently running a task`));
+            console.log(chalk.dim(`State: ${agent.state}`));
+            return;
+          }
+
+          // Use the agent's task socket
+          socketPath = socketDiscovery.getTaskSocketPath(agent.currentTaskId);
+          console.log(
+            chalk.dim(`Attaching to agent ${options.agent} via task ${agent.currentTaskId}...`)
+          );
+        } catch (err) {
+          // Orchestrator not running or cluster not loaded - fall back to socket discovery
+          console.error(chalk.yellow(`Could not get cluster status: ${err.message}`));
+          console.log(
+            chalk.dim('Try attaching directly to a task ID instead: zeroshot attach <taskId>')
+          );
+
+          // Try to find any task sockets that might belong to this cluster
+          const tasks = await socketDiscovery.listAttachableTasks();
+          if (tasks.length > 0) {
+            console.log(chalk.dim('\nAttachable tasks:'));
+            for (const taskId of tasks) {
+              console.log(chalk.dim(`  zeroshot attach ${taskId}`));
+            }
+          }
+          return;
+        }
+      } else {
+        // Try to auto-detect
+        socketPath = socketDiscovery.getSocketPath(id, options.agent);
+      }
+
+      // Check if socket exists
+      const socketAlive = await socketDiscovery.isSocketAlive(socketPath);
+      if (!socketAlive) {
+        console.error(chalk.red(`Cannot attach to ${id}`));
+
+        // Check if it's an old task without attach support
+        const { detectIdType } = require('../lib/id-detector');
+        const type = detectIdType(id);
+
+        if (type === 'task') {
+          console.error(chalk.dim('Task may have been spawned before attach support was added.'));
+          console.error(chalk.dim(`Try: zeroshot logs ${id} -f`));
+        } else if (type === 'cluster') {
+          console.error(chalk.dim('Cluster may not be running or agent may not exist.'));
+          console.error(chalk.dim(`Check status: zeroshot status ${id}`));
+        } else {
+          console.error(chalk.dim('Process not found or not attachable.'));
+        }
+        process.exit(1);
+      }
+
+      // Connect
+      console.log(
+        chalk.dim(`Attaching to ${id}${options.agent ? ` (agent: ${options.agent})` : ''}...`)
+      );
+      console.log(chalk.dim('Press Ctrl+B ? for help, Ctrl+B d to detach\n'));
+
+      const client = new AttachClient({ socketPath });
+
+      client.on('state', (_state) => {
+        // Could show status bar here in future
+      });
+
+      client.on('exit', ({ code, signal }) => {
+        console.log(chalk.dim(`\n\nProcess exited (code: ${code}, signal: ${signal})`));
+        process.exit(code || 0);
+      });
+
+      client.on('error', (err) => {
+        console.error(chalk.red(`\nConnection error: ${err.message}`));
+        process.exit(1);
+      });
+
+      client.on('detach', () => {
+        console.log(chalk.dim('\n\nDetached. Task continues running.'));
+        console.log(
+          chalk.dim(
+            `Re-attach: zeroshot attach ${id}${options.agent ? ` --agent ${options.agent}` : ''}`
+          )
+        );
+        process.exit(0);
+      });
+
+      client.on('close', () => {
+        console.log(chalk.dim('\n\nConnection closed.'));
+        process.exit(0);
+      });
+
+      await client.connect();
+    } catch (error) {
+      console.error(chalk.red(`Error attaching: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// Kill-all command - kills all running tasks and clusters
+program
+  .command('kill-all')
+  .description('Kill all running tasks and clusters')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (options) => {
+    try {
+      // Get counts first
+      const orchestrator = getOrchestrator();
+      const clusters = orchestrator.listClusters();
+      const runningClusters = clusters.filter(
+        (c) => c.state === 'running' || c.state === 'initializing'
+      );
+
+      const { loadTasks } = await import('../task-lib/store.js');
+      const { isProcessRunning } = await import('../task-lib/runner.js');
+      const tasks = loadTasks();
+      const runningTasks = Object.values(tasks).filter(
+        (t) => t.status === 'running' && isProcessRunning(t.pid)
+      );
+
+      const totalCount = runningClusters.length + runningTasks.length;
+
+      if (totalCount === 0) {
+        console.log(chalk.dim('No running tasks or clusters to kill.'));
+        return;
+      }
+
+      // Show what will be killed
+      console.log(chalk.bold(`\nWill kill:`));
+      if (runningClusters.length > 0) {
+        console.log(chalk.cyan(`  ${runningClusters.length} cluster(s)`));
+        for (const c of runningClusters) {
+          console.log(chalk.dim(`    - ${c.id}`));
+        }
+      }
+      if (runningTasks.length > 0) {
+        console.log(chalk.yellow(`  ${runningTasks.length} task(s)`));
+        for (const t of runningTasks) {
+          console.log(chalk.dim(`    - ${t.id}`));
+        }
+      }
+
+      // Confirm unless -y flag
+      if (!options.yes) {
+        const readline = require('readline');
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+
+        const answer = await new Promise((resolve) => {
+          rl.question(chalk.bold('\nProceed? [y/N] '), resolve);
+        });
+        rl.close();
+
+        if (answer.toLowerCase() !== 'y') {
+          console.log('Aborted.');
+          return;
+        }
+      }
+
+      console.log('');
+
+      // Kill clusters
+      if (runningClusters.length > 0) {
+        const clusterResults = await orchestrator.killAll();
+        for (const id of clusterResults.killed) {
+          console.log(chalk.green(`✓ Killed cluster: ${id}`));
+        }
+        for (const err of clusterResults.errors) {
+          console.log(chalk.red(`✗ Failed to kill cluster ${err.id}: ${err.error}`));
+        }
+      }
+
+      // Kill tasks
+      if (runningTasks.length > 0) {
+        const { killTask, isProcessRunning: checkPid } = await import('../task-lib/runner.js');
+        const { updateTask } = await import('../task-lib/store.js');
+
+        for (const task of runningTasks) {
+          if (!checkPid(task.pid)) {
+            updateTask(task.id, {
+              status: 'stale',
+              error: 'Process died unexpectedly',
+            });
+            console.log(chalk.yellow(`○ Task ${task.id} was already dead, marked stale`));
+            continue;
+          }
+
+          const killed = killTask(task.pid);
+          if (killed) {
+            updateTask(task.id, {
+              status: 'killed',
+              error: 'Killed by kill-all',
+            });
+            console.log(chalk.green(`✓ Killed task: ${task.id}`));
+          } else {
+            console.log(chalk.red(`✗ Failed to kill task: ${task.id}`));
+          }
+        }
+      }
+
+      console.log(chalk.bold.green(`\nDone.`));
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Export command (cluster-only)
+program
+  .command('export <cluster-id>')
+  .description('Export cluster conversation')
+  .option('-f, --format <format>', 'Export format: json, markdown, pdf', 'pdf')
+  .option('-o, --output <file>', 'Output file (auto-generated for pdf)')
+  .action(async (clusterId, options) => {
+    try {
+      // Get messages from DB
+      const Ledger = require('../src/ledger');
+      const homeDir = require('os').homedir();
+      const dbPath = path.join(homeDir, '.zeroshot', `${clusterId}.db`);
+
+      if (!require('fs').existsSync(dbPath)) {
+        throw new Error(`Cluster ${clusterId} not found (no DB file)`);
+      }
+
+      const ledger = new Ledger(dbPath);
+      const messages = ledger.getAll(clusterId);
+      ledger.close();
+
+      // JSON export
+      if (options.format === 'json') {
+        const data = JSON.stringify({ cluster_id: clusterId, messages }, null, 2);
+        if (options.output) {
+          require('fs').writeFileSync(options.output, data, 'utf8');
+          console.log(`Exported to ${options.output}`);
+        } else {
+          console.log(data);
+        }
+        return;
+      }
+
+      // Terminal-style export (for markdown and pdf)
+      const terminalOutput = renderMessagesToTerminal(clusterId, messages);
+
+      if (options.format === 'markdown') {
+        // Strip ANSI codes for markdown
+        const plainText = terminalOutput.replace(/\\x1b\[[0-9;]*m/g, '');
+        if (options.output) {
+          require('fs').writeFileSync(options.output, plainText, 'utf8');
+          console.log(`Exported to ${options.output}`);
+        } else {
+          console.log(plainText);
+        }
+        return;
+      }
+
+      // PDF export - convert ANSI to HTML, then to PDF
+      const outputFile = options.output || `${clusterId}.pdf`;
+      const AnsiToHtml = require('ansi-to-html');
+      const { mdToPdf } = await import('md-to-pdf');
+
+      const ansiConverter = new AnsiToHtml({
+        fg: '#d4d4d4',
+        bg: '#1e1e1e',
+        colors: {
+          0: '#1e1e1e',
+          1: '#f44747',
+          2: '#6a9955',
+          3: '#dcdcaa',
+          4: '#569cd6',
+          5: '#c586c0',
+          6: '#4ec9b0',
+          7: '#d4d4d4',
+          8: '#808080',
+          9: '#f44747',
+          10: '#6a9955',
+          11: '#dcdcaa',
+          12: '#569cd6',
+          13: '#c586c0',
+          14: '#4ec9b0',
+          15: '#ffffff',
+        },
+      });
+
+      const htmlContent = ansiConverter.toHtml(terminalOutput);
+      const fullHtml = `<pre style="margin:0;padding:0;white-space:pre-wrap;word-wrap:break-word;">${htmlContent}</pre>`;
+
+      const pdf = await mdToPdf(
+        { content: fullHtml },
+        {
+          pdf_options: {
+            format: 'A4',
+            margin: {
+              top: '10mm',
+              right: '10mm',
+              bottom: '10mm',
+              left: '10mm',
+            },
+            printBackground: true,
+          },
+          css: `
+            @page { size: A4 landscape; }
+            body {
+              margin: 0; padding: 16px;
+              background: #1e1e1e; color: #d4d4d4;
+              font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', 'Monaco', monospace;
+              font-size: 9pt; line-height: 1.4;
+            }
+            pre { margin: 0; font-family: inherit; }
+          `,
+        }
+      );
+
+      require('fs').writeFileSync(outputFile, pdf.content);
+      console.log(`Exported to ${outputFile}`);
+    } catch (error) {
+      console.error('Error exporting cluster:', error.message);
+      process.exit(1);
+    }
+  });
+
+// === TASK-SPECIFIC COMMANDS ===
+
+// Resume task or cluster
+program
+  .command('resume <id> [prompt]')
+  .description('Resume a failed task or cluster')
+  .option('-d, --detach', 'Resume in background (daemon mode)')
+  .action(async (id, prompt, options) => {
+    try {
+      // Try cluster first, then task (both use same ID format: "adjective-noun-number")
+      const OrchestratorModule = require('../src/orchestrator');
+      const orchestrator = new OrchestratorModule();
+
+      // Check if cluster exists
+      const cluster = orchestrator.getCluster(id);
+
+      if (cluster) {
+        // Resume cluster
+        console.log(chalk.cyan(`Resuming cluster ${id}...`));
+        const result = await orchestrator.resume(id, prompt);
+
+        console.log(chalk.green(`✓ Cluster resumed`));
+        if (result.resumeType === 'failure') {
+          console.log(`  Resume type: ${chalk.yellow('From failure')}`);
+          console.log(`  Resumed agent: ${result.resumedAgent}`);
+          console.log(`  Previous error: ${result.previousError}`);
+        } else {
+          console.log(`  Resume type: ${chalk.cyan('Clean continuation')}`);
+          if (result.resumedAgents && result.resumedAgents.length > 0) {
+            console.log(`  Resumed agents: ${result.resumedAgents.join(', ')}`);
+          } else {
+            console.log(`  Published CLUSTER_RESUMED to trigger workflow`);
+          }
+        }
+
+        // === DAEMON MODE: Exit and let cluster run in background ===
+        if (options.detach) {
+          console.log('');
+          console.log(chalk.dim(`Follow logs with: zeroshot logs ${id} -f`));
+          return;
+        }
+
+        // === FOREGROUND MODE: Stream logs in real-time (same as 'run' command) ===
+        console.log('');
+        console.log(chalk.dim('Streaming logs... (Ctrl+C to stop cluster)'));
+        console.log('');
+
+        // Get the cluster's message bus for streaming
+        const resumedCluster = orchestrator.getCluster(id);
+        if (!resumedCluster || !resumedCluster.messageBus) {
+          console.error(chalk.red('Failed to get message bus for resumed cluster'));
+          process.exit(1);
+        }
+
+        // Track senders that have output (for periodic flushing)
+        const sendersWithOutput = new Set();
+        // Track messages we've already processed (to avoid duplicates between history and subscription)
+        const processedMessageIds = new Set();
+
+        // Message handler - processes messages, deduplicates by ID
+        const handleMessage = (msg) => {
+          if (msg.cluster_id !== id) return;
+          if (processedMessageIds.has(msg.id)) return;
+          processedMessageIds.add(msg.id);
+
+          if (msg.topic === 'AGENT_OUTPUT' && msg.sender) {
+            sendersWithOutput.add(msg.sender);
+          }
+          printMessage(msg, false, false, true);
+        };
+
+        // Subscribe to NEW messages
+        const unsubscribe = resumedCluster.messageBus.subscribe(handleMessage);
+
+        // Periodic flush of text buffers (streaming text may not have newlines)
+        const flushInterval = setInterval(() => {
+          for (const sender of sendersWithOutput) {
+            const prefix = getColorForSender(sender)(`${sender.padEnd(15)} |`);
+            flushLineBuffer(prefix, sender);
+          }
+        }, 250);
+
+        // Wait for cluster to complete
+        await new Promise((resolve) => {
+          const checkInterval = setInterval(() => {
+            try {
+              const status = orchestrator.getStatus(id);
+              if (status.state !== 'running') {
+                clearInterval(checkInterval);
+                clearInterval(flushInterval);
+                // Final flush
+                for (const sender of sendersWithOutput) {
+                  const prefix = getColorForSender(sender)(`${sender.padEnd(15)} |`);
+                  flushLineBuffer(prefix, sender);
+                }
+                unsubscribe();
+                resolve();
+              }
+            } catch {
+              // Cluster may have been removed
+              clearInterval(checkInterval);
+              clearInterval(flushInterval);
+              unsubscribe();
+              resolve();
+            }
+          }, 500);
+
+          // Handle Ctrl+C: Stop cluster since foreground mode has no daemon
+          // CRITICAL: In foreground mode, the cluster runs IN this process.
+          // If we exit without stopping, the cluster becomes a zombie (state=running but no process).
+          process.on('SIGINT', async () => {
+            console.log(chalk.dim('\n\n--- Interrupted ---'));
+            clearInterval(checkInterval);
+            clearInterval(flushInterval);
+            unsubscribe();
+
+            // Stop the cluster properly so state is updated
+            try {
+              console.log(chalk.dim(`Stopping cluster ${id}...`));
+              await orchestrator.stop(id);
+              console.log(chalk.dim(`Cluster ${id} stopped.`));
+            } catch (stopErr) {
+              console.error(chalk.red(`Failed to stop cluster: ${stopErr.message}`));
+            }
+
+            process.exit(0);
+          });
+        });
+
+        console.log(chalk.dim(`\nCluster ${id} completed.`));
+      } else {
+        // Try resuming as task
+        const { resumeTask } = await import('../task-lib/commands/resume.js');
+        await resumeTask(id, prompt);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error resuming:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Finish cluster - convert to single-agent completion task
+program
+  .command('finish <id>')
+  .description('Take existing cluster and create completion-focused task (creates PR and merges)')
+  .option('-y, --yes', 'Skip confirmation if cluster is running')
+  .action(async (id, options) => {
+    try {
+      const OrchestratorModule = require('../src/orchestrator');
+      const orchestrator = new OrchestratorModule();
+
+      // Check if cluster exists
+      const cluster = orchestrator.getCluster(id);
+
+      if (!cluster) {
+        console.error(chalk.red(`Error: Cluster ${id} not found`));
+        console.error(chalk.dim('Use "zeroshot list" to see available clusters'));
+        process.exit(1);
+      }
+
+      // Stop cluster if it's running (with confirmation unless -y)
+      if (cluster.state === 'running') {
+        if (!options.y && !options.yes) {
+          console.log(chalk.yellow(`Cluster ${id} is still running.`));
+          console.log(chalk.dim('Stopping it before converting to completion task...'));
+          console.log('');
+
+          // Simple confirmation prompt
+          const readline = require('readline');
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+          });
+
+          const answer = await new Promise((resolve) => {
+            rl.question(chalk.yellow('Continue? (y/N) '), resolve);
+          });
+          rl.close();
+
+          if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+            console.log(chalk.red('Aborted'));
+            process.exit(0);
+          }
+        }
+
+        console.log(chalk.cyan('Stopping cluster...'));
+        await orchestrator.stop(id);
+        console.log(chalk.green('✓ Cluster stopped'));
+        console.log('');
+      }
+
+      console.log(chalk.cyan(`Converting cluster ${id} to completion task...`));
+      console.log('');
+
+      // Extract cluster context from ledger
+      const messages = cluster.messageBus.getAll(id);
+
+      // Find original task
+      const issueOpened = messages.find((m) => m.topic === 'ISSUE_OPENED');
+      const taskText = issueOpened?.content?.text || 'Unknown task';
+      const issueNumber = issueOpened?.content?.data?.issue_number;
+      const issueTitle = issueOpened?.content?.data?.title || 'Implementation';
+
+      // Find what's been done
+      const agentOutputs = messages.filter((m) => m.topic === 'AGENT_OUTPUT');
+      const validations = messages.filter((m) => m.topic === 'VALIDATION_RESULT');
+
+      // Build context summary
+      let contextSummary = `# Original Task\n\n${taskText}\n\n`;
+
+      if (issueNumber) {
+        contextSummary += `Issue: #${issueNumber} - ${issueTitle}\n\n`;
+      }
+
+      contextSummary += `# Progress So Far\n\n`;
+      contextSummary += `- ${agentOutputs.length} agent outputs\n`;
+      contextSummary += `- ${validations.length} validation results\n`;
+
+      const approvedValidations = validations.filter(
+        (v) => v.content?.data?.approved === true || v.content?.data?.approved === 'true'
+      );
+      contextSummary += `- ${approvedValidations.length} approvals\n\n`;
+
+      // Add recent validation summaries
+      if (validations.length > 0) {
+        contextSummary += `## Recent Validations\n\n`;
+        for (const v of validations.slice(-3)) {
+          const approved =
+            v.content?.data?.approved === true || v.content?.data?.approved === 'true';
+          const icon = approved ? '✅' : '❌';
+          contextSummary += `${icon} **${v.sender}**: ${v.content?.data?.summary || 'No summary'}\n`;
+        }
+        contextSummary += '\n';
+      }
+
+      // Build ultra-aggressive completion prompt (always merges)
+      const mergeGoal = 'CREATE PR AND MERGE IT';
+      const mergeStep = `
+8. MERGE THE PR - THIS IS MANDATORY:
+   \`\`\`bash
+   gh pr merge --merge --auto
+   \`\`\`
+
+   IF MERGE FAILS DUE TO CONFLICTS:
+   a) Pull and rebase: \`git fetch origin main && git rebase origin/main\`
+   b) Resolve conflicts manually (read files, make decisions, edit)
+   c) \`git add <resolved-files> && git rebase --continue\`
+   d) Force push: \`git push --force-with-lease\`
+   e) Retry merge: \`gh pr merge --merge\`
+
+   REPEAT UNTIL MERGED. DO NOT GIVE UP.`;
+
+      const completionPrompt = `# YOUR MISSION: ${mergeGoal}
+
+${contextSummary}
+
+# WHAT YOU MUST DO NOW
+
+You are the FINISHER. Your ONLY job is to take this cluster's work and push it across the finish line.
+
+**FAILURE IS NOT AN OPTION. YOU MUST COMPLETE THIS TASK.**
+
+## Steps (MUST complete ALL):
+
+1. REVIEW CURRENT STATE - Check git status, see what's changed:
+   \`\`\`bash
+   git status
+   git diff
+   \`\`\`
+
+2. COMMIT ALL CHANGES - Stage and commit everything:
+   \`\`\`bash
+   git add .
+   git commit -m "${issueTitle || 'feat: implement task'}"
+   \`\`\`
+
+3. CREATE BRANCH - Use issue number if available:
+   \`\`\`bash
+   ${issueNumber ? `git checkout -b issue-${issueNumber}` : 'git checkout -b feature/implementation'}
+   \`\`\`
+
+4. PUSH TO REMOTE:
+   \`\`\`bash
+   git push -u origin HEAD
+   \`\`\`
+
+5. CREATE PULL REQUEST:
+   \`\`\`bash
+   gh pr create --title "${issueTitle || 'Implementation'}" --body "Closes #${issueNumber || 'N/A'}
+
+## Summary
+${taskText.slice(0, 200)}...
+
+## Changes
+- Implementation complete
+- All validations addressed
+
+🤖 Generated with zeroshot finish"
+   \`\`\`
+
+6. GET PR URL:
+   \`\`\`bash
+   gh pr view --json url -q .url
+   \`\`\`
+
+7. OUTPUT THE PR URL - Print it clearly so user can see it
+${mergeStep}
+
+## RULES
+
+- NO EXCUSES: If something fails, FIX IT and retry
+- NO SHORTCUTS: Follow ALL steps above
+- NO PARTIAL WORK: Must reach PR creation and merge
+- IF TESTS FAIL: Fix them until they pass
+- IF CI FAILS: Wait for it, fix issues, retry
+- IF CONFLICTS: Resolve them intelligently
+
+**DO NOT STOP UNTIL YOU HAVE A MERGED PR.**`;
+
+      // Show preview
+      console.log(chalk.dim('='.repeat(80)));
+      console.log(chalk.dim('Task prompt preview:'));
+      console.log(chalk.dim('='.repeat(80)));
+      console.log(completionPrompt.split('\n').slice(0, 20).join('\n'));
+      console.log(chalk.dim('... (truncated) ...\n'));
+      console.log(chalk.dim('='.repeat(80)));
+      console.log('');
+
+      // Launch as task (preserve isolation if cluster was isolated)
+      console.log(chalk.cyan('Launching completion task...'));
+      const { runTask } = await import('../task-lib/commands/run.js');
+
+      const taskOptions = {
+        cwd: process.cwd(),
+      };
+
+      // If cluster was in isolation mode, pass container info to task
+      if (cluster.isolation?.enabled && cluster.isolation?.containerId) {
+        console.log(chalk.dim(`Using isolation container: ${cluster.isolation.containerId}`));
+        taskOptions.isolation = {
+          containerId: cluster.isolation.containerId,
+          workDir: '/workspace', // Standard workspace mount point in isolation containers
+        };
+      }
+
+      await runTask(completionPrompt, taskOptions);
+
+      console.log('');
+      console.log(chalk.green(`✓ Completion task started`));
+      if (cluster.isolation?.enabled) {
+        console.log(chalk.dim('Running in isolation container (same as cluster)'));
+      }
+      console.log(chalk.dim('Monitor with: zeroshot list'));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Clean tasks
+program
+  .command('clean')
+  .description('Remove old task records and logs')
+  .option('-a, --all', 'Remove all tasks')
+  .option('-c, --completed', 'Remove completed tasks')
+  .option('-f, --failed', 'Remove failed/stale/killed tasks')
+  .action(async (options) => {
+    try {
+      const { cleanTasks } = await import('../task-lib/commands/clean.js');
+      await cleanTasks(options);
+    } catch (error) {
+      console.error('Error cleaning tasks:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Clear all runs (clusters + tasks)
+program
+  .command('clear')
+  .description('Kill all running processes and delete all data')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (options) => {
+    try {
+      const orchestrator = getOrchestrator();
+
+      // Get counts first
+      const clusters = orchestrator.listClusters();
+      const runningClusters = clusters.filter(
+        (c) => c.state === 'running' || c.state === 'initializing'
+      );
+
+      const { loadTasks } = await import('../task-lib/store.js');
+      const { isProcessRunning } = await import('../task-lib/runner.js');
+      const tasks = Object.values(loadTasks());
+      const runningTasks = tasks.filter((t) => t.status === 'running' && isProcessRunning(t.pid));
+
+      // Check if there's anything to clear
+      if (clusters.length === 0 && tasks.length === 0) {
+        console.log(chalk.dim('No clusters or tasks to clear.'));
+        return;
+      }
+
+      // Show what will be cleared
+      console.log(chalk.bold('\nWill kill and delete:'));
+      if (clusters.length > 0) {
+        console.log(chalk.cyan(`  ${clusters.length} cluster(s) with all history`));
+        if (runningClusters.length > 0) {
+          console.log(chalk.yellow(`    ${runningClusters.length} running`));
+        }
+      }
+      if (tasks.length > 0) {
+        console.log(chalk.yellow(`  ${tasks.length} task(s) with all logs`));
+        if (runningTasks.length > 0) {
+          console.log(chalk.yellow(`    ${runningTasks.length} running`));
+        }
+      }
+      console.log('');
+
+      // Confirm unless -y flag
+      if (!options.yes) {
+        const readline = require('readline');
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+
+        const answer = await new Promise((resolve) => {
+          rl.question(
+            chalk.bold.red(
+              'This will kill all processes and permanently delete all data. Proceed? [y/N] '
+            ),
+            resolve
+          );
+        });
+        rl.close();
+
+        if (answer.toLowerCase() !== 'y') {
+          console.log('Aborted.');
+          return;
+        }
+      }
+
+      console.log('');
+
+      // Kill running clusters first
+      if (runningClusters.length > 0) {
+        console.log(chalk.bold('Killing running clusters...'));
+        const clusterResults = await orchestrator.killAll();
+        for (const id of clusterResults.killed) {
+          console.log(chalk.green(`✓ Killed cluster: ${id}`));
+        }
+        for (const err of clusterResults.errors) {
+          console.log(chalk.red(`✗ Failed to kill cluster ${err.id}: ${err.error}`));
+        }
+      }
+
+      // Kill running tasks
+      if (runningTasks.length > 0) {
+        console.log(chalk.bold('Killing running tasks...'));
+        const { killTask } = await import('../task-lib/runner.js');
+        const { updateTask } = await import('../task-lib/store.js');
+
+        for (const task of runningTasks) {
+          if (!isProcessRunning(task.pid)) {
+            updateTask(task.id, {
+              status: 'stale',
+              error: 'Process died unexpectedly',
+            });
+            console.log(chalk.yellow(`○ Task ${task.id} was already dead, marked stale`));
+            continue;
+          }
+
+          const killed = killTask(task.pid);
+          if (killed) {
+            updateTask(task.id, { status: 'killed', error: 'Killed by clear' });
+            console.log(chalk.green(`✓ Killed task: ${task.id}`));
+          } else {
+            console.log(chalk.red(`✗ Failed to kill task: ${task.id}`));
+          }
+        }
+      }
+
+      // Delete all cluster data
+      if (clusters.length > 0) {
+        console.log(chalk.bold('Deleting cluster data...'));
+        const clustersFile = path.join(orchestrator.storageDir, 'clusters.json');
+        const clustersDir = path.join(orchestrator.storageDir, 'clusters');
+
+        // Delete all cluster databases
+        for (const cluster of clusters) {
+          const dbPath = path.join(orchestrator.storageDir, `${cluster.id}.db`);
+          if (fs.existsSync(dbPath)) {
+            fs.unlinkSync(dbPath);
+            console.log(chalk.green(`✓ Deleted cluster database: ${cluster.id}.db`));
+          }
+        }
+
+        // Delete clusters.json
+        if (fs.existsSync(clustersFile)) {
+          fs.unlinkSync(clustersFile);
+          console.log(chalk.green(`✓ Deleted clusters.json`));
+        }
+
+        // Delete clusters directory if exists
+        if (fs.existsSync(clustersDir)) {
+          fs.rmSync(clustersDir, { recursive: true, force: true });
+          console.log(chalk.green(`✓ Deleted clusters/ directory`));
+        }
+
+        // Clear in-memory clusters
+        orchestrator.clusters.clear();
+      }
+
+      // Delete all task data
+      if (tasks.length > 0) {
+        console.log(chalk.bold('Deleting task data...'));
+        const { cleanTasks } = await import('../task-lib/commands/clean.js');
+        await cleanTasks({ all: true });
+      }
+
+      console.log(chalk.bold.green('\nAll runs killed and cleared.'));
+    } catch (error) {
+      console.error('Error clearing runs:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Schedule a task
+program
+  .command('schedule <prompt>')
+  .description('Create a recurring scheduled task')
+  .option('-e, --every <interval>', 'Interval (e.g., "1h", "30m", "1d")')
+  .option('--cron <expression>', 'Cron expression')
+  .option('-C, --cwd <path>', 'Working directory')
+  .action(async (prompt, options) => {
+    try {
+      const { createSchedule } = await import('../task-lib/commands/schedule.js');
+      await createSchedule(prompt, options);
+    } catch (error) {
+      console.error('Error creating schedule:', error.message);
+      process.exit(1);
+    }
+  });
+
+// List schedules
+program
+  .command('schedules')
+  .description('List all scheduled tasks')
+  .action(async () => {
+    try {
+      const { listSchedules } = await import('../task-lib/commands/schedules.js');
+      await listSchedules();
+    } catch (error) {
+      console.error('Error listing schedules:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Unschedule a task
+program
+  .command('unschedule <scheduleId>')
+  .description('Remove a scheduled task')
+  .action(async (scheduleId) => {
+    try {
+      const { deleteSchedule } = await import('../task-lib/commands/unschedule.js');
+      await deleteSchedule(scheduleId);
+    } catch (error) {
+      console.error('Error unscheduling:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Scheduler daemon management
+program
+  .command('scheduler <action>')
+  .description('Manage scheduler daemon (start, stop, status, logs)')
+  .action(async (action) => {
+    try {
+      const { schedulerCommand } = await import('../task-lib/commands/scheduler-cmd.js');
+      await schedulerCommand(action);
+    } catch (error) {
+      console.error('Error managing scheduler:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Get log path (machine-readable)
+program
+  .command('get-log-path <taskId>')
+  .description('Output log file path for a task (machine-readable)')
+  .action(async (taskId) => {
+    try {
+      const { getLogPath } = await import('../task-lib/commands/get-log-path.js');
+      await getLogPath(taskId);
+    } catch (error) {
+      console.error('Error getting log path:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Watch command - interactive TUI dashboard
+program
+  .command('watch')
+  .description('Interactive TUI to monitor clusters')
+  .option('--refresh-rate <ms>', 'Refresh interval in milliseconds', '1000')
+  .action(async (options) => {
+    try {
+      const TUI = require('../src/tui');
+      const tui = new TUI({
+        orchestrator: getOrchestrator(),
+        refreshRate: parseInt(options.refreshRate, 10),
+      });
+      await tui.start();
+    } catch (error) {
+      console.error('Error starting TUI:', error.message);
+      process.exit(1);
+    }
+  });
+
+// Settings management
+const settingsCmd = program.command('settings').description('Manage zeroshot settings');
+
+settingsCmd
+  .command('list')
+  .description('Show all settings')
+  .action(() => {
+    const settings = loadSettings();
+    console.log(chalk.bold('\nCrew Settings:\n'));
+    for (const [key, value] of Object.entries(settings)) {
+      const isDefault = DEFAULT_SETTINGS[key] === value;
+      const label = isDefault ? chalk.dim(key) : chalk.cyan(key);
+      const val = isDefault ? chalk.dim(String(value)) : chalk.white(String(value));
+      console.log(`  ${label.padEnd(30)} ${val}`);
+    }
+    console.log('');
+  });
+
+settingsCmd
+  .command('get <key>')
+  .description('Get a setting value')
+  .action((key) => {
+    const settings = loadSettings();
+    if (!(key in settings)) {
+      console.error(chalk.red(`Unknown setting: ${key}`));
+      console.log(chalk.dim('\nAvailable settings:'));
+      Object.keys(DEFAULT_SETTINGS).forEach((k) => console.log(chalk.dim(`  - ${k}`)));
+      process.exit(1);
+    }
+    console.log(settings[key]);
+  });
+
+settingsCmd
+  .command('set <key> <value>')
+  .description('Set a setting value')
+  .action((key, value) => {
+    if (!(key in DEFAULT_SETTINGS)) {
+      console.error(chalk.red(`Unknown setting: ${key}`));
+      console.log(chalk.dim('\nAvailable settings:'));
+      Object.keys(DEFAULT_SETTINGS).forEach((k) => console.log(chalk.dim(`  - ${k}`)));
+      process.exit(1);
+    }
+
+    const settings = loadSettings();
+
+    // Type coercion
+    let parsedValue;
+    try {
+      parsedValue = coerceValue(key, value);
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+
+    // Validation
+    const validationError = validateSetting(key, parsedValue);
+    if (validationError) {
+      console.error(chalk.red(validationError));
+      process.exit(1);
+    }
+
+    settings[key] = parsedValue;
+    saveSettings(settings);
+    console.log(chalk.green(`✓ Set ${key} = ${parsedValue}`));
+  });
+
+settingsCmd
+  .command('reset')
+  .description('Reset all settings to defaults')
+  .option('-y, --yes', 'Skip confirmation')
+  .action((options) => {
+    if (!options.yes) {
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      rl.question(chalk.yellow('Reset all settings to defaults? [y/N] '), (answer) => {
+        rl.close();
+        if (answer.toLowerCase() !== 'y') {
+          console.log('Aborted.');
+          return;
+        }
+        saveSettings(DEFAULT_SETTINGS);
+        console.log(chalk.green('✓ Settings reset to defaults'));
+      });
+    } else {
+      saveSettings(DEFAULT_SETTINGS);
+      console.log(chalk.green('✓ Settings reset to defaults'));
+    }
+  });
+
+// Add alias for settings list (just `zeroshot settings`)
+settingsCmd.action(() => {
+  // Default action when no subcommand - show list
+  const settings = loadSettings();
+  console.log(chalk.bold('\nCrew Settings:\n'));
+  for (const [key, value] of Object.entries(settings)) {
+    const isDefault = DEFAULT_SETTINGS[key] === value;
+    const label = isDefault ? chalk.dim(key) : chalk.cyan(key);
+    const val = isDefault ? chalk.dim(String(value)) : chalk.white(String(value));
+    console.log(`  ${label.padEnd(30)} ${val}`);
+  }
+  console.log('');
+  console.log(chalk.dim('Usage:'));
+  console.log(chalk.dim('  zeroshot settings set <key> <value>'));
+  console.log(chalk.dim('  zeroshot settings get <key>'));
+  console.log(chalk.dim('  zeroshot settings reset'));
+  console.log('');
+});
+
+// Config visualization commands
+const configCmd = program.command('config').description('Manage and visualize cluster configs');
+
+configCmd
+  .command('list')
+  .description('List available cluster configs')
+  .action(() => {
+    try {
+      const configsDir = path.join(PACKAGE_ROOT, 'cluster-templates');
+      const files = fs.readdirSync(configsDir).filter((f) => f.endsWith('.json'));
+
+      if (files.length === 0) {
+        console.log(chalk.dim('No configs found in examples/'));
+        return;
+      }
+
+      console.log(chalk.bold('\nAvailable configs:\n'));
+      for (const file of files) {
+        const configPath = path.join(configsDir, file);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const agentCount = config.agents?.length || 0;
+        const name = file.replace('.json', '');
+
+        console.log(`  ${chalk.cyan(name.padEnd(30))} ${chalk.dim(`${agentCount} agents`)}`);
+      }
+      console.log('');
+    } catch (error) {
+      console.error('Error listing configs:', error.message);
+      process.exit(1);
+    }
+  });
+
+configCmd
+  .command('show <name>')
+  .description('Visualize a cluster config')
+  .action((name) => {
+    try {
+      // Support both with and without .json extension
+      const configName = name.endsWith('.json') ? name : `${name}.json`;
+      const configPath = path.join(PACKAGE_ROOT, 'cluster-templates', configName);
+
+      if (!fs.existsSync(configPath)) {
+        console.error(chalk.red(`Config not found: ${configName}`));
+        console.log(chalk.dim('\nAvailable configs:'));
+        const files = fs
+          .readdirSync(path.join(PACKAGE_ROOT, 'cluster-templates'))
+          .filter((f) => f.endsWith('.json'));
+        files.forEach((f) => console.log(chalk.dim(`  - ${f.replace('.json', '')}`)));
+        process.exit(1);
+      }
+
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+      // Header
+      console.log('');
+      console.log(chalk.bold.cyan('═'.repeat(80)));
+      console.log(chalk.bold.cyan(`  Config: ${name.replace('.json', '')}`));
+      console.log(chalk.bold.cyan('═'.repeat(80)));
+      console.log('');
+
+      // Agents section
+      console.log(chalk.bold('Agents:\n'));
+
+      if (!config.agents || config.agents.length === 0) {
+        console.log(chalk.dim('  No agents defined'));
+      } else {
+        for (const agent of config.agents) {
+          const color = getColorForSender(agent.id);
+          console.log(color.bold(`  ${agent.id}`));
+          console.log(chalk.dim(`    Role: ${agent.role || 'none'}`));
+
+          if (agent.model) {
+            console.log(chalk.dim(`    Model: ${agent.model}`));
+          }
+
+          if (agent.triggers && agent.triggers.length > 0) {
+            // Triggers are objects with topic field
+            const triggerTopics = agent.triggers
+              .map((t) => (typeof t === 'string' ? t : t.topic))
+              .filter(Boolean);
+            console.log(chalk.dim(`    Triggers: ${triggerTopics.join(', ')}`));
+          } else {
+            console.log(chalk.dim(`    Triggers: none (manual only)`));
+          }
+
+          console.log('');
+        }
+      }
+
+      // Message flow visualization
+      if (config.agents && config.agents.length > 0) {
+        console.log(chalk.bold('Message Flow:\n'));
+
+        // Build trigger map: topic -> [agents that listen]
+        const triggerMap = new Map();
+        for (const agent of config.agents) {
+          if (agent.triggers) {
+            for (const trigger of agent.triggers) {
+              const topic = typeof trigger === 'string' ? trigger : trigger.topic;
+              if (topic) {
+                if (!triggerMap.has(topic)) {
+                  triggerMap.set(topic, []);
+                }
+                triggerMap.get(topic).push(agent.id);
+              }
+            }
+          }
+        }
+
+        if (triggerMap.size === 0) {
+          console.log(chalk.dim('  No automatic triggers defined\n'));
+        } else {
+          for (const [topic, agents] of triggerMap) {
+            console.log(
+              `  ${chalk.yellow(topic)} ${chalk.dim('→')} ${agents.map((a) => getColorForSender(a)(a)).join(', ')}`
+            );
+          }
+          console.log('');
+        }
+      }
+
+      console.log(chalk.bold.cyan('═'.repeat(80)));
+      console.log('');
+    } catch (error) {
+      console.error('Error showing config:', error.message);
+      process.exit(1);
+    }
+  });
+
+configCmd
+  .command('validate <configPath>')
+  .description('Validate a cluster config for structural issues')
+  .option('--strict', 'Treat warnings as errors')
+  .option('--json', 'Output as JSON')
+  .action((configPath, options) => {
+    try {
+      const { validateConfig, formatValidationResult } = require('../src/config-validator');
+
+      // Resolve path (support relative paths and built-in names)
+      let fullPath;
+      if (fs.existsSync(configPath)) {
+        fullPath = path.resolve(configPath);
+      } else {
+        // Try examples directory
+        const configName = configPath.endsWith('.json') ? configPath : `${configPath}.json`;
+        fullPath = path.join(PACKAGE_ROOT, 'cluster-templates', configName);
+        if (!fs.existsSync(fullPath)) {
+          console.error(chalk.red(`Config not found: ${configPath}`));
+          console.log(chalk.dim('\nAvailable built-in configs:'));
+          const files = fs
+            .readdirSync(path.join(PACKAGE_ROOT, 'cluster-templates'))
+            .filter((f) => f.endsWith('.json'));
+          files.forEach((f) => console.log(chalk.dim(`  - ${f.replace('.json', '')}`)));
+          process.exit(1);
+        }
+      }
+
+      // Load and validate
+      const config = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+      const result = validateConfig(config);
+
+      // Apply strict mode
+      if (options.strict && result.warnings.length > 0) {
+        result.errors.push(...result.warnings.map((w) => `[strict] ${w}`));
+        result.valid = false;
+      }
+
+      // Output
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log('');
+        console.log(chalk.bold(`Validating: ${path.basename(fullPath)}`));
+        console.log('');
+        console.log(formatValidationResult(result));
+        console.log('');
+      }
+
+      // Exit code
+      process.exit(result.valid ? 0 : 1);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        console.error(chalk.red(`Invalid JSON: ${error.message}`));
+      } else {
+        console.error(chalk.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  });
+
+// Helper function to keep the process alive for follow mode
+function keepProcessAlive(cleanupFn) {
+  // Prevent Node.js from exiting by keeping the event loop active
+  // Use setInterval with a long interval (1 hour) to minimize overhead
+  const keepAliveInterval = setInterval(() => {}, 3600000);
+
+  // Handle graceful shutdown on Ctrl+C
+  process.on('SIGINT', () => {
+    clearInterval(keepAliveInterval);
+    if (cleanupFn) cleanupFn();
+    console.log('\n\nStopped following logs.');
+    process.exit(0);
+  });
+
+  // Also handle SIGTERM for graceful shutdown
+  process.on('SIGTERM', () => {
+    clearInterval(keepAliveInterval);
+    if (cleanupFn) cleanupFn();
+    process.exit(0);
+  });
+}
+
+// Tool icons for different tool types
+function getToolIcon(toolName) {
+  const icons = {
+    Read: '📖',
+    Write: '📝',
+    Edit: '✏️',
+    Bash: '💻',
+    Glob: '🔍',
+    Grep: '🔎',
+    WebFetch: '🌐',
+    WebSearch: '🔎',
+    Task: '🤖',
+    TodoWrite: '📋',
+    AskUserQuestion: '❓',
+  };
+  return icons[toolName] || '🔧';
+}
+
+// Format tool call input for display
+function formatToolCall(toolName, input) {
+  if (!input) return '';
+
+  switch (toolName) {
+    case 'Bash':
+      return input.command ? `$ ${input.command}` : '';
+    case 'Read':
+      return input.file_path ? input.file_path.split('/').slice(-2).join('/') : '';
+    case 'Write':
+      return input.file_path ? `→ ${input.file_path.split('/').slice(-2).join('/')}` : '';
+    case 'Edit':
+      return input.file_path ? input.file_path.split('/').slice(-2).join('/') : '';
+    case 'Glob':
+      return input.pattern || '';
+    case 'Grep':
+      return input.pattern ? `/${input.pattern}/` : '';
+    case 'WebFetch':
+      return input.url ? input.url.substring(0, 50) : '';
+    case 'WebSearch':
+      return input.query ? `"${input.query}"` : '';
+    case 'Task':
+      return input.description || '';
+    case 'TodoWrite':
+      if (input.todos && Array.isArray(input.todos)) {
+        const statusCounts = {};
+        input.todos.forEach((todo) => {
+          statusCounts[todo.status] = (statusCounts[todo.status] || 0) + 1;
+        });
+        const parts = Object.entries(statusCounts).map(
+          ([status, count]) => `${count} ${status.replace('_', ' ')}`
+        );
+        return `${input.todos.length} todo${input.todos.length === 1 ? '' : 's'} (${parts.join(', ')})`;
+      }
+      return '';
+    case 'AskUserQuestion':
+      if (input.questions && Array.isArray(input.questions)) {
+        const q = input.questions[0];
+        const preview = q.question.substring(0, 50);
+        return input.questions.length > 1
+          ? `${input.questions.length} questions: "${preview}..."`
+          : `"${preview}${q.question.length > 50 ? '...' : ''}"`;
+      }
+      return '';
+    default:
+      // For unknown tools, show first key-value pair
+      const keys = Object.keys(input);
+      if (keys.length > 0) {
+        const val = String(input[keys[0]]).substring(0, 40);
+        return val.length < String(input[keys[0]]).length ? val + '...' : val;
+      }
+      return '';
+  }
+}
+
+// Format tool result for display
+function formatToolResult(content, isError, toolName, toolInput) {
+  if (!content) return isError ? 'error' : 'done';
+
+  // For errors, show full message
+  if (isError) {
+    const firstLine = content.split('\n')[0].substring(0, 80);
+    return chalk.red(firstLine);
+  }
+
+  // For TodoWrite, show the actual todo items
+  if (toolName === 'TodoWrite' && toolInput?.todos && Array.isArray(toolInput.todos)) {
+    const todos = toolInput.todos;
+    if (todos.length === 0) return chalk.dim('no todos');
+    if (todos.length === 1) {
+      const status =
+        todos[0].status === 'completed' ? '✓' : todos[0].status === 'in_progress' ? '⧗' : '○';
+      return chalk.dim(
+        `${status} ${todos[0].content.substring(0, 50)}${todos[0].content.length > 50 ? '...' : ''}`
+      );
+    }
+    // Multiple todos - show first one as preview
+    const status =
+      todos[0].status === 'completed' ? '✓' : todos[0].status === 'in_progress' ? '⧗' : '○';
+    return chalk.dim(
+      `${status} ${todos[0].content.substring(0, 40)}... (+${todos.length - 1} more)`
+    );
+  }
+
+  // For success, show summary
+  const lines = content.split('\n').filter((l) => l.trim());
+  if (lines.length === 0) return 'done';
+  if (lines.length === 1) {
+    const line = lines[0].substring(0, 60);
+    return chalk.dim(line.length < lines[0].length ? line + '...' : line);
+  }
+  // Multiple lines - show count
+  return chalk.dim(`${lines.length} lines`);
+}
+
+// Helper function to get deterministic color for an agent/sender based on name hash
+// Uses djb2 hash algorithm for good distribution across color palette
+function getColorForSender(sender) {
+  if (!agentColors.has(sender)) {
+    let hash = 5381;
+    for (let i = 0; i < sender.length; i++) {
+      hash = (hash << 5) + hash + sender.charCodeAt(i);
+    }
+    const colorIndex = Math.abs(hash) % COLORS.length;
+    agentColors.set(sender, COLORS[colorIndex]);
+  }
+  return agentColors.get(sender);
+}
+
+// Track recently seen content to avoid duplicates
+const recentContentHashes = new Set();
+const MAX_RECENT_HASHES = 100;
+
+// Track clusters that have already shown their NEW TASK header (suppress conductor re-publish)
+const shownNewTaskForCluster = new Set();
+
+function hashContent(content) {
+  // Simple hash for deduplication
+  return content.substring(0, 200);
+}
+
+function isDuplicate(content) {
+  const hash = hashContent(content);
+  if (recentContentHashes.has(hash)) {
+    return true;
+  }
+  recentContentHashes.add(hash);
+  // Prune old hashes
+  if (recentContentHashes.size > MAX_RECENT_HASHES) {
+    const arr = Array.from(recentContentHashes);
+    recentContentHashes.clear();
+    arr.slice(-50).forEach((h) => recentContentHashes.add(h));
+  }
+  return false;
+}
+
+// Format task summary from ISSUE_OPENED message - truncated for display
+function formatTaskSummary(issueOpened, maxLen = 35) {
+  const data = issueOpened.content?.data || {};
+  const issueNum = data.issue_number || data.number;
+  const title = data.title;
+  const url = data.url || data.html_url;
+
+  // Prefer: #N: Short title
+  if (issueNum && title) {
+    const truncatedTitle = title.length > maxLen ? title.slice(0, maxLen - 3) + '...' : title;
+    return `#${issueNum}: ${truncatedTitle}`;
+  }
+  if (issueNum) return `#${issueNum}`;
+
+  // Extract from URL
+  if (url) {
+    const match = url.match(/issues\/(\d+)/);
+    if (match) return `#${match[1]}`;
+  }
+
+  // Fallback: first meaningful line (for manual prompts)
+  const text = issueOpened.content?.text || 'Task';
+  const firstLine = text.split('\n').find((l) => l.trim() && !l.startsWith('#')) || 'Task';
+  return firstLine.slice(0, maxLen) + (firstLine.length > maxLen ? '...' : '');
+}
+
+// Set terminal title (works in most terminals)
+function setTerminalTitle(title) {
+  // ESC ] 0 ; <title> BEL
+  process.stdout.write(`\\x1b]0;${title}\x07`);
+}
+
+// Restore terminal title on exit
+function restoreTerminalTitle() {
+  // Reset to default (empty title lets terminal use its default)
+  process.stdout.write('\\x1b]0;\x07');
+}
+
+// Format markdown-style text for terminal display
+function formatMarkdownLine(line) {
+  let formatted = line;
+
+  // Headers: ## Header -> bold cyan
+  if (/^#{1,3}\s/.test(formatted)) {
+    formatted = formatted.replace(/^#{1,3}\s*/, '');
+    return chalk.bold.cyan(formatted);
+  }
+
+  // Blockquotes: > text -> dim italic with bar
+  if (/^>\s/.test(formatted)) {
+    formatted = formatted.replace(/^>\s*/, '');
+    return chalk.dim('│ ') + chalk.italic(formatted);
+  }
+
+  // Numbered lists: 1. item -> yellow number
+  const numMatch = formatted.match(/^(\d+)\.\s+(.*)$/);
+  if (numMatch) {
+    return chalk.yellow(numMatch[1] + '.') + ' ' + formatInlineMarkdown(numMatch[2]);
+  }
+
+  // Bullet lists: - item or * item -> dim bullet
+  const bulletMatch = formatted.match(/^[-*]\s+(.*)$/);
+  if (bulletMatch) {
+    return chalk.dim('•') + ' ' + formatInlineMarkdown(bulletMatch[1]);
+  }
+
+  // Checkboxes: - [ ] or - [x]
+  const checkMatch = formatted.match(/^[-*]\s+\[([ x])\]\s+(.*)$/i);
+  if (checkMatch) {
+    const checked = checkMatch[1].toLowerCase() === 'x';
+    const icon = checked ? chalk.green('✓') : chalk.dim('○');
+    return icon + ' ' + formatInlineMarkdown(checkMatch[2]);
+  }
+
+  return formatInlineMarkdown(formatted);
+}
+
+// Format inline markdown: **bold**, `code`
+function formatInlineMarkdown(text) {
+  let result = text;
+
+  // Bold: **text** -> bold
+  result = result.replace(/\*\*([^*]+)\*\*/g, (_, content) => chalk.bold(content));
+
+  // Inline code: `code` -> cyan dim
+  result = result.replace(/`([^`]+)`/g, (_, content) => chalk.cyan.dim(content));
+
+  return result;
+}
+
+// Line buffer per sender - tracks line state for prefix printing
+const lineBuffers = new Map();
+
+// Track current tool call per sender - needed for matching tool results with calls
+const currentToolCall = new Map();
+
+/**
+ * Render messages to terminal-style output with ANSI colors (same as zeroshot logs)
+ */
+function renderMessagesToTerminal(clusterId, messages) {
+  const lines = [];
+  const buffers = new Map(); // Line buffers per sender
+  const toolCalls = new Map(); // Track tool calls per sender
+
+  const getBuffer = (sender) => {
+    if (!buffers.has(sender)) {
+      buffers.set(sender, { text: '', needsPrefix: true });
+    }
+    return buffers.get(sender);
+  };
+
+  const flushBuffer = (sender, prefix) => {
+    const buf = buffers.get(sender);
+    if (buf && buf.text.trim()) {
+      const textLines = buf.text.split('\n');
+      for (const line of textLines) {
+        if (line.trim()) {
+          lines.push(`${prefix} ${formatMarkdownLine(line)}`);
+        }
+      }
+      buf.text = '';
+      buf.needsPrefix = true;
+    }
+  };
+
+  for (const msg of messages) {
+    const timestamp = new Date(msg.timestamp).toLocaleTimeString('en-US', {
+      hour12: false,
+    });
+    const color = getColorForSender(msg.sender);
+    const prefix = color(`${msg.sender.padEnd(15)} |`);
+
+    // AGENT_LIFECYCLE
+    if (msg.topic === 'AGENT_LIFECYCLE') {
+      const data = msg.content?.data;
+      const event = data?.event;
+      let icon, eventText;
+      switch (event) {
+        case 'STARTED':
+          icon = chalk.green('▶');
+          const triggers = data.triggers?.join(', ') || 'none';
+          eventText = `started (listening for: ${chalk.dim(triggers)})`;
+          break;
+        case 'TASK_STARTED':
+          icon = chalk.yellow('⚡');
+          eventText = `${chalk.cyan(data.triggeredBy)} → task #${data.iteration} (${chalk.dim(data.model)})`;
+          break;
+        case 'TASK_COMPLETED':
+          icon = chalk.green('✓');
+          eventText = `task #${data.iteration} completed`;
+          break;
+        default:
+          icon = chalk.dim('•');
+          eventText = event || 'unknown event';
+      }
+      lines.push(`${prefix} ${icon} ${eventText}`);
+      continue;
+    }
+
+    // ISSUE_OPENED
+    if (msg.topic === 'ISSUE_OPENED') {
+      lines.push('');
+      lines.push(chalk.bold.blue('─'.repeat(80)));
+      // Extract issue URL if present
+      const issueData = msg.content?.data || {};
+      const issueUrl = issueData.url || issueData.html_url;
+      const issueTitle = issueData.title;
+      const issueNum = issueData.issue_number || issueData.number;
+
+      if (issueUrl) {
+        lines.push(
+          `${prefix} ${chalk.gray(timestamp)} ${chalk.bold.blue('📋')} ${chalk.cyan(issueUrl)}`
+        );
+        if (issueTitle) {
+          lines.push(`${prefix} ${chalk.white(issueTitle)}`);
+        }
+      } else if (issueNum) {
+        lines.push(
+          `${prefix} ${chalk.gray(timestamp)} ${chalk.bold.blue('📋')} Issue #${issueNum}`
+        );
+        if (issueTitle) {
+          lines.push(`${prefix} ${chalk.white(issueTitle)}`);
+        }
+      } else {
+        // Fallback: show first line of text only
+        lines.push(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.blue('📋 TASK')}`);
+        if (msg.content?.text) {
+          const firstLine = msg.content.text
+            .split('\n')
+            .find((l) => l.trim() && l.trim() !== '# Manual Input');
+          if (firstLine) {
+            lines.push(`${prefix} ${chalk.white(firstLine.slice(0, 100))}`);
+          }
+        }
+      }
+      lines.push(chalk.bold.blue('─'.repeat(80)));
+      continue;
+    }
+
+    // IMPLEMENTATION_READY
+    if (msg.topic === 'IMPLEMENTATION_READY') {
+      lines.push(
+        `${prefix} ${chalk.gray(timestamp)} ${chalk.bold.yellow('✅ IMPLEMENTATION READY')}`
+      );
+      continue;
+    }
+
+    // VALIDATION_RESULT
+    if (msg.topic === 'VALIDATION_RESULT') {
+      const data = msg.content?.data || {};
+      const approved = data.approved === true || data.approved === 'true';
+      const icon = approved ? chalk.green('✓ APPROVED') : chalk.red('✗ REJECTED');
+      lines.push(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.magenta('VALIDATION_RESULT')}`);
+      lines.push(`${prefix}   ${icon} ${chalk.dim(data.summary || '')}`);
+      if (!approved) {
+        let issues = data.issues || data.errors;
+        if (typeof issues === 'string') {
+          try {
+            issues = JSON.parse(issues);
+          } catch {
+            issues = [];
+          }
+        }
+        if (Array.isArray(issues)) {
+          for (const issue of issues) {
+            lines.push(`${prefix}     ${chalk.red('•')} ${issue}`);
+          }
+        }
+      }
+      continue;
+    }
+
+    // PR_CREATED
+    if (msg.topic === 'PR_CREATED') {
+      lines.push('');
+      lines.push(chalk.bold.green('─'.repeat(80)));
+      lines.push(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('🔗 PR CREATED')}`);
+      if (msg.content?.data?.pr_url) {
+        lines.push(`${prefix} ${chalk.cyan(msg.content.data.pr_url)}`);
+      }
+      if (msg.content?.data?.merged) {
+        lines.push(`${prefix} ${chalk.bold.cyan('✓ MERGED')}`);
+      }
+      lines.push(chalk.bold.green('─'.repeat(80)));
+      continue;
+    }
+
+    // CLUSTER_COMPLETE
+    if (msg.topic === 'CLUSTER_COMPLETE') {
+      lines.push('');
+      lines.push(chalk.bold.green('─'.repeat(80)));
+      lines.push(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('✅ CLUSTER COMPLETE')}`);
+      lines.push(chalk.bold.green('─'.repeat(80)));
+      continue;
+    }
+
+    // AGENT_ERROR
+    if (msg.topic === 'AGENT_ERROR') {
+      lines.push('');
+      lines.push(chalk.bold.red('─'.repeat(80)));
+      lines.push(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.red('🔴 AGENT ERROR')}`);
+      if (msg.content?.text) {
+        lines.push(`${prefix} ${chalk.red(msg.content.text)}`);
+      }
+      lines.push(chalk.bold.red('─'.repeat(80)));
+      continue;
+    }
+
+    // AGENT_OUTPUT - parse streaming JSON
+    if (msg.topic === 'AGENT_OUTPUT') {
+      const content = msg.content?.data?.line || msg.content?.data?.chunk || msg.content?.text;
+      if (!content || !content.trim()) continue;
+
+      const events = parseChunk(content);
+      for (const event of events) {
+        switch (event.type) {
+          case 'text':
+            const buf = getBuffer(msg.sender);
+            buf.text += event.text;
+            // Print complete lines
+            while (buf.text.includes('\n')) {
+              const idx = buf.text.indexOf('\n');
+              const line = buf.text.slice(0, idx);
+              buf.text = buf.text.slice(idx + 1);
+              if (line.trim()) {
+                lines.push(`${prefix} ${formatMarkdownLine(line)}`);
+              }
+            }
+            break;
+          case 'tool_call':
+            flushBuffer(msg.sender, prefix);
+            const icon = getToolIcon(event.toolName);
+            const toolDesc = formatToolCall(event.toolName, event.input);
+            lines.push(`${prefix} ${icon} ${chalk.cyan(event.toolName)} ${chalk.dim(toolDesc)}`);
+            toolCalls.set(msg.sender, {
+              toolName: event.toolName,
+              input: event.input,
+            });
+            break;
+          case 'tool_result':
+            const status = event.isError ? chalk.red('✗') : chalk.green('✓');
+            const tc = toolCalls.get(msg.sender);
+            const resultDesc = formatToolResult(
+              event.content,
+              event.isError,
+              tc?.toolName,
+              tc?.input
+            );
+            lines.push(`${prefix}   ${status} ${resultDesc}`);
+            toolCalls.delete(msg.sender);
+            break;
+        }
+      }
+      continue;
+    }
+
+    // Other topics - show topic name
+    if (msg.topic && !['AGENT_OUTPUT', 'AGENT_LIFECYCLE'].includes(msg.topic)) {
+      lines.push(`${prefix} ${chalk.gray(timestamp)} ${chalk.yellow(msg.topic)}`);
+    }
+  }
+
+  // Flush any remaining buffers
+  for (const [sender, buf] of buffers) {
+    if (buf.text.trim()) {
+      const color = getColorForSender(sender);
+      const prefix = color(`${sender.padEnd(15)} |`);
+      for (const line of buf.text.split('\n')) {
+        if (line.trim()) {
+          lines.push(`${prefix} ${line}`);
+        }
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// Get terminal width for word wrapping
+function getTerminalWidth() {
+  return process.stdout.columns || 100;
+}
+
+// Word wrap text at terminal width, respecting word boundaries
+// Returns array of lines
+function wordWrap(text, maxWidth) {
+  if (!text || maxWidth <= 0) return [text];
+
+  const words = text.split(/(\s+)/); // Keep whitespace as separate tokens
+  const lines = [];
+  let currentLine = '';
+
+  for (const word of words) {
+    // If adding this word exceeds width, start new line
+    if (currentLine.length + word.length > maxWidth && currentLine.trim()) {
+      lines.push(currentLine.trimEnd());
+      currentLine = word.trimStart(); // Don't start new line with whitespace
+    } else {
+      currentLine += word;
+    }
+  }
+
+  if (currentLine.trim()) {
+    lines.push(currentLine.trimEnd());
+  }
+
+  return lines.length > 0 ? lines : [''];
+}
+
+function getLineBuffer(sender) {
+  if (!lineBuffers.has(sender)) {
+    // needsPrefix: true when at start of new line (need to print prefix)
+    // pendingNewline: text written but no newline yet (need newline before next prefix)
+    // textBuffer: accumulate text until we have a complete line
+    lineBuffers.set(sender, {
+      needsPrefix: true,
+      pendingNewline: false,
+      thinkingNeedsPrefix: true,
+      thinkingPendingNewline: false,
+      textBuffer: '', // NEW: buffer for accumulating text
+    });
+  }
+  return lineBuffers.get(sender);
+}
+
+// Accumulate text and print complete lines only
+// Word wrap long lines, aligning continuation with message column
+function accumulateText(prefix, sender, text) {
+  if (!text) return;
+  const buf = getLineBuffer(sender);
+
+  // Add incoming text to buffer
+  buf.textBuffer += text;
+
+  // Calculate widths for word wrapping
+  const prefixLen = chalk.reset(prefix).replace(/\\x1b\[[0-9;]*m/g, '').length + 1;
+  const termWidth = getTerminalWidth();
+  const contentWidth = Math.max(40, termWidth - prefixLen - 2);
+  const continuationPrefix = ' '.repeat(prefixLen);
+
+  // Process complete lines (ending with \n)
+  while (buf.textBuffer.includes('\n')) {
+    const newlineIdx = buf.textBuffer.indexOf('\n');
+    const completeLine = buf.textBuffer.slice(0, newlineIdx);
+    buf.textBuffer = buf.textBuffer.slice(newlineIdx + 1);
+
+    // Word wrap and print the complete line
+    const wrappedLines = wordWrap(completeLine, contentWidth);
+    for (let i = 0; i < wrappedLines.length; i++) {
+      const wrappedLine = wrappedLines[i];
+
+      // Print prefix (real or continuation)
+      if (buf.needsPrefix) {
+        process.stdout.write(`${prefix} `);
+        buf.needsPrefix = false;
+      } else if (i > 0) {
+        process.stdout.write(`${continuationPrefix}`);
+      }
+
+      if (wrappedLine.trim()) {
+        process.stdout.write(formatInlineMarkdown(wrappedLine));
+      }
+
+      // Newline after each wrapped segment
+      if (i < wrappedLines.length - 1) {
+        process.stdout.write('\n');
+      }
+    }
+
+    // Complete the line
+    process.stdout.write('\n');
+    buf.needsPrefix = true;
+    buf.pendingNewline = false;
+  }
+
+  // Mark that we have pending text (no newline yet)
+  if (buf.textBuffer.length > 0) {
+    buf.pendingNewline = true;
+  }
+}
+
+// Stream thinking text immediately with word wrapping
+function accumulateThinking(prefix, sender, text) {
+  if (!text) return;
+  const buf = getLineBuffer(sender);
+
+  // Calculate widths for word wrapping (same as accumulateText but with 💭 prefix)
+  const prefixLen = chalk.reset(prefix).replace(/\\x1b\[[0-9;]*m/g, '').length + 4; // +4 for " 💭 "
+  const termWidth = getTerminalWidth();
+  const contentWidth = Math.max(40, termWidth - prefixLen - 2);
+  const continuationPrefix = ' '.repeat(prefixLen);
+
+  let remaining = text;
+  while (remaining.length > 0) {
+    const newlineIdx = remaining.indexOf('\n');
+    const rawLine = newlineIdx === -1 ? remaining : remaining.slice(0, newlineIdx);
+
+    const wrappedLines = wordWrap(rawLine, contentWidth);
+
+    for (let i = 0; i < wrappedLines.length; i++) {
+      const wrappedLine = wrappedLines[i];
+
+      if (buf.thinkingNeedsPrefix) {
+        process.stdout.write(`${prefix} ${chalk.dim.italic('💭 ')}`);
+        buf.thinkingNeedsPrefix = false;
+      } else if (i > 0) {
+        process.stdout.write(`${continuationPrefix}`);
+      }
+
+      if (wrappedLine.trim()) {
+        process.stdout.write(chalk.dim.italic(wrappedLine));
+      }
+
+      if (i < wrappedLines.length - 1) {
+        process.stdout.write('\n');
+      }
+    }
+
+    if (newlineIdx === -1) {
+      buf.thinkingPendingNewline = true;
+      break;
+    } else {
+      process.stdout.write('\n');
+      buf.thinkingNeedsPrefix = true;
+      buf.thinkingPendingNewline = false;
+      remaining = remaining.slice(newlineIdx + 1);
+    }
+  }
+}
+
+// Flush pending content - just add newline if we have pending text
+function flushLineBuffer(prefix, sender) {
+  const buf = lineBuffers.get(sender);
+  if (!buf) return;
+
+  // CRITICAL: Flush any remaining text in textBuffer (text without trailing newline)
+  if (buf.textBuffer && buf.textBuffer.length > 0) {
+    // Calculate widths for word wrapping (same as accumulateText)
+    const prefixLen = chalk.reset(prefix).replace(/\\x1b\[[0-9;]*m/g, '').length + 1;
+    const termWidth = getTerminalWidth();
+    const contentWidth = Math.max(40, termWidth - prefixLen - 2);
+    const continuationPrefix = ' '.repeat(prefixLen);
+
+    const wrappedLines = wordWrap(buf.textBuffer, contentWidth);
+    for (let i = 0; i < wrappedLines.length; i++) {
+      const wrappedLine = wrappedLines[i];
+
+      if (buf.needsPrefix) {
+        process.stdout.write(`${prefix} `);
+        buf.needsPrefix = false;
+      } else if (i > 0) {
+        process.stdout.write(`${continuationPrefix}`);
+      }
+
+      if (wrappedLine.trim()) {
+        process.stdout.write(formatInlineMarkdown(wrappedLine));
+      }
+
+      if (i < wrappedLines.length - 1) {
+        process.stdout.write('\n');
+      }
+    }
+
+    // Clear the buffer
+    buf.textBuffer = '';
+    buf.pendingNewline = true; // Mark that we need a newline before next prefix
+  }
+
+  if (buf.pendingNewline) {
+    process.stdout.write('\n');
+    buf.needsPrefix = true;
+    buf.pendingNewline = false;
+  }
+  if (buf.thinkingPendingNewline) {
+    process.stdout.write('\n');
+    buf.thinkingNeedsPrefix = true;
+    buf.thinkingPendingNewline = false;
+  }
+}
+
+// Lines to filter out (noise, metadata, errors)
+const FILTERED_PATTERNS = [
+  // ct internal output
+  /^--- Following log/,
+  /--- Following logs/,
+  /Ctrl\+C to stop/,
+  /^=== Claude Task:/,
+  /^Started:/,
+  /^Finished:/,
+  /^Exit code:/,
+  /^CWD:/,
+  /^={50}$/,
+  // Agent context metadata
+  /^Prompt: You are agent/,
+  /^Iteration:/,
+  /^## Triggering Message/,
+  /^## Messages from topic:/,
+  /^## Instructions/,
+  /^## Output Format/,
+  /^Topic: [A-Z_]+$/,
+  /^Sender:/,
+  /^Data: \{/,
+  /^"issue_number"/,
+  /^"title"/,
+  /^"commit"/,
+  /^\[\d{4}-\d{2}-\d{2}T/, // ISO timestamps
+  /^# Manual Input$/,
+  // Task errors (internal)
+  /^Task not found:/,
+  // JSON fragments
+  /^\s*\{$/,
+  /^\s*\}$/,
+  /^\s*"[a-z_]+":.*,?\s*$/,
+  // Template variables (unresolved)
+  /\{\{[a-z.]+\}\}/,
+];
+
+// Helper function to print a message (docker-compose style with colors)
+function printMessage(msg, showClusterId = false, watchMode = false, isActive = true) {
+  const timestamp = new Date(msg.timestamp).toLocaleTimeString('en-US', {
+    hour12: false,
+  });
+  // Use dim colors for inactive clusters
+  const color = isActive ? getColorForSender(msg.sender) : chalk.dim;
+
+  // Build prefix with optional cluster ID and model (sender_model is set by agent-wrapper._publish)
+  let senderLabel = msg.sender;
+  if (showClusterId && msg.cluster_id) {
+    senderLabel = `${msg.cluster_id}/${msg.sender}`;
+  }
+  const modelSuffix = msg.sender_model ? chalk.dim(` [${msg.sender_model}]`) : '';
+  const prefix = color(`${senderLabel.padEnd(showClusterId ? 25 : 15)} |`) + modelSuffix;
+
+  // Watch mode: ONLY show high-level business events in human-readable format
+  if (watchMode) {
+    // Skip low-level topics (too noisy for watch mode)
+    if (msg.topic === 'AGENT_OUTPUT' || msg.topic === 'AGENT_LIFECYCLE') {
+      return;
+    }
+
+    // Clear status line, print message, will be redrawn by status interval
+    process.stdout.write('\r' + ' '.repeat(120) + '\r');
+
+    // Simplified prefix for watch mode: just cluster ID (white = alive, grey = dead)
+    const clusterPrefix = isActive
+      ? chalk.white(`${msg.cluster_id.padEnd(20)} |`)
+      : chalk.dim(`${msg.cluster_id.padEnd(20)} |`);
+
+    // AGENT_ERROR: Show errors prominently
+    if (msg.topic === 'AGENT_ERROR') {
+      const errorMsg = `${msg.sender} ${chalk.bold.red('ERROR')}`;
+      console.log(`${clusterPrefix} ${errorMsg}`);
+      if (msg.content?.text) {
+        console.log(`${clusterPrefix}   ${chalk.red(msg.content.text)}`);
+      }
+      return;
+    }
+
+    // Human-readable event descriptions (with consistent agent colors)
+    const agentColor = getColorForSender(msg.sender);
+    const agentName = agentColor(msg.sender);
+    let eventText = '';
+
+    switch (msg.topic) {
+      case 'ISSUE_OPENED':
+        const issueNum = msg.content?.data?.issue_number || '';
+        const title = msg.content?.data?.title || '';
+        const prompt = msg.content?.data?.prompt || msg.content?.text || '';
+
+        // If it's manual input, show the prompt instead of "Manual Input"
+        const taskDesc = title === 'Manual Input' && prompt ? prompt : title;
+        const truncatedDesc =
+          taskDesc && taskDesc.length > 60 ? taskDesc.substring(0, 60) + '...' : taskDesc;
+
+        eventText = `Started ${issueNum ? `#${issueNum}` : 'task'}${truncatedDesc ? chalk.dim(` - ${truncatedDesc}`) : ''}`;
+        break;
+
+      case 'IMPLEMENTATION_READY':
+        eventText = `${agentName} completed implementation`;
+        break;
+
+      case 'VALIDATION_RESULT':
+        const data = msg.content?.data;
+        const approved = data?.approved === 'true' || data?.approved === true;
+        const status = approved ? chalk.green('APPROVED') : chalk.red('REJECTED');
+        eventText = `${agentName} ${status}`;
+        if (data?.summary && !approved) {
+          eventText += chalk.dim(` - ${data.summary}`);
+        }
+        console.log(`${clusterPrefix} ${eventText}`);
+
+        // Show rejection details (character counts only)
+        if (!approved) {
+          let errors = data.errors;
+          let issues = data.issues;
+
+          if (typeof errors === 'string') {
+            try {
+              errors = JSON.parse(errors);
+            } catch {
+              errors = [];
+            }
+          }
+          if (typeof issues === 'string') {
+            try {
+              issues = JSON.parse(issues);
+            } catch {
+              issues = [];
+            }
+          }
+
+          // Calculate total character counts
+          let errorsCharCount = 0;
+          let issuesCharCount = 0;
+
+          if (Array.isArray(errors) && errors.length > 0) {
+            errorsCharCount = JSON.stringify(errors).length;
+            console.log(
+              `${clusterPrefix}   ${chalk.red('•')} ${errors.length} error${errors.length > 1 ? 's' : ''} (${errorsCharCount} chars)`
+            );
+          }
+
+          if (Array.isArray(issues) && issues.length > 0) {
+            issuesCharCount = JSON.stringify(issues).length;
+            console.log(
+              `${clusterPrefix}   ${chalk.yellow('•')} ${issues.length} issue${issues.length > 1 ? 's' : ''} (${issuesCharCount} chars)`
+            );
+          }
+        }
+        return;
+
+      case 'PR_CREATED':
+        const prNum = msg.content?.data?.pr_number || '';
+        eventText = `${agentName} created PR${prNum ? ` #${prNum}` : ''}`;
+        break;
+
+      case 'PR_MERGED':
+        eventText = `${agentName} merged PR`;
+        break;
+
+      default:
+        // Fallback for unknown topics
+        eventText = `${agentName} ${msg.topic.toLowerCase().replace(/_/g, ' ')}`;
+    }
+
+    console.log(`${clusterPrefix} ${eventText}`);
+    return;
+  }
+
+  // AGENT_LIFECYCLE: Show agent start/trigger/task events
+  if (msg.topic === 'AGENT_LIFECYCLE') {
+    const data = msg.content?.data;
+    const event = data?.event;
+
+    let icon, eventText;
+    switch (event) {
+      case 'STARTED':
+        icon = chalk.green('▶');
+        const triggers = data.triggers?.join(', ') || 'none';
+        eventText = `started (listening for: ${chalk.dim(triggers)})`;
+        break;
+      case 'TASK_STARTED':
+        icon = chalk.yellow('⚡');
+        eventText = `${chalk.cyan(data.triggeredBy)} → task #${data.iteration} (${chalk.dim(data.model)})`;
+        break;
+      case 'TASK_COMPLETED':
+        icon = chalk.green('✓');
+        eventText = `task #${data.iteration} completed`;
+        break;
+      default:
+        icon = chalk.dim('•');
+        eventText = event || 'unknown event';
+    }
+
+    console.log(`${prefix} ${icon} ${eventText}`);
+    return;
+  }
+
+  // AGENT_OUTPUT: parse streaming JSON and display all content
+  if (msg.topic === 'AGENT_OUTPUT') {
+    // Support both old 'chunk' and new 'line' formats
+    const content = msg.content?.data?.line || msg.content?.data?.chunk || msg.content?.text;
+    if (!content || !content.trim()) return;
+
+    // Parse streaming JSON events using the parser
+    const events = parseChunk(content);
+
+    for (const event of events) {
+      switch (event.type) {
+        case 'text':
+          // Accumulate text, print complete lines
+          accumulateText(prefix, msg.sender, event.text);
+          break;
+
+        case 'thinking':
+        case 'thinking_start':
+          // Accumulate thinking, print complete lines
+          if (event.text) {
+            accumulateThinking(prefix, msg.sender, event.text);
+          } else if (event.type === 'thinking_start') {
+            console.log(`${prefix} ${chalk.dim.italic('💭 thinking...')}`);
+          }
+          break;
+
+        case 'tool_start':
+          // Flush pending text before tool - don't print, tool_call has details
+          flushLineBuffer(prefix, msg.sender);
+          break;
+
+        case 'tool_call':
+          // Flush pending text before tool
+          flushLineBuffer(prefix, msg.sender);
+          const icon = getToolIcon(event.toolName);
+          const toolDesc = formatToolCall(event.toolName, event.input);
+          console.log(`${prefix} ${icon} ${chalk.cyan(event.toolName)} ${chalk.dim(toolDesc)}`);
+          // Store tool call info for matching with result
+          currentToolCall.set(msg.sender, {
+            toolName: event.toolName,
+            input: event.input,
+          });
+          break;
+
+        case 'tool_input':
+          // Streaming tool input JSON - skip (shown in tool_call)
+          break;
+
+        case 'tool_result':
+          const status = event.isError ? chalk.red('✗') : chalk.green('✓');
+          // Get stored tool call info for better formatting
+          const toolCall = currentToolCall.get(msg.sender);
+          const resultDesc = formatToolResult(
+            event.content,
+            event.isError,
+            toolCall?.toolName,
+            toolCall?.input
+          );
+          console.log(`${prefix}   ${status} ${resultDesc}`);
+          // Clear stored tool call after result
+          currentToolCall.delete(msg.sender);
+          break;
+
+        case 'result':
+          // Flush remaining buffer before result
+          flushLineBuffer(prefix, msg.sender);
+          // Final result - only show errors (success text already streamed)
+          if (!event.success) {
+            console.log(`${prefix} ${chalk.bold.red('✗ Error:')} ${event.error || 'Task failed'}`);
+          }
+          break;
+
+        case 'block_end':
+          // Block ended - skip
+          break;
+
+        default:
+          // Unknown event type - skip
+          break;
+      }
+    }
+
+    // If no JSON events parsed, fall through to text filtering
+    if (events.length === 0) {
+      const lines = content.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // Check against filtered patterns
+        let shouldSkip = false;
+        for (const pattern of FILTERED_PATTERNS) {
+          if (pattern.test(trimmed)) {
+            shouldSkip = true;
+            break;
+          }
+        }
+        if (shouldSkip) continue;
+
+        // Skip JSON-like content
+        if (
+          (trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+          (trimmed.startsWith('[') && trimmed.endsWith(']'))
+        )
+          continue;
+
+        // Skip duplicate content
+        if (isDuplicate(trimmed)) continue;
+
+        console.log(`${prefix} ${line}`);
+      }
+    }
+    return;
+  }
+
+  // AGENT_ERROR: Show errors with visual prominence
+  if (msg.topic === 'AGENT_ERROR') {
+    console.log(''); // Blank line before error
+    console.log(chalk.bold.red(`${'─'.repeat(60)}`));
+    console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.red('🔴 AGENT ERROR')}`);
+    if (msg.content?.text) {
+      console.log(`${prefix} ${chalk.red(msg.content.text)}`);
+    }
+    if (msg.content?.data?.stack) {
+      // Show first 5 lines of stack trace
+      const stackLines = msg.content.data.stack.split('\n').slice(0, 5);
+      for (const line of stackLines) {
+        if (line.trim()) {
+          console.log(`${prefix} ${chalk.dim(line)}`);
+        }
+      }
+    }
+    console.log(chalk.bold.red(`${'─'.repeat(60)}`));
+    return;
+  }
+
+  // ISSUE_OPENED: Show as task header with visual separation
+  // Skip duplicate - conductor re-publishes after spawning agents (same task, confusing UX)
+  if (msg.topic === 'ISSUE_OPENED') {
+    if (shownNewTaskForCluster.has(msg.cluster_id)) {
+      return; // Already shown NEW TASK for this cluster
+    }
+    shownNewTaskForCluster.add(msg.cluster_id);
+
+    console.log(''); // Blank line before new task
+    console.log(chalk.bold.blue(`${'─'.repeat(60)}`));
+    console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.blue('📋 NEW TASK')}`);
+    if (msg.content?.text) {
+      // Show task description (first 3 lines max)
+      const lines = msg.content.text.split('\n').slice(0, 3);
+      for (const line of lines) {
+        if (line.trim() && line.trim() !== '# Manual Input') {
+          console.log(`${prefix} ${chalk.white(line)}`);
+        }
+      }
+    }
+    console.log(chalk.bold.blue(`${'─'.repeat(60)}`));
+    return;
+  }
+
+  // IMPLEMENTATION_READY: milestone marker
+  if (msg.topic === 'IMPLEMENTATION_READY') {
+    console.log(
+      `${prefix} ${chalk.gray(timestamp)} ${chalk.bold.yellow('✅ IMPLEMENTATION READY')}`
+    );
+    if (msg.content?.data?.commit) {
+      console.log(
+        `${prefix} ${chalk.gray('Commit:')} ${chalk.cyan(msg.content.data.commit.substring(0, 8))}`
+      );
+    }
+    return;
+  }
+
+  // VALIDATION_RESULT: show approval/rejection clearly
+  if (msg.topic === 'VALIDATION_RESULT') {
+    const data = msg.content?.data || {};
+    const approved = data.approved === true || data.approved === 'true';
+    const status = approved ? chalk.bold.green('✓ APPROVED') : chalk.bold.red('✗ REJECTED');
+
+    console.log(`${prefix} ${chalk.gray(timestamp)} ${status}`);
+
+    // Show summary if present and not a template variable
+    if (msg.content?.text && !msg.content.text.includes('{{')) {
+      console.log(`${prefix} ${msg.content.text.substring(0, 100)}`);
+    }
+
+    // Show full JSON data structure
+    console.log(
+      `${prefix} ${chalk.dim(JSON.stringify(data, null, 2).split('\n').join(`\n${prefix} `))}`
+    );
+
+    // Show errors/issues if any
+    if (data.errors && Array.isArray(data.errors) && data.errors.length > 0) {
+      console.log(`${prefix} ${chalk.red('Errors:')}`);
+      data.errors.forEach((err) => {
+        if (err && typeof err === 'string') {
+          console.log(`${prefix}   - ${err}`);
+        }
+      });
+    }
+
+    if (data.issues && Array.isArray(data.issues) && data.issues.length > 0) {
+      console.log(`${prefix} ${chalk.yellow('Issues:')}`);
+      data.issues.forEach((issue) => {
+        if (issue && typeof issue === 'string') {
+          console.log(`${prefix}   - ${issue}`);
+        }
+      });
+    }
+    return;
+  }
+
+  // PR_CREATED: show PR created banner
+  if (msg.topic === 'PR_CREATED') {
+    console.log('');
+    console.log(chalk.bold.green(`${'─'.repeat(60)}`));
+    console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('🔗 PR CREATED')}`);
+    if (msg.content?.data?.pr_url) {
+      console.log(`${prefix} ${chalk.cyan(msg.content.data.pr_url)}`);
+    }
+    if (msg.content?.data?.merged) {
+      console.log(`${prefix} ${chalk.bold.cyan('✓ MERGED')}`);
+    }
+    console.log(chalk.bold.green(`${'─'.repeat(60)}`));
+    return;
+  }
+
+  // CLUSTER_COMPLETE: show completion banner
+  if (msg.topic === 'CLUSTER_COMPLETE') {
+    console.log('');
+    console.log(chalk.bold.green(`${'═'.repeat(60)}`));
+    console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('✅ CLUSTER COMPLETED')}`);
+    if (msg.content?.text) {
+      console.log(`${prefix} ${chalk.white(msg.content.text)}`);
+    }
+    if (msg.content?.data?.reason) {
+      console.log(`${prefix} ${chalk.dim('Reason:')} ${msg.content.data.reason}`);
+    }
+    console.log(chalk.bold.green(`${'═'.repeat(60)}`));
+    console.log('');
+    return;
+  }
+
+  // Other topics: generic display
+  const topicColor = msg.topic.startsWith('TASK_')
+    ? chalk.bold.green
+    : msg.topic.startsWith('ERROR')
+      ? chalk.bold.red
+      : chalk.bold;
+
+  console.log(`${prefix} ${chalk.gray(timestamp)} ${topicColor(msg.topic)}`);
+
+  // Show text content (skip template variables)
+  if (msg.content?.text && !msg.content.text.includes('{{')) {
+    const lines = msg.content.text.split('\n');
+    for (const line of lines) {
+      if (line.trim()) {
+        console.log(`${prefix} ${line}`);
+      }
+    }
+  }
+}
+
+// Default command handling: if first arg doesn't match a known command, treat it as 'run'
+// This allows `zeroshot "task"` to work the same as `zeroshot run "task"`
+const args = process.argv.slice(2);
+if (args.length > 0) {
+  const firstArg = args[0];
+
+  // Skip if it's a flag/option (starts with -)
+  // Skip if it's --help or --version (these are handled by commander)
+  if (!firstArg.startsWith('-')) {
+    // Get all registered command names
+    const commandNames = program.commands.map((cmd) => cmd.name());
+
+    // If first arg is not a known command, prepend 'run'
+    if (!commandNames.includes(firstArg)) {
+      process.argv.splice(2, 0, 'run');
+    }
+  }
+}
+
+program.parse();