@litmers/cursorflow-orchestrator 0.1.15 → 0.1.20

package/src/utils/repro-thinking-logs.ts

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createLogManager } from './enhanced-logger';
+
+async function testThinkingLogs() {
+  const testDir = path.join(process.cwd(), '_test_thinking_logs');
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+
+  console.log('--- Initializing Log Manager ---');
+  const manager = createLogManager(testDir, 'test-lane-thinking', {
+    writeJsonLog: true,
+    keepRawLogs: true
+  });
+
+  manager.setTask('repro-thinking-task', 'sonnet-4.5-thinking');
+
+  const logLines = [
+    '{"type":"tool_call","subtype":"started","call_id":"0_tool_54a8fcc9-6981-4f59-aeb6-3ab6d37b2","tool_call":{"readToolCall":{"args":{"path":"/home/eugene/workbench/workbench-os-eungjin/_cursorflow/worktrees/cursorflow/run-mjfxp57i/agent_output.txt"}}}}',
+    '{"type":"thinking","subtype":"delta","text":"**Defining Installation Strategy**\\n\\nI\'ve considered the `package.json` file as the central point for installation in automated environments. Thinking now about how that impacts the user\'s ultimate goal, given this is how the process begins in these environments.\\n\\n\\n"}',
+    '{"type":"thinking","subtype":"delta","text":"**Clarifying Execution Context**\\n\\nI\'m focused on the user\'s explicit command: `pnpm add @convex-dev/agent ai @ai-sdk/google zod`. My inability to directly execute this is a key constraint. I\'m exploring ways to inform the user about this. I\'ve considered that, without the tools required to run the original command, any attempt to run a command like `grep` or `date` is pointless and will fail.\\n\\n\\n"}',
+    '{"type":"tool_call","subtype":"started","call_id":"0_tool_d8f826c8-9d8f-4cab-9ff8-1c47d1ac1","tool_call":{"shellToolCall":{"args":{"command":"date"}}}}'
+  ];
+
+  console.log('\n--- Feeding Log Lines to Manager ---');
+  for (const line of logLines) {
+    console.log('Processing:', line.substring(0, 100) + '...');
+    manager.writeStdout(line + '\n');
+  }
+
+  manager.close();
+
+  console.log('\n--- Verifying terminal-readable.log ---');
+  const readableLog = fs.readFileSync(path.join(testDir, 'terminal-readable.log'), 'utf8');
+  console.log(readableLog);
+
+  console.log('\n--- Verifying terminal.jsonl (last 3 entries) ---');
+  const jsonlLog = fs.readFileSync(path.join(testDir, 'terminal.jsonl'), 'utf8');
+  const lines = jsonlLog.trim().split('\n');
+  for (const line of lines.slice(-3)) {
+    const parsed = JSON.parse(line);
+    console.log(JSON.stringify({
+      level: parsed.level,
+      message: parsed.message.substring(0, 50) + '...',
+      hasMetadata: !!parsed.metadata,
+      metadataType: parsed.metadata?.type
+    }, null, 2));
+  }
+}
+
+testThinkingLogs().catch(console.error);
+

package/src/utils/state.ts

@@ -4,6 +4,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
+import { safeJoin } from './path';
 import { 
   LaneState, 
   ConversationEntry, 
@@ -80,18 +81,25 @@ export function readLog<T = any>(logPath: string): T[] {
 /**
  * Create initial lane state
  */
-export function createLaneState(laneName: string, config: RunnerConfig): LaneState {
+export function createLaneState(
+  laneName: string, 
+  config: RunnerConfig, 
+  tasksFile?: string,
+  options: { pipelineBranch?: string; worktreeDir?: string } = {}
+): LaneState {
   return {
     label: laneName,
     status: 'pending',
     currentTaskIndex: 0,
     totalTasks: config.tasks ? config.tasks.length : 0,
-    worktreeDir: null,
-    pipelineBranch: null,
+    worktreeDir: options.worktreeDir || null,
+    pipelineBranch: options.pipelineBranch || null,
     startTime: Date.now(),
     endTime: null,
     error: null,
     dependencyRequest: null,
+    tasksFile,
+    dependsOn: config.dependsOn || [],
   };
 }
 
@@ -151,7 +159,7 @@ export function getLatestRunDir(logsDir: string): string | null {
   }
   
   const runs = fs.readdirSync(logsDir)
-    .filter(f => fs.statSync(path.join(logsDir, f)).isDirectory())
+    .filter(f => fs.statSync(safeJoin(logsDir, f)).isDirectory())
     .sort()
     .reverse();
   
@@ -159,7 +167,7 @@ export function getLatestRunDir(logsDir: string): string | null {
     return null;
   }
   
-  return path.join(logsDir, runs[0]!);
+  return safeJoin(logsDir, runs[0]!);
 }
 
 /**
@@ -171,11 +179,11 @@ export function listLanesInRun(runDir: string): { name: string; dir: string; sta
   }
   
   return fs.readdirSync(runDir)
-    .filter(f => fs.statSync(path.join(runDir, f)).isDirectory())
+    .filter(f => fs.statSync(safeJoin(runDir, f)).isDirectory())
     .map(laneName => ({
       name: laneName,
-      dir: path.join(runDir, laneName),
-      statePath: path.join(runDir, laneName, 'state.json'),
+      dir: safeJoin(runDir, laneName),
+      statePath: safeJoin(runDir, laneName, 'state.json'),
     }));
 }
 

package/src/utils/template.ts

@@ -0,0 +1,92 @@
+/**
+ * Template loading utilities for CursorFlow
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+import * as logger from './logger';
+import { safeJoin } from './path';
+import { findProjectRoot } from './config';
+
+/**
+ * Fetch remote template from URL
+ */
+export async function fetchRemoteTemplate(url: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+    
+    protocol.get(url, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`Failed to fetch template from ${url}: Status ${res.statusCode}`));
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse template JSON from ${url}: ${e}`));
+        }
+      });
+    }).on('error', (err) => {
+      reject(new Error(`Network error while fetching template from ${url}: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * Resolve template from various sources:
+ * 1. URL (starts with http:// or https://)
+ * 2. Built-in template (name without .json)
+ * 3. Local file path
+ */
+export async function resolveTemplate(templatePath: string): Promise<any> {
+  // 1. Remote URL
+  if (templatePath.startsWith('http://') || templatePath.startsWith('https://')) {
+    logger.info(`Fetching remote template: ${templatePath}`);
+    return fetchRemoteTemplate(templatePath);
+  }
+
+  // 2. Built-in template
+  // Search in templates/ directory of the project root
+  try {
+    const projectRoot = findProjectRoot();
+    const builtInPath = safeJoin(projectRoot, 'templates', templatePath.endsWith('.json') ? templatePath : `${templatePath}.json`);
+    if (fs.existsSync(builtInPath)) {
+      logger.info(`Using built-in template: ${templatePath}`);
+      return JSON.parse(fs.readFileSync(builtInPath, 'utf8'));
+    }
+  } catch (e) {
+    // Ignore error if project root not found, try other methods
+  }
+
+  // Fallback for built-in templates relative to the module (for installed package)
+  const templatesDir = path.resolve(__dirname, '../../templates');
+  const templateFileName = templatePath.endsWith('.json') ? templatePath : `${templatePath}.json`;
+  const modulePath = safeJoin(templatesDir, templateFileName);
+  if (fs.existsSync(modulePath)) {
+    logger.info(`Using module template: ${templatePath}`);
+    return JSON.parse(fs.readFileSync(modulePath, 'utf8'));
+  }
+
+  // 3. Local file path
+  const localPath = safeJoin(process.cwd(), templatePath);
+  if (fs.existsSync(localPath)) {
+    logger.info(`Using local template: ${templatePath}`);
+    try {
+      return JSON.parse(fs.readFileSync(localPath, 'utf8'));
+    } catch (e) {
+      throw new Error(`Failed to parse local template ${templatePath}: ${e}`);
+    }
+  }
+
+  throw new Error(`Template not found: ${templatePath}. It must be a URL, a built-in template name, or a local file path.`);
+}
+

package/src/utils/types.ts

@@ -18,6 +18,7 @@ export interface CursorFlowConfig {
   lockfileReadOnly: boolean;
   enableReview: boolean;
   reviewModel: string;
+  reviewAllTasks?: boolean;
   maxReviewIterations: number;
   defaultLaneConfig: LaneConfig;
   logLevel: string;
@@ -189,20 +190,27 @@ export interface Task {
   model?: string;
   /** Acceptance criteria for the AI reviewer to validate */
   acceptanceCriteria?: string[];
+  /** Task-level dependencies (format: "lane:task") */
+  dependsOn?: string[];
+  /** Task execution timeout in milliseconds. Overrides lane-level timeout. */
+  timeout?: number;
 }
 
 export interface RunnerConfig {
   tasks: Task[];
   dependsOn?: string[];
   pipelineBranch?: string;
+  worktreeDir?: string;
   branchPrefix?: string;
   worktreeRoot?: string;
   baseBranch?: string;
   model?: string;
   dependencyPolicy: DependencyPolicy;
+  enableReview?: boolean;
   /** Output format for cursor-agent (default: 'stream-json') */
   agentOutputFormat?: 'stream-json' | 'json' | 'plain';
   reviewModel?: string;
+  reviewAllTasks?: boolean;
   maxReviewIterations?: number;
   acceptanceCriteria?: string[];
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
@@ -263,6 +271,7 @@ export interface ReviewResult {
 export interface TaskResult {
   taskName: string;
   taskBranch: string;
+  acceptanceCriteria?: string[];
   [key: string]: any;
 }
 
@@ -281,6 +290,10 @@ export interface LaneState {
   tasksFile?: string; // Original tasks file path
   dependsOn?: string[];
   pid?: number;
+  /** List of completed task names in this lane */
+  completedTasks?: string[];
+  /** Task-level dependencies currently being waited for (format: "lane:task") */
+  waitingFor?: string[];
 }
 
 export interface ConversationEntry {

package/src/utils/webhook.ts

@@ -56,6 +56,9 @@ async function sendWebhook(config: WebhookConfig, event: CursorFlowEvent) {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
 
+      // SECURITY NOTE: Intentionally sending event data to configured webhook URLs.
+      // This is the expected behavior - users explicitly configure webhook endpoints
+      // to receive CursorFlow events. The data is JSON-serialized event metadata.
       const response = await fetch(config.url, {
         method: 'POST',
         headers,

package/templates/basic.json

@@ -0,0 +1,21 @@
+{
+  "name": "basic-template",
+  "tasks": [
+    {
+      "name": "plan",
+      "model": "sonnet-4.5-thinking",
+      "prompt": "Analyze requirements for {{featureName}} and create a plan.",
+      "acceptanceCriteria": ["Plan documented"]
+    },
+    {
+      "name": "implement",
+      "model": "sonnet-4.5",
+      "prompt": "Implement {{featureName}} based on the plan.",
+      "acceptanceCriteria": ["Implementation complete"]
+    }
+  ],
+  "dependencyPolicy": {
+    "allowDependencyChange": false,
+    "lockfileReadOnly": true
+  }
+}

package/scripts/simple-logging-test.sh

@@ -1,97 +0,0 @@
-#!/bin/bash
-#
-# Simple Real Logging Test
-# This test runs cursor-agent directly and verifies log capture
-#
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
-
-echo "🧪 Simple Cursor-Agent Logging Test"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-# Check cursor-agent
-if ! command -v cursor-agent &> /dev/null; then
-    echo "❌ cursor-agent not found"
-    exit 1
-fi
-
-cd "$PROJECT_ROOT"
-
-# Build
-echo "Building..."
-npm run build > /dev/null 2>&1
-
-# Setup test dir
-TEST_DIR="$PROJECT_ROOT/_test-logs"
-rm -rf "$TEST_DIR"
-mkdir -p "$TEST_DIR"
-
-# Create a very simple task
-cat > "$TEST_DIR/task.json" << 'EOF'
-{
-  "baseBranch": "main",
-  "branchPrefix": "test/log-",
-  "timeout": 30000,
-  "tasks": [
-    {
-      "name": "echo-test",
-      "prompt": "Say 'test complete' and nothing else.",
-      "model": "sonnet-4.5"
-    }
-  ]
-}
-EOF
-
-# Run with node directly
-echo ""
-echo "Running cursor-agent via runner..."
-echo ""
-
-LANE_DIR="$TEST_DIR/lane"
-mkdir -p "$LANE_DIR"
-
-# Run runner.js directly
-timeout 60 node dist/core/runner.js "$TEST_DIR/task.json" \
-  --run-dir "$LANE_DIR" \
-  --executor cursor-agent \
-  --start-index 0 || true
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "📋 Log Files Created:"
-echo ""
-
-ls -la "$LANE_DIR"/*.log "$LANE_DIR"/*.jsonl 2>/dev/null || echo "No log files found"
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "📝 terminal.log content:"
-echo ""
-
-if [ -f "$LANE_DIR/terminal.log" ]; then
-    head -50 "$LANE_DIR/terminal.log"
-else
-    echo "No terminal.log"
-fi
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "📝 terminal.jsonl (first 3 entries):"
-echo ""
-
-if [ -f "$LANE_DIR/terminal.jsonl" ]; then
-    head -3 "$LANE_DIR/terminal.jsonl"
-else
-    echo "No terminal.jsonl"
-fi
-
-# Cleanup git branches
-git branch -D test/log-* 2>/dev/null || true
-git worktree remove _cursorflow/worktrees/test/log-* --force 2>/dev/null || true
-
-echo ""
-echo "✅ Test finished"
-

package/scripts/test-real-cursor-lifecycle.sh

@@ -1,289 +0,0 @@
-#!/bin/bash
-# scripts/test-real-cursor-lifecycle.sh
-# 
-# Full Lifecycle Integration Test for CursorFlow
-# 
-# This script performs a real-world test by:
-# 1. Creating a temporary Git repository
-# 2. Initializing CursorFlow
-# 3. Defining a real task for cursor-agent
-# 4. Running the orchestration
-# 5. Verifying the results (file changes)
-# 6. Cleaning up all resources (branches, worktrees, logs)
-
-set -e
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-NC='\033[0m' # No Color
-
-# Parse arguments
-CLEANUP=true
-NO_GIT=false
-for arg in "$@"; do
-    if [ "$arg" == "--no-cleanup" ]; then
-        CLEANUP=false
-    fi
-    if [ "$arg" == "--no-git" ]; then
-        NO_GIT=true
-    fi
-done
-
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${CYAN}  🧪 Full Lifecycle Integration Test${NC}"
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-# Prerequisites Check
-echo -e "${YELLOW}Checking prerequisites...${NC}"
-if ! command -v cursor-agent &> /dev/null; then
-    echo -e "${RED}❌ cursor-agent CLI not found. Please install it first.${NC}"
-    exit 1
-fi
-
-if ! cursor-agent create-chat &> /dev/null; then
-    echo -e "${RED}❌ cursor-agent authentication failed.${NC}"
-    echo "   Please sign in to Cursor IDE first."
-    exit 1
-fi
-echo -e "${GREEN}✓ Prerequisites OK${NC}"
-
-# Setup Directories
-PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-TEST_ROOT="$PROJECT_ROOT/_lifecycle_test"
-CLI_BIN="$PROJECT_ROOT/dist/cli/index.js"
-
-echo -e "${YELLOW}Setting up temporary repository at $TEST_ROOT...${NC}"
-rm -rf "$TEST_ROOT"
-mkdir -p "$TEST_ROOT"
-cd "$TEST_ROOT"
-
-# Init Git
-# Use a more compatible way to init and set branch
-git init > /dev/null
-echo "# Lifecycle Test Project" > README.md
-
-# IMPORTANT: Create a dummy package.json AND .cursorignore to ensure this is treated as a separate root
-cat > package.json << 'EOF'
-{
-  "name": "lifecycle-test-project",
-  "version": "1.0.0"
-}
-EOF
-
-touch .cursorignore
-
-git add README.md package.json .cursorignore
-git commit -m "initial commit" > /dev/null
-git branch -m main > /dev/null 2>&1 || true
-
-git config user.email "test@cursorflow.com"
-git config user.name "CursorFlow Test"
-
-echo -e "${GREEN}✓ Git repository initialized with package.json${NC}"
-
-# Build CursorFlow (ensure latest changes)
-echo -e "${YELLOW}Building CursorFlow...${NC}"
-cd "$PROJECT_ROOT"
-npm run build > /dev/null
-cd "$TEST_ROOT"
-echo -e "${GREEN}✓ Build complete${NC}"
-echo -e "${GREEN}✓ Build complete${NC}"
-
-# Create an alias for cursorflow to test it as a command
-shopt -s expand_aliases
-alias cursorflow="node $CLI_BIN"
-
-# Init CursorFlow
-echo -e "${YELLOW}Initializing CursorFlow...${NC}"
-cursorflow init --yes > /dev/null
-echo -e "${GREEN}✓ CursorFlow initialized${NC}"
-
-# Define Task
-echo -e "${YELLOW}Defining complex tasks with dependencies...${NC}"
-mkdir -p _cursorflow/tasks
-
-# Lane 1: Creates and updates a config file
-cat > _cursorflow/tasks/lane-1.json << 'EOF'
-{
-  "name": "lane-1",
-  "tasks": [
-    {
-      "name": "create-config",
-      "prompt": "Create a file named 'config.json' with { \"version\": \"1.0.0\", \"status\": \"alpha\" }. Commit it.",
-      "model": "sonnet-4.5"
-    },
-    {
-      "name": "update-config",
-      "prompt": "Update 'config.json' to set \"status\": \"beta\" and add \"author\": \"cursorflow-test\". Commit it.",
-      "model": "sonnet-4.5"
-    }
-  ],
-  "dependencyPolicy": {
-    "allowDependencyChange": false,
-    "lockfileReadOnly": true
-  }
-}
-EOF
-
-# Lane 2: Depends on Lane 1, creates a main file using the config
-cat > _cursorflow/tasks/lane-2.json << 'EOF'
-{
-  "name": "lane-2",
-  "dependsOn": ["lane-1"],
-  "tasks": [
-    {
-      "name": "create-main",
-      "prompt": "Read 'config.json'. Create a file named 'app.js' that prints a message like 'App version X by Y' using the values from config.json. Commit it.",
-      "model": "sonnet-4.5"
-    }
-  ],
-  "dependencyPolicy": {
-    "allowDependencyChange": false,
-    "lockfileReadOnly": true
-  }
-}
-EOF
-echo -e "${GREEN}✓ Complex tasks defined${NC}"
-
-# Run Orchestration
-echo -e "${YELLOW}Running orchestration (2 lanes, 3 tasks total)...${NC}"
-echo -e "${CYAN}This will interact with Cursor IDE. Please wait...${NC}"
-echo ""
-
-# We use the CLI command directly
-if [ "$NO_GIT" == "true" ]; then
-    echo -e "${YELLOW}⚠️  Running in --no-git mode (no Git operations)${NC}"
-    cursorflow run _cursorflow/tasks --skip-doctor --no-git
-else
-    cursorflow run _cursorflow/tasks --skip-doctor
-fi
-
-echo -e "${GREEN}✓ Orchestration finished${NC}"
-
-# Verify Result
-echo -e "${YELLOW}Verifying results...${NC}"
-
-if [ "$NO_GIT" == "true" ]; then
-    # In no-git mode, check workdir instead of branches
-    WORKDIR=$(find _cursorflow/workdir -type d -name "cursorflow-*" 2>/dev/null | head -n 1)
-    
-    if [ -z "$WORKDIR" ]; then
-        WORKDIR=$(find _cursorflow/workdir -type d -mindepth 1 2>/dev/null | head -n 1)
-    fi
-    
-    if [ -z "$WORKDIR" ]; then
-        echo -e "${YELLOW}⚠️  No workdir found, checking current directory${NC}"
-        WORKDIR="."
-    fi
-    
-    echo -e "${GREEN}✓ Work directory: $WORKDIR${NC}"
-    
-    # In noGit mode, files are created in the workdir
-    if [ -f "$WORKDIR/config.json" ]; then
-        CONFIG_CONTENT=$(cat "$WORKDIR/config.json")
-        echo -e "${GREEN}✓ config.json found${NC}"
-        echo -e "  config.json: $CONFIG_CONTENT"
-    else
-        echo -e "${YELLOW}⚠️  config.json not found in workdir (may be in different location)${NC}"
-    fi
-    
-    echo -e "${GREEN}✓ Verification SUCCESS (no-git mode)${NC}"
-else
-    # Check Lane 2's final branch (which should have everything)
-    LANE2_BRANCH=$(git branch --list 'feature/lane-2*' 'cursorflow/lane-2*' | head -n 1 | sed 's/*//' | xargs)
-
-    if [ -z "$LANE2_BRANCH" ]; then
-        # Try to find it by looking at the latest branches
-        LANE2_BRANCH=$(git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short)' | grep 'lane-2' | head -n 1)
-    fi
-
-    if [ -z "$LANE2_BRANCH" ]; then
-        echo -e "${RED}❌ No branch found for lane-2${NC}"
-        exit 1
-    fi
-
-    echo -e "${GREEN}✓ Lane 2 final branch: $LANE2_BRANCH${NC}"
-
-    # Checkout and check files
-    git checkout "$LANE2_BRANCH" > /dev/null 2>&1
-
-    if [ -f "config.json" ] && [ -f "app.js" ]; then
-        CONFIG_CONTENT=$(cat config.json)
-        APP_CONTENT=$(cat app.js)
-        echo -e "${GREEN}✓ Verification SUCCESS${NC}"
-        echo -e "  config.json: $CONFIG_CONTENT"
-        echo -e "  app.js: $APP_CONTENT"
-    else
-        echo -e "${RED}❌ Verification FAILED - Missing files${NC}"
-        [ ! -f "config.json" ] && echo "  - config.json is missing"
-        [ ! -f "app.js" ] && echo "  - app.js is missing"
-        exit 1
-    fi
-fi
-
-# Verify Logs
-echo -e "${YELLOW}Verifying logs...${NC}"
-LOG_DIR="_cursorflow/logs"
-if [ -d "$LOG_DIR" ]; then
-    echo -e "${GREEN}✓ Logs directory exists${NC}"
-    RUN_LOGS=$(ls -d $LOG_DIR/runs/run-* 2>/dev/null | sort -r | head -n 1)
-    if [ -n "$RUN_LOGS" ]; then
-        echo -e "${GREEN}✓ Run logs found in $RUN_LOGS${NC}"
-        # Check for readable log in lane-1
-        READABLE_LOG="$RUN_LOGS/lanes/lane-1/terminal-readable.log"
-        if [ -f "$READABLE_LOG" ]; then
-            echo -e "${GREEN}✓ Readable log file created: $READABLE_LOG${NC}"
-            echo -e "${YELLOW}  Log preview (first 10 lines):${NC}"
-            head -n 10 "$READABLE_LOG" | sed 's/^/    /'
-        else
-            echo -e "${RED}❌ Readable log NOT found at $READABLE_LOG${NC}"
-            echo "Available files in lane-1 directory:"
-            ls -R "$RUN_LOGS/lanes/lane-1"
-            exit 1
-        fi
-    else
-        echo -e "${RED}❌ No run logs found in $LOG_DIR/runs${NC}"
-        ls -R "$LOG_DIR"
-        exit 1
-    fi
-else
-    echo -e "${RED}❌ Logs directory NOT found at $LOG_DIR${NC}"
-    echo "Current working directory contents:"
-    ls -R .
-    exit 1
-fi
-
-# Cleanup
-if [ "$CLEANUP" = "true" ]; then
-    echo ""
-    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "${CYAN}  🧹 Cleaning Up${NC}"
-    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-    if [ "$NO_GIT" != "true" ]; then
-        # Return to main branch
-        git checkout main > /dev/null 2>&1
-
-        # Use cursorflow clean
-        echo -e "${YELLOW}Cleaning CursorFlow resources...${NC}"
-        cursorflow clean all --include-latest --force > /dev/null 2>&1 || true
-    fi
-
-    # Finally remove the test root
-    cd "$PROJECT_ROOT"
-    rm -rf "$TEST_ROOT"
-    echo -e "${GREEN}✓ Temporary test directory removed${NC}"
-else
-    echo ""
-    echo -e "${YELLOW}⚠️  Skipping cleanup as requested.${NC}"
-    echo -e "   Test directory: $TEST_ROOT"
-    echo -e "   You can inspect the results there."
-fi
-
-echo ""
-echo -e "${GREEN}✅ Full lifecycle test PASSED successfully!${NC}"
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-