@litmers/cursorflow-orchestrator 0.1.31 → 0.1.34

package/src/cli/config.ts

@@ -0,0 +1,177 @@
+/**
+ * CursorFlow 'config' command
+ * 
+ * View and set configuration values
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from '../utils/logger';
+import { loadConfig, findProjectRoot } from '../utils/config';
+import { safeJoin } from '../utils/path';
+
+interface ConfigOptions {
+  key: string | null;
+  value: string | null;
+  list: boolean;
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+\x1b[1mcursorflow config\x1b[0m - 설정 조회 및 변경
+
+\x1b[1m사용법:\x1b[0m
+  cursorflow config                     # 현재 설정 보기
+  cursorflow config <key>               # 특정 설정 값 보기
+  cursorflow config <key> <value>       # 설정 값 변경
+
+\x1b[1m주요 설정 키:\x1b[0m
+  defaultModel       기본 AI 모델 (예: gemini-3-flash)
+  branchPrefix       브랜치 접두사 (예: feature/)
+  executor           실행기 (cursor-agent | cloud)
+
+\x1b[1m예시:\x1b[0m
+  # 현재 설정 보기
+  cursorflow config
+
+  # 기본 모델 확인
+  cursorflow config defaultModel
+
+  # 기본 모델 변경
+  cursorflow config defaultModel opus-4.5-thinking
+
+\x1b[1m참고:\x1b[0m
+  설정 파일 위치: cursorflow.config.js
+  설정을 영구 저장하려면 cursorflow.config.js 파일을 직접 수정하세요.
+  `);
+}
+
+function parseArgs(args: string[]): ConfigOptions {
+  const result: ConfigOptions = {
+    key: null,
+    value: null,
+    list: false,
+    help: false,
+  };
+
+  let positionalCount = 0;
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg === '--help' || arg === '-h') {
+      result.help = true;
+    } else if (arg === '--list' || arg === '-l') {
+      result.list = true;
+    } else if (!arg.startsWith('--')) {
+      if (positionalCount === 0) {
+        result.key = arg;
+      } else if (positionalCount === 1) {
+        result.value = arg;
+      }
+      positionalCount++;
+    }
+  }
+
+  return result;
+}
+
+async function config(args: string[]): Promise<void> {
+  const options = parseArgs(args);
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const projectRoot = findProjectRoot();
+  const currentConfig = loadConfig(projectRoot);
+  const configPath = safeJoin(projectRoot, 'cursorflow.config.js');
+
+  // If setting a value
+  if (options.key && options.value) {
+    const key = options.key;
+    const value = options.value;
+    
+    // Validate key exists
+    if (!(key in currentConfig)) {
+      logger.error(`알 수 없는 설정 키: ${key}`);
+      console.log('\n사용 가능한 키: defaultModel, branchPrefix, executor, ...');
+      process.exit(1);
+    }
+
+    // Update or create config file
+    let configContent: string;
+    
+    if (fs.existsSync(configPath)) {
+      // Read existing config
+      const existingContent = fs.readFileSync(configPath, 'utf-8');
+      
+      // Simple regex replace for the key
+      const keyRegex = new RegExp(`(${key}\\s*:\\s*)['"]?[^'",\\n]+['"]?`, 'g');
+      if (keyRegex.test(existingContent)) {
+        configContent = existingContent.replace(keyRegex, `$1'${value}'`);
+      } else {
+        // Add the key to the config
+        configContent = existingContent.replace(
+          /module\.exports\s*=\s*\{/,
+          `module.exports = {\n  ${key}: '${value}',`
+        );
+      }
+    } else {
+      // Create new config file
+      configContent = `module.exports = {
+  ${key}: '${value}',
+};
+`;
+    }
+
+    fs.writeFileSync(configPath, configContent);
+    logger.success(`✅ ${key} = '${value}' 설정됨`);
+    console.log(`\n설정 파일: ${configPath}`);
+    return;
+  }
+
+  // If viewing a specific key
+  if (options.key) {
+    const key = options.key;
+    
+    if (!(key in currentConfig)) {
+      logger.error(`알 수 없는 설정 키: ${key}`);
+      process.exit(1);
+    }
+
+    const value = (currentConfig as any)[key];
+    console.log(`${key} = ${JSON.stringify(value)}`);
+    return;
+  }
+
+  // List all config
+  logger.section('CursorFlow 설정');
+  console.log('');
+  
+  const importantKeys = [
+    'defaultModel',
+    'branchPrefix',
+    'executor',
+    'flowsDir',
+    'tasksDir',
+    'logsDir',
+  ];
+
+  console.log('\x1b[1m주요 설정:\x1b[0m');
+  for (const key of importantKeys) {
+    const value = (currentConfig as any)[key];
+    console.log(`  ${key.padEnd(20)} ${JSON.stringify(value)}`);
+  }
+
+  console.log('');
+  console.log(`설정 파일: ${configPath}`);
+  console.log('');
+  console.log('설정 변경: cursorflow config <key> <value>');
+  console.log('예: cursorflow config defaultModel opus-4.5-thinking');
+}
+
+export = config;
+

package/src/cli/index.ts

@@ -12,6 +12,11 @@ type CommandFn = (args: string[]) => Promise<void>;
  */
 const COMMANDS: Record<string, CommandFn> = {
   init: require('./init'),
+  // New Flow architecture commands
+  new: require('./new'),
+  add: require('./add'),
+  config: require('./config'),
+  // Legacy prepare command (deprecated)
   prepare: require('./prepare'),
   run: require('./run'),
   monitor: require('./monitor'),
@@ -21,7 +26,6 @@ const COMMANDS: Record<string, CommandFn> = {
   signal: require('./signal'),
   models: require('./models'),
   logs: require('./logs'),
-  runs: require('./runs'),
   tasks: require('./tasks'),
   stop: require('./stop'),
   setup: require('./setup-commands').main,
@@ -35,37 +39,37 @@ function printHelp(): void {
 \x1b[1mUSAGE\x1b[0m
   $ \x1b[32mcursorflow\x1b[0m <command> [options]
 
-\x1b[1mCOMMANDS\x1b[0m
-  \x1b[33minit\x1b[0m [options]              Initialize CursorFlow in project
-  \x1b[33msetup\x1b[0m [options]             Install Cursor IDE commands
-  \x1b[33mprepare\x1b[0m <feature> [opts]    Prepare task directory and JSON files
-  \x1b[33mrun\x1b[0m <tasks-dir> [options]   Run orchestration (DAG-based)
-  \x1b[33mmonitor\x1b[0m [run-dir] [options] \x1b[36mInteractive\x1b[0m lane dashboard
-  \x1b[33mtasks\x1b[0m [name] [options]      Browse and validate prepared tasks
-  \x1b[33mruns\x1b[0m [run-id] [options]     List and view run details
-  \x1b[33mstop\x1b[0m [run-id] [options]     Stop running workflows
-  \x1b[33mclean\x1b[0m <type> [options]      Clean branches/worktrees/logs/tasks
-  \x1b[33mresume\x1b[0m [lane] [options]     Resume lane(s) - use --all for batch resume
-  \x1b[33mdoctor\x1b[0m [options]            Check environment and preflight
-  \x1b[33msignal\x1b[0m <lane> <msg>         Directly intervene in a running lane
-  \x1b[33mmodels\x1b[0m [options]            List available AI models
-  \x1b[33mlogs\x1b[0m [run-dir] [options]    View, export, and follow logs
-
-\x1b[1mGLOBAL OPTIONS\x1b[0m
-  --config <path>             Config file path
-  --help, -h                  Show help
-  --version, -v               Show version
-
-\x1b[1mEXAMPLES\x1b[0m
-  $ \x1b[32mcursorflow init --example\x1b[0m
-  $ \x1b[32mcursorflow prepare NewFeature --lanes 3\x1b[0m
-  $ \x1b[32mcursorflow run _cursorflow/tasks/MyFeature/\x1b[0m
-  $ \x1b[32mcursorflow monitor latest\x1b[0m
-  $ \x1b[32mcursorflow logs --all --follow\x1b[0m
-  $ \x1b[32mcursorflow runs --running\x1b[0m
-  $ \x1b[32mcursorflow resume --all\x1b[0m
-  $ \x1b[32mcursorflow doctor\x1b[0m
-  $ \x1b[32mcursorflow models\x1b[0m
+\x1b[1mFLOW COMMANDS (New)\x1b[0m
+  \x1b[33mnew\x1b[0m <flow> --lanes "..."     Create a new Flow with Lanes
+  \x1b[33madd\x1b[0m <flow> <lane> --task    Add Tasks to a Lane
+  \x1b[33mconfig\x1b[0m [key] [value]        View or set config (e.g., defaultModel)
+
+\x1b[1mEXECUTION\x1b[0m
+  \x1b[33mrun\x1b[0m <flow> [options]         Run orchestration (DAG-based)
+  \x1b[33mmonitor\x1b[0m [run-dir] [options]  \x1b[36mInteractive\x1b[0m lane dashboard
+  \x1b[33mstop\x1b[0m [run-id] [options]      Stop running workflows
+  \x1b[33mresume\x1b[0m [lane] [options]      Resume lane(s)
+
+\x1b[1mINSPECTION\x1b[0m
+  \x1b[33mtasks\x1b[0m [name] [options]       Browse and validate prepared tasks
+  \x1b[33mlogs\x1b[0m [run-dir] [options]     View, export, and follow logs
+  \x1b[33mdoctor\x1b[0m [options]             Check environment and preflight
+
+\x1b[1mUTILITY\x1b[0m
+  \x1b[33minit\x1b[0m [options]               Initialize CursorFlow in project
+  \x1b[33msetup\x1b[0m [options]              Install Cursor IDE commands
+  \x1b[33mclean\x1b[0m <type> [options]       Clean branches/worktrees/logs/tasks
+  \x1b[33msignal\x1b[0m <lane> <msg>          Directly intervene in a running lane
+  \x1b[33mmodels\x1b[0m [options]             List available AI models
+
+\x1b[1mLEGACY\x1b[0m
+  \x1b[33mprepare\x1b[0m <feature> [opts]     (deprecated) Use 'new' + 'add' instead
+
+\x1b[1mQUICK START\x1b[0m
+  $ \x1b[32mcursorflow new MyFeature --lanes "backend,frontend"\x1b[0m
+  $ \x1b[32mcursorflow add MyFeature backend --task "name=impl|model=sonnet-4.5|prompt=API 구현"\x1b[0m
+  $ \x1b[32mcursorflow add MyFeature frontend --task "name=ui|model=sonnet-4.5|prompt=UI 구현" --after "backend"\x1b[0m
+  $ \x1b[32mcursorflow run MyFeature\x1b[0m
 
 \x1b[1mDOCUMENTATION\x1b[0m
   https://github.com/eungjin-cigro/cursorflow#readme

package/src/cli/logs.ts

@@ -160,17 +160,12 @@ function displayTextLogs(
   let logFile: string;
   const readableLog = safeJoin(laneDir, 'terminal-readable.log');
   const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-  const cleanLog = safeJoin(laneDir, 'terminal.log');
 
   if (options.raw) {
     logFile = rawLog;
-  } else if (options.clean) {
-    logFile = cleanLog;
-  } else if (options.readable && fs.existsSync(readableLog)) {
-    logFile = readableLog;
   } else {
-    // Default or fallback to clean log
-    logFile = cleanLog;
+    // Default to readable log (clean option also uses readable now)
+    logFile = readableLog;
   }
   
   if (!fs.existsSync(logFile)) {
@@ -686,17 +681,12 @@ function followLogs(laneDir: string, options: LogsOptions): void {
   let logFile: string;
   const readableLog = safeJoin(laneDir, 'terminal-readable.log');
   const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-  const cleanLog = safeJoin(laneDir, 'terminal.log');
 
   if (options.raw) {
     logFile = rawLog;
-  } else if (options.clean) {
-    logFile = cleanLog;
-  } else if (options.readable && fs.existsSync(readableLog)) {
-    logFile = readableLog;
   } else {
-    // Default or fallback to clean log
-    logFile = cleanLog;
+    // Default to readable log
+    logFile = readableLog;
   }
   
   if (!fs.existsSync(logFile)) {
@@ -778,16 +768,14 @@ function displaySummary(runDir: string): void {
   
   for (const lane of lanes) {
     const laneDir = safeJoin(runDir, 'lanes', lane);
-    const cleanLog = safeJoin(laneDir, 'terminal.log');
     const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-    const jsonLog = safeJoin(laneDir, 'terminal.jsonl');
     const readableLog = safeJoin(laneDir, 'terminal-readable.log');
     
     console.log(`  ${logger.COLORS.green}📁 ${lane}${logger.COLORS.reset}`);
     
-    if (fs.existsSync(cleanLog)) {
-      const stats = fs.statSync(cleanLog);
-      console.log(`     └─ terminal.log          ${formatSize(stats.size)}`);
+    if (fs.existsSync(readableLog)) {
+      const stats = fs.statSync(readableLog);
+      console.log(`     └─ terminal-readable.log ${formatSize(stats.size)} ${logger.COLORS.yellow}(default)${logger.COLORS.reset}`);
     }
     
     if (fs.existsSync(rawLog)) {
@@ -795,18 +783,6 @@ function displaySummary(runDir: string): void {
       console.log(`     └─ terminal-raw.log      ${formatSize(stats.size)}`);
     }
     
-    if (fs.existsSync(readableLog)) {
-      const stats = fs.statSync(readableLog);
-      console.log(`     └─ terminal-readable.log ${formatSize(stats.size)} ${logger.COLORS.yellow}(parsed AI output)${logger.COLORS.reset}`);
-    }
-    
-    if (fs.existsSync(jsonLog)) {
-      const stats = fs.statSync(jsonLog);
-      const entries = readJsonLog(jsonLog);
-      const errors = entries.filter(e => e.level === 'error' || e.level === 'stderr').length;
-      console.log(`     └─ terminal.jsonl        ${formatSize(stats.size)} (${entries.length} entries, ${errors} errors)`);
-    }
-    
     console.log('');
   }
 }

package/src/cli/monitor.ts

@@ -56,13 +56,13 @@ const UI = {
 interface LaneWithDeps {
   name: string;
   path: string;
-  dependsOn: string[];
 }
 
 interface MonitorOptions {
   runDir?: string;
   interval: number;
   help: boolean;
+  list: boolean;
 }
 
 function printHelp(): void {
@@ -73,8 +73,14 @@ Interactive lane dashboard to track progress and dependencies.
 
 Options:
   [run-dir]              Run directory to monitor (default: latest)
+  --list, -l             List all runs (multiple flows dashboard)
   --interval <seconds>   Refresh interval (default: 2)
   --help, -h             Show help
+
+Examples:
+  cursorflow monitor             # Monitor latest run
+  cursorflow monitor --list      # Show all runs dashboard
+  cursorflow monitor run-123     # Monitor specific run
   `);
 }
 
@@ -135,9 +141,10 @@ class InteractiveMonitor {
     return process.stdout.rows || 24;
   }
 
-  constructor(runDir: string, interval: number, logsDir?: string) {
+  constructor(runDir: string, interval: number, logsDir?: string, initialView: View = View.LIST) {
     this.runDir = runDir;
     this.interval = interval;
+    this.view = initialView;
     
     // Set logs directory for multiple flows discovery
     if (logsDir) {
@@ -152,6 +159,21 @@ class InteractiveMonitor {
   }
 
   public async start() {
+    // Non-interactive mode for CI/pipes
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+      this.discoverFlows();
+      this.refresh();
+      // Print summary and exit
+      if (this.view === View.FLOWS_DASHBOARD) {
+        console.log(`\nFound ${this.allFlows.length} flows`);
+      } else {
+        console.log(`\nMonitoring run: ${path.basename(this.runDir)}`);
+        const flowSummary = getFlowSummary(this.runDir);
+        console.log(`Status: ${flowSummary.running} running, ${flowSummary.completed} completed, ${flowSummary.failed} failed`);
+      }
+      return;
+    }
+
     this.setupTerminal();
     
     // Start unified log streaming
@@ -999,14 +1021,12 @@ class InteractiveMonitor {
       // Next action
       let nextAction = '-';
       if (status.status === 'completed') {
-        const dependents = this.lanes.filter(l => laneStatuses[l.name]?.dependsOn?.includes(lane.name));
-        nextAction = dependents.length > 0 ? `→ ${dependents.map(d => d.name).join(', ')}` : '✓ Done';
+        nextAction = '✓ Done';
       } else if (status.status === 'waiting') {
         if (status.waitingFor?.length > 0) {
           nextAction = `⏳ ${status.waitingFor.join(', ')}`;
         } else {
-          const missingDeps = status.dependsOn.filter((d: string) => laneStatuses[d]?.status !== 'completed');
-          nextAction = missingDeps.length > 0 ? `⏳ ${missingDeps.join(', ')}` : '⏳ waiting';
+          nextAction = '⏳ waiting';
         }
       } else if (processStatus?.actualStatus === 'running') {
         nextAction = '🚀 working...';
@@ -1063,9 +1083,6 @@ class InteractiveMonitor {
     process.stdout.write(` ${UI.COLORS.dim}Duration${UI.COLORS.reset}   ${this.formatDuration(processStatus?.duration || status.duration)}\n`);
     process.stdout.write(` ${UI.COLORS.dim}Branch${UI.COLORS.reset}     ${status.pipelineBranch}\n`);
     
-    if (status.dependsOn && status.dependsOn.length > 0) {
-      process.stdout.write(` ${UI.COLORS.dim}Depends${UI.COLORS.reset}    ${status.dependsOn.join(', ')}\n`);
-    }
     if (status.waitingFor && status.waitingFor.length > 0) {
       process.stdout.write(` ${UI.COLORS.yellow}Waiting${UI.COLORS.reset}    ${status.waitingFor.join(', ')}\n`);
     }
@@ -1075,7 +1092,7 @@ class InteractiveMonitor {
 
     // Live terminal preview
     this.renderSectionTitle('Live Terminal', 'last 10 lines');
-    const logPath = safeJoin(lane.path, 'terminal.log');
+    const logPath = safeJoin(lane.path, 'terminal-readable.log');
     if (fs.existsSync(logPath)) {
       const content = fs.readFileSync(logPath, 'utf8');
       const lines = content.split('\n').slice(-10);
@@ -1132,7 +1149,6 @@ class InteractiveMonitor {
     const colors: Record<string, string> = {
       user: UI.COLORS.yellow,
       assistant: UI.COLORS.green,
-      reviewer: UI.COLORS.magenta,
       intervention: UI.COLORS.red,
       system: UI.COLORS.cyan,
     };
@@ -1243,9 +1259,9 @@ class InteractiveMonitor {
         const nodeText = `${statusIcon} ${laneName}`;
         process.stdout.write(`   ${statusColor}${nodeText.padEnd(20)}${UI.COLORS.reset}`);
         
-        // Render dependencies
-        if (status?.dependsOn?.length > 0) {
-          process.stdout.write(` ${UI.COLORS.dim}←${UI.COLORS.reset} ${UI.COLORS.yellow}${status.dependsOn.join(', ')}${UI.COLORS.reset}`);
+        // Show task-level dependencies if waiting
+        if (status?.waitingFor?.length > 0) {
+          process.stdout.write(` ${UI.COLORS.dim}←${UI.COLORS.reset} ${UI.COLORS.yellow}${status.waitingFor.join(', ')}${UI.COLORS.reset}`);
         }
         process.stdout.write('\n');
       }
@@ -1256,54 +1272,21 @@ class InteractiveMonitor {
       }
     }
 
-    process.stdout.write(`\n ${UI.COLORS.dim}Lanes wait for dependencies to complete before starting${UI.COLORS.reset}\n`);
+    process.stdout.write(`\n ${UI.COLORS.dim}Tasks can wait for other tasks using task-level dependencies${UI.COLORS.reset}\n`);
     
     this.renderFooter(['[←/Esc] Back']);
   }
   
   /**
-   * Calculate dependency levels for visualization
+   * Calculate levels for visualization (all lanes run in parallel now)
    */
   private calculateDependencyLevels(): string[][] {
-    const levels: string[][] = [];
-    const assigned = new Set<string>();
-    
-    // First, find lanes with no dependencies
-    const noDeps = this.lanes.filter(l => !l.dependsOn || l.dependsOn.length === 0);
-    if (noDeps.length > 0) {
-      levels.push(noDeps.map(l => l.name));
-      noDeps.forEach(l => assigned.add(l.name));
-    }
-    
-    // Then assign remaining lanes by dependency completion
-    let maxIterations = 10;
-    while (assigned.size < this.lanes.length && maxIterations-- > 0) {
-      const nextLevel: string[] = [];
-      
-      for (const lane of this.lanes) {
-        if (assigned.has(lane.name)) continue;
-        
-        // Check if all dependencies are assigned
-        const allDepsAssigned = lane.dependsOn.every(d => assigned.has(d));
-        if (allDepsAssigned) {
-          nextLevel.push(lane.name);
-        }
-      }
-      
-      if (nextLevel.length === 0) {
-        // Remaining lanes have circular deps or missing deps
-        const remaining = this.lanes.filter(l => !assigned.has(l.name)).map(l => l.name);
-        if (remaining.length > 0) {
-          levels.push(remaining);
-        }
-        break;
-      }
-      
-      levels.push(nextLevel);
-      nextLevel.forEach(n => assigned.add(n));
+    // Since lane-level dependencies are removed, all lanes can run in parallel
+    // Group them into a single level
+    if (this.lanes.length === 0) {
+      return [];
     }
-    
-    return levels;
+    return [this.lanes.map(l => l.name)];
   }
 
   private renderTerminal() {
@@ -1326,8 +1309,8 @@ class InteractiveMonitor {
       logLines = this.getReadableLogLines(jsonlPath, lane.name);
       totalLines = logLines.length;
     } else {
-      // Use raw log
-      const logPath = safeJoin(lane.path, 'terminal.log');
+      // Use readable log
+      const logPath = safeJoin(lane.path, 'terminal-readable.log');
       if (fs.existsSync(logPath)) {
         const content = fs.readFileSync(logPath, 'utf8');
         logLines = content.split('\n');
@@ -1689,39 +1672,33 @@ class InteractiveMonitor {
     return fs.readdirSync(lanesDir)
       .filter(d => fs.statSync(safeJoin(lanesDir, d)).isDirectory())
       .map(name => {
-        const config = laneConfigs.find(c => c.name === name);
         return {
           name,
           path: safeJoin(lanesDir, name),
-          dependsOn: config?.dependsOn || [],
         };
       });
   }
 
-  private listLaneFilesFromDir(tasksDir: string): { name: string; dependsOn: string[] }[] {
+  private listLaneFilesFromDir(tasksDir: string): { name: string }[] {
     if (!fs.existsSync(tasksDir)) return [];
     return fs.readdirSync(tasksDir)
       .filter(f => f.endsWith('.json'))
       .map(f => {
         const filePath = safeJoin(tasksDir, f);
         try {
-          const config = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-          return { name: path.basename(f, '.json'), dependsOn: config.dependsOn || [] };
+          return { name: path.basename(f, '.json') };
         } catch {
-          return { name: path.basename(f, '.json'), dependsOn: [] };
+          return { name: path.basename(f, '.json') };
         }
       });
   }
 
-  private getLaneStatus(lanePath: string, laneName: string) {
+  private getLaneStatus(lanePath: string, _laneName: string) {
     const statePath = safeJoin(lanePath, 'state.json');
     const state = loadState<LaneState & { chatId?: string }>(statePath);
     
-    const laneInfo = this.lanes.find(l => l.name === laneName);
-    const dependsOn = state?.dependsOn || laneInfo?.dependsOn || [];
-    
     if (!state) {
-      return { status: 'pending', currentTask: 0, totalTasks: '?', progress: '0%', dependsOn, duration: 0, pipelineBranch: '-', chatId: '-' };
+      return { status: 'pending', currentTask: 0, totalTasks: '?', progress: '0%', duration: 0, pipelineBranch: '-', chatId: '-' };
     }
     
     const progress = state.totalTasks > 0 ? Math.round((state.currentTaskIndex / state.totalTasks) * 100) : 0;
@@ -1737,7 +1714,6 @@ class InteractiveMonitor {
       progress: `${progress}%`,
       pipelineBranch: state.pipelineBranch || '-',
       chatId: state.chatId || '-',
-      dependsOn,
       duration,
       error: state.error,
       pid: state.pid,
@@ -1788,6 +1764,8 @@ function findLatestRunDir(logsDir: string): string | null {
  */
 async function monitor(args: string[]): Promise<void> {
   const help = args.includes('--help') || args.includes('-h');
+  const list = args.includes('--list') || args.includes('-l');
+  
   if (help) {
     printHelp();
     return;
@@ -1802,12 +1780,18 @@ async function monitor(args: string[]): Promise<void> {
   let runDir = runDirArg;
   if (!runDir || runDir === 'latest') {
     runDir = findLatestRunDir(config.logsDir) || undefined;
-    if (!runDir) throw new Error('No run directories found');
+    if (!runDir && !list) throw new Error('No run directories found');
+    if (!runDir && list) {
+      // Create a dummy runDir if none exists but we want to see the list (dashboard will handle empty list)
+      runDir = path.join(config.logsDir, 'runs', 'empty');
+    }
   }
   
-  if (!fs.existsSync(runDir)) throw new Error(`Run directory not found: ${runDir}`);
+  if (runDir && !fs.existsSync(runDir) && !list) {
+    throw new Error(`Run directory not found: ${runDir}`);
+  }
   
-  const monitor = new InteractiveMonitor(runDir, interval);
+  const monitor = new InteractiveMonitor(runDir!, interval, undefined, list ? View.FLOWS_DASHBOARD : View.LIST);
   await monitor.start();
 }