@anh3d0nic/qwen-code-termux-ice 14.0.0 → 16.0.0

package/integration-tests/concurrent-runner/runner.py

@@ -1,1083 +0,0 @@
-#!/usr/bin/env python3
-"""
-Qwen Concurrent Runner - Execute multiple CLI tasks across different models concurrently.
-
-This tool creates isolated git worktrees for each task/model combination and executes
-the Qwen CLI in parallel with status tracking and output capture.
-"""
-
-from __future__ import annotations
-
-import argparse
-import html
-import asyncio
-import json
-import os
-import shutil
-import subprocess
-import sys
-import uuid
-from dataclasses import dataclass, field, asdict
-from datetime import datetime
-from enum import Enum
-from pathlib import Path
-from typing import List, Optional, Dict, Any, Tuple
-
-from rich.console import Console
-from rich.live import Live
-from rich.table import Table
-from rich.panel import Panel
-from rich.progress import Progress, TaskID
-import aiofiles
-import aiofiles.os
-
-
-class RunStatus(Enum):
-    """Execution status for a single run."""
-    QUEUED = "queued"
-    PREPARING = "preparing"
-    RUNNING = "running"
-    SUCCEEDED = "succeeded"
-    FAILED = "failed"
-    CLEANING = "cleaning"
-
-
-@dataclass
-class Task:
-    """A task definition containing one or more prompts."""
-    id: str
-    name: str
-    prompts: List[str]
-
-
-@dataclass
-class ModelSpec:
-    """One model to run: name and optional auth_type (e.g. anthropic)."""
-    name: str
-    auth_type: Optional[str] = None
-
-
-@dataclass
-class RunConfig:
-    """Configuration for the concurrent execution."""
-    tasks: List[Task]
-    models: List[ModelSpec]  # name + optional auth_type per model
-    concurrency: int = 4
-    yolo: bool = True
-    source_repo: Path = field(default_factory=lambda: Path.cwd())
-    worktree_base: Path = field(default_factory=lambda: Path.home() / ".qwen" / "worktrees")
-    outputs_dir: Path = field(default_factory=lambda: Path("./outputs"))
-    results_file: Path = field(default_factory=lambda: Path("./results.json"))
-    branch: Optional[str] = None  # Git branch to checkout (uses default if not set)
-    keep_worktree: bool = False  # If true, don't remove git worktree after run
-
-
-@dataclass
-class PromptResult:
-    """Result of a single prompt execution."""
-    prompt_index: int
-    prompt_text: str
-    stdout_file: str
-    stderr_file: str
-    exit_code: int
-    status: str  # "succeeded" or "failed"
-
-
-@dataclass
-class RunRecord:
-    """Record of a single task/model execution."""
-    run_id: str
-    task_id: str
-    task_name: str
-    model: str
-    status: RunStatus
-    auth_type: Optional[str] = None  # e.g. "anthropic" for qwen --auth-type
-    worktree_path: Optional[str] = None
-    output_dir: Optional[str] = None
-    logs_dir: Optional[str] = None
-    started_at: Optional[str] = None
-    ended_at: Optional[str] = None
-    exit_code: Optional[int] = None
-    error_message: Optional[str] = None
-    prompt_results: List[PromptResult] = field(default_factory=list)
-    diff_file: Optional[str] = None  # Path to git diff output
-    session_log_file: Optional[str] = None  # Path to session log (chat recording)
-    session_html_file: Optional[str] = None  # Path to rendered chat HTML
-    session_id: Optional[str] = None  # Session ID (UUID from chat recording)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "run_id": self.run_id,
-            "task_id": self.task_id,
-            "task_name": self.task_name,
-            "model": self.model,
-            "status": self.status.value,
-            "auth_type": self.auth_type,
-            "worktree_path": self.worktree_path,
-            "output_dir": self.output_dir,
-            "logs_dir": self.logs_dir,
-            "started_at": self.started_at,
-            "ended_at": self.ended_at,
-            "exit_code": self.exit_code,
-            "error_message": self.error_message,
-            "diff_file": self.diff_file,
-            "session_log_file": self.session_log_file,
-            "session_html_file": self.session_html_file,
-            "session_id": self.session_id,
-            "prompt_results": [
-                {
-                    "prompt_index": r.prompt_index,
-                    "prompt_text": r.prompt_text,
-                    "stdout_file": r.stdout_file,
-                    "stderr_file": r.stderr_file,
-                    "exit_code": r.exit_code,
-                    "status": r.status,
-                }
-                for r in self.prompt_results
-            ],
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> RunRecord:
-        return cls(
-            run_id=data["run_id"],
-            task_id=data["task_id"],
-            task_name=data["task_name"],
-            model=data["model"],
-            status=RunStatus(data["status"]),
-            auth_type=data.get("auth_type"),
-            worktree_path=data.get("worktree_path"),
-            output_dir=data.get("output_dir"),
-            logs_dir=data.get("logs_dir"),
-            started_at=data.get("started_at"),
-            ended_at=data.get("ended_at"),
-            exit_code=data.get("exit_code"),
-            error_message=data.get("error_message"),
-            diff_file=data.get("diff_file"),
-            session_log_file=data.get("session_log_file"),
-            session_html_file=data.get("session_html_file"),
-            session_id=data.get("session_id"),
-        )
-
-
-@dataclass
-class ExecutionState:
-    """Overall execution state across all runs."""
-    runs: List[RunRecord] = field(default_factory=list)
-    total: int = 0
-    completed: int = 0
-    succeeded: int = 0
-    failed: int = 0
-
-
-class GitWorktreeManager:
-    """Manages git worktree creation, initialization, and cleanup."""
-
-    def __init__(self, console: Console, source_repo: Path):
-        self.console = console
-        self.source_repo = source_repo
-
-    async def ensure_git_repo(self) -> None:
-        """Ensure the source repository is a valid git repo, initialize if not."""
-        git_dir = self.source_repo / ".git"
-        if git_dir.exists():
-            return
-
-        self.console.print(f"[yellow]Source repo is not a git repository. Initializing...[/yellow]")
-
-        # git init
-        result = await self._run_command(["git", "init"], cwd=self.source_repo)
-        if result.returncode != 0:
-            raise RuntimeError(f"Failed to initialize git repo: {result.stderr}")
-
-        # git add .
-        result = await self._run_command(["git", "add", "."], cwd=self.source_repo)
-        if result.returncode != 0:
-            raise RuntimeError(f"Failed to stage files: {result.stderr}")
-
-        # git commit
-        result = await self._run_command(
-            ["git", "commit", "-m", "Initial commit"],
-            cwd=self.source_repo
-        )
-        if result.returncode != 0:
-            raise RuntimeError(f"Failed to create initial commit: {result.stderr}")
-
-        self.console.print(f"[green]✓ Git repository initialized[/green]")
-
-    async def create(self, source_repo: Path, worktree_dir: Path, branch: Optional[str] = None) -> Path:
-        """Create a new git worktree from the source repository."""
-        worktree_dir.parent.mkdir(parents=True, exist_ok=True)
-
-        # Build worktree command
-        if branch:
-            # Create a unique branch for this worktree based on the specified branch
-            worktree_branch = f"{branch}-{worktree_dir.name}"
-            cmd = ["git", "worktree", "add", "-b", worktree_branch, str(worktree_dir), branch]
-            self.console.print(f"[dim]Git: Creating worktree with branch '{worktree_branch}' from '{branch}'...[/dim]")
-        else:
-            # Create worktree from HEAD (default branch)
-            cmd = ["git", "worktree", "add", str(worktree_dir)]
-
-        self.console.print(f"[dim]Git: {' '.join(cmd)}[/dim]")
-        result = await self._run_command(cmd, cwd=source_repo)
-
-        if result.returncode != 0:
-            raise RuntimeError(f"Failed to create worktree: {result.stderr}")
-
-        return worktree_dir
-
-
-    async def remove(self, worktree_dir: Path) -> None:
-        """Remove a git worktree."""
-        if not worktree_dir.exists():
-            self.console.print(f"[dim]Worktree already removed: {worktree_dir}[/dim]")
-            return
-
-        self.console.print(f"[dim]Removing worktree: {worktree_dir}[/dim]")
-        cmd = ["git", "worktree", "remove", "--force", str(worktree_dir)]
-        result = await self._run_command(cmd, cwd=self.source_repo)
-
-        if result.returncode != 0:
-            self.console.print(f"[yellow]Warning: Failed to remove worktree {worktree_dir}: {result.stderr}[/yellow]")
-            # Fallback to manual removal
-            try:
-                shutil.rmtree(worktree_dir, ignore_errors=True)
-            except Exception:
-                pass
-
-    async def get_diff(self, worktree_dir: Path) -> str:
-        """Get git diff showing all changes in the worktree."""
-        self.console.print(f"[dim]Capturing git diff from {worktree_dir.name}...[/dim]")
-
-        # First, stage all changes (including untracked files) so we can get a complete diff
-        await self._run_command(["git", "add", "-A"], cwd=worktree_dir)
-
-        # Get the diff (staged changes)
-        result = await self._run_command(["git", "diff", "--cached", "--no-color"], cwd=worktree_dir)
-
-        if result.returncode != 0:
-            self.console.print(f"[yellow]Warning: Failed to get diff: {result.stderr}[/yellow]")
-            return ""
-
-        return result.stdout
-
-    async def collect_session_log(self, worktree_dir: Path, output_dir: Path) -> Optional[Tuple[Path, str, Path]]:
-        """Collect the session log file from the worktree's chat recording.
-
-        Session logs are stored at:
-        ~/.qwen/projects/{projectId}/chats/{sessionId}.jsonl
-
-        Where projectId is the sanitized worktree path.
-
-        Returns:
-            Tuple of (output_path, session_id, rendered_html_path) or None if not found.
-        """
-        import re
-
-        # Compute projectId by sanitizing the worktree path (same as storage.ts)
-        project_id = re.sub(r'[^a-zA-Z0-9]', '-', str(worktree_dir))
-
-        # Build the chats directory path
-        qwen_dir = Path.home() / ".qwen"
-        chats_dir = qwen_dir / "projects" / project_id / "chats"
-
-        if not chats_dir.exists():
-            self.console.print(f"[dim]No chats directory found at {chats_dir}[/dim]")
-            return None
-
-        # Find all .jsonl files in the chats directory
-        jsonl_files = list(chats_dir.glob("*.jsonl"))
-        if not jsonl_files:
-            self.console.print(f"[dim]No session log files found in {chats_dir}[/dim]")
-            return None
-
-        # Get the most recently modified file (the one just created)
-        session_log = max(jsonl_files, key=lambda f: f.stat().st_mtime)
-
-        # Extract session ID from filename (remove .jsonl extension)
-        session_id = session_log.stem
-
-        # Copy to output directory with original filename (preserves session ID)
-        # Place in 'chats' subdir to match the actual session log structure
-        chats_output_dir = output_dir / "chats"
-        chats_output_dir.mkdir(parents=True, exist_ok=True)
-        output_log = chats_output_dir / session_log.name
-
-        # Read the original file, modify cwd field, and write to output
-        # cwd should be the actual current working dir (where runner is executed)
-        actual_cwd = str(Path.cwd())
-        messages = []
-        start_time = None
-        async with aiofiles.open(session_log, 'r') as src, aiofiles.open(output_log, 'w') as dst:
-            async for line in src:
-                line = line.strip()
-                if line:
-                    try:
-                        record = json.loads(line)
-                        record['cwd'] = actual_cwd
-                        messages.append(record)
-                        if not start_time and 'time' in record:
-                            start_time = record['time']
-                        await dst.write(json.dumps(record, ensure_ascii=False) + '\n')
-                    except json.JSONDecodeError:
-                        # If line is not valid JSON, write it as-is
-                        await dst.write(line + '\n')
-
-        self.console.print(f"[dim]Session log copied: {session_log.name}[/dim]")
-
-        # Generate rendered HTML using the JS exporter script
-        rendered_html_path = chats_output_dir / f"{session_id}.html"
-        try:
-            exporter_script = Path(__file__).parent / "export-html-from-chatrecord-jsonl.js"
-            if exporter_script.exists():
-                # Call the JS script to generate the HTML
-                result = await self._run_command(
-                    ["node", str(exporter_script), str(output_log)],
-                    cwd=exporter_script.parent,
-                    timeout=30
-                )
-                if result.returncode == 0:
-                    self.console.print(f"[dim]Rendered chat HTML saved: {rendered_html_path.name}[/dim]")
-                else:
-                    self.console.print(f"[yellow]Warning: HTML exporter failed: {result.stderr}[/yellow]")
-            else:
-                self.console.print(f"[yellow]Warning: HTML exporter script not found at {exporter_script}[/yellow]")
-        except Exception as e:
-            self.console.print(f"[yellow]Warning: Failed to render chat HTML: {e}[/yellow]")
-
-        return output_log, session_id, rendered_html_path
-
-    async def _run_command(
-        self,
-        cmd: List[str],
-        cwd: Optional[Path] = None,
-        timeout: int = 60
-    ) -> subprocess.CompletedProcess:
-        """Run a command asynchronously."""
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            cwd=cwd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        try:
-            stdout, stderr = await asyncio.wait_for(
-                proc.communicate(), 
-                timeout=timeout
-            )
-            return subprocess.CompletedProcess(
-                args=cmd,
-                returncode=proc.returncode,
-                stdout=stdout.decode() if stdout else "",
-                stderr=stderr.decode() if stderr else "",
-            )
-        except asyncio.TimeoutError:
-            proc.kill()
-            await proc.wait()
-            raise RuntimeError(f"Command timed out after {timeout}s: {' '.join(cmd)}")
-
-
-class StatusTracker:
-    """Thread-safe status tracking with JSON persistence."""
-
-    def __init__(self, results_file: Path, console: Console):
-        self.results_file = results_file
-        self.console = console
-        self._lock = asyncio.Lock()
-        self._runs: Dict[str, RunRecord] = {}
-
-    async def initialize(self, runs: List[RunRecord]) -> None:
-        """Initialize the tracker with all runs."""
-        async with self._lock:
-            for run in runs:
-                self._runs[run.run_id] = run
-            await self._persist()
-
-    async def update_status(
-        self, 
-        run_id: str, 
-        status: RunStatus,
-        **kwargs
-    ) -> None:
-        """Update the status of a run."""
-        async with self._lock:
-            if run_id in self._runs:
-                run = self._runs[run_id]
-                run.status = status
-                for key, value in kwargs.items():
-                    if hasattr(run, key):
-                        setattr(run, key, value)
-                await self._persist()
-
-    async def _persist(self) -> None:
-        """Persist current state to JSON file and generate HTML report."""
-        data = {
-            "updated_at": datetime.now().isoformat(),
-            "runs": [run.to_dict() for run in self._runs.values()],
-        }
-        
-        # Write JSON atomically
-        temp_file = self.results_file.with_suffix('.tmp')
-        async with aiofiles.open(temp_file, 'w') as f:
-            await f.write(json.dumps(data, indent=2))
-        
-        temp_file.replace(self.results_file)
-
-        # Generate HTML report
-        await self._generate_html(data)
-
-    async def _generate_html(self, data: Dict[str, Any]) -> None:
-        """Generate a beautiful HTML report."""
-        html_file = self.results_file.with_name("index.html")
-        
-        # Calculate summary
-        total = len(data["runs"])
-        succeeded = sum(1 for r in data["runs"] if r["status"] == "succeeded")
-        failed = sum(1 for r in data["runs"] if r["status"] == "failed")
-        running = sum(1 for r in data["runs"] if r["status"] in ["preparing", "running"])
-        
-        # Build rows
-        rows = []
-        for run in sorted(data["runs"], key=lambda x: x.get("started_at") or "", reverse=True):
-            status = run["status"]
-            status_class = f"status-{status}"
-            
-            # Links
-            links = []
-            
-            # Output Directory
-            if run.get("output_dir"):
-                # Make path absolute for local viewing
-                abs_output_dir = os.path.abspath(run["output_dir"])
-                links.append(f'<a href="file://{abs_output_dir}">Outputs</a>')
-            
-            # Diff File
-            if run.get("diff_file"):
-                abs_diff_file = os.path.abspath(run["diff_file"])
-                links.append(f'<a href="file://{abs_diff_file}">Diff</a>')
-                
-            # Session Log
-            if run.get("session_html_file"):
-                abs_session_html = os.path.abspath(run["session_html_file"])
-                links.append(f'<a href="file://{abs_session_html}">Chat</a>')
-            elif run.get("session_log_file"):
-                abs_session_log = os.path.abspath(run["session_log_file"])
-                links.append(f'<a href="file://{abs_session_log}">Chat (Raw)</a>')
-
-            # Worktree
-            if run.get("worktree_path"):
-                abs_worktree = os.path.abspath(run["worktree_path"])
-                links.append(f'<a href="file://{abs_worktree}">Worktree</a>')
-
-            # Prompt results (stdout/stderr)
-            prompt_links = []
-            for i, p in enumerate(run.get("prompt_results", []), 1):
-                p_links = []
-                if p.get("stdout_file"):
-                    p_links.append(f'<a href="file://{os.path.abspath(p["stdout_file"])}">out</a>')
-                if p.get("stderr_file"):
-                    p_links.append(f'<a href="file://{os.path.abspath(p["stderr_file"])}">err</a>')
-                
-                if p_links:
-                    prompt_links.append(f'P{i}: {"|".join(p_links)}')
-
-            links_html = " | ".join(links)
-            prompts_html = "<br>".join(prompt_links)
-            
-            duration = "N/A"
-            if run.get("started_at") and run.get("ended_at"):
-                try:
-                    start = datetime.fromisoformat(run["started_at"])
-                    end = datetime.fromisoformat(run["ended_at"])
-                    duration = f"{(end - start).total_seconds():.1f}s"
-                except: pass
-
-            error_msg = f'<div class="error-msg">{html.escape(run["error_message"])}</div>' if run.get("error_message") else ""
-
-            rows.append(f"""
-                <tr>
-                    <td><code>{run["run_id"]}</code></td>
-                    <td>{html.escape(run["task_name"])}</td>
-                    <td>{html.escape(run["model"])}</td>
-                    <td><span class="status-pill {status_class}">{status}</span></td>
-                    <td>{duration}</td>
-                    <td class="links">{links_html}</td>
-                    <td class="links">{prompts_html}</td>
-                    <td>{error_msg}</td>
-                </tr>
-            """)
-
-        html_content = f"""<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8">
-    <title>Qwen Runner Report</title>
-    <style>
-        body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; background: #f5f7f9; }}
-        h1 {{ color: #1a202c; }}
-        .summary {{ display: flex; gap: 20px; margin-bottom: 30px; }}
-        .summary-card {{ background: white; padding: 15px 25px; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); flex: 1; }}
-        .summary-card h3 {{ margin: 0; font-size: 14px; text-transform: uppercase; color: #718096; }}
-        .summary-card .value {{ font-size: 24px; font-weight: bold; margin-top: 5px; }}
-        table {{ width: 100%; border-collapse: collapse; background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }}
-        th, td {{ padding: 12px 15px; text-align: left; border-bottom: 1px solid #e2e8f0; }}
-        th {{ background: #edf2f7; font-weight: 600; color: #4a5568; }}
-        tr:hover {{ background: #f7fafc; }}
-        .status-pill {{ padding: 4px 8px; border-radius: 9999px; font-size: 12px; font-weight: 500; text-transform: uppercase; }}
-        .status-succeeded {{ background: #c6f6d5; color: #22543d; }}
-        .status-failed {{ background: #fed7d7; color: #822727; }}
-        .status-running {{ background: #bee3f8; color: #2a4365; }}
-        .status-preparing {{ background: #e9d8fd; color: #44337a; }}
-        .status-queued {{ background: #edf2f7; color: #4a5568; }}
-        .links a {{ color: #3182ce; text-decoration: none; font-size: 13px; }}
-        .links a:hover {{ text-decoration: underline; }}
-        .error-msg {{ color: #e53e3e; font-size: 12px; margin-top: 4px; max-width: 300px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }}
-        code {{ background: #f1f5f9; padding: 2px 4px; border-radius: 4px; font-family: monospace; font-size: 12px; }}
-    </style>
-</head>
-<body>
-    <h1>Qwen Runner Execution Report</h1>
-    <div class="summary">
-        <div class="summary-card"><h3>Total</h3><div class="value">{total}</div></div>
-        <div class="summary-card"><h3 style="color: #38a169;">Succeeded</h3><div class="value" style="color: #38a169;">{succeeded}</div></div>
-        <div class="summary-card"><h3 style="color: #e53e3e;">Failed</h3><div class="value" style="color: #e53e3e;">{failed}</div></div>
-        <div class="summary-card"><h3 style="color: #3182ce;">Running</h3><div class="value" style="color: #3182ce;">{running}</div></div>
-    </div>
-    <table>
-        <thead>
-            <tr>
-                <th>ID</th>
-                <th>Task</th>
-                <th>Model</th>
-                <th>Status</th>
-                <th>Duration</th>
-                <th>Logs & Artifacts</th>
-                <th>Prompts</th>
-                <th>Error</th>
-            </tr>
-        </thead>
-        <tbody>
-            {"".join(rows)}
-        </tbody>
-    </table>
-    <div style="margin-top: 20px; color: #718096; font-size: 12px; text-align: right;">
-        Updated at: {data["updated_at"]}
-    </div>
-</body>
-</html>"""
-
-        async with aiofiles.open(html_file, 'w') as f:
-            await f.write(html_content)
-
-    def get_state(self) -> ExecutionState:
-        """Get current execution state."""
-        runs = list(self._runs.values())
-        completed = sum(1 for r in runs if r.status in (RunStatus.SUCCEEDED, RunStatus.FAILED))
-        succeeded = sum(1 for r in runs if r.status == RunStatus.SUCCEEDED)
-        failed = sum(1 for r in runs if r.status == RunStatus.FAILED)
-        
-        return ExecutionState(
-            runs=runs,
-            total=len(runs),
-            completed=completed,
-            succeeded=succeeded,
-            failed=failed,
-        )
-
-    def get_active_runs(self) -> List[RunRecord]:
-        """Get currently active runs."""
-        active_statuses = {RunStatus.PREPARING, RunStatus.RUNNING}
-        return [r for r in self._runs.values() if r.status in active_statuses]
-
-
-class ProgressDisplay:
-    """Rich-based progress display."""
-
-    def __init__(self, console: Console):
-        self.console = console
-        self.live: Optional[Live] = None
-
-    def start(self) -> None:
-        """Start the live display."""
-        self.live = Live(auto_refresh=True, console=self.console)
-        self.live.start()
-
-    def stop(self) -> None:
-        """Stop the live display."""
-        if self.live:
-            self.live.stop()
-
-    def update(self, state: ExecutionState) -> None:
-        """Update the display with current state."""
-        if not self.live:
-            return
-
-        # Summary panel
-        summary = Table.grid(expand=True)
-        summary.add_column()
-        summary.add_column()
-        summary.add_row(
-            f"[bold]Total:[/bold] {state.total}",
-            f"[bold]Completed:[/bold] {state.completed}/{state.total}"
-        )
-        summary.add_row(
-            f"[green bold]Succeeded:[/green bold] {state.succeeded}",
-            f"[red bold]Failed:[/red bold] {state.failed}"
-        )
-
-        # Active runs table
-        active_runs = [r for r in state.runs if r.status not in (RunStatus.SUCCEEDED, RunStatus.FAILED, RunStatus.QUEUED)]
-        
-        runs_table = Table(
-            title="Active Runs",
-            show_header=True,
-            header_style="bold magenta",
-            expand=True,
-        )
-        runs_table.add_column("Task", style="cyan")
-        runs_table.add_column("Model", style="green")
-        runs_table.add_column("Status", style="yellow")
-        runs_table.add_column("Started", style="dim")
-
-        for run in active_runs[:10]:  # Show up to 10 active runs
-            started = run.started_at or "N/A"
-            if len(started) > 19:
-                started = started[11:19]  # Extract time portion
-            runs_table.add_row(
-                run.task_name[:30],
-                run.model[:25],
-                run.status.value,
-                started,
-            )
-
-        # Recent completed runs
-        completed_runs = sorted(
-            [r for r in state.runs if r.status in (RunStatus.SUCCEEDED, RunStatus.FAILED)],
-            key=lambda r: r.ended_at or "",
-            reverse=True,
-        )[:5]
-
-        completed_table = Table(
-            title="Recently Completed",
-            show_header=True,
-            header_style="bold blue",
-            expand=True,
-        )
-        completed_table.add_column("Task", style="cyan")
-        completed_table.add_column("Model", style="green")
-        completed_table.add_column("Status", style="bold")
-        completed_table.add_column("Duration", style="dim")
-
-        for run in completed_runs:
-            status_color = "green" if run.status == RunStatus.SUCCEEDED else "red"
-            duration = "N/A"
-            if run.started_at and run.ended_at:
-                try:
-                    start = datetime.fromisoformat(run.started_at)
-                    end = datetime.fromisoformat(run.ended_at)
-                    duration_sec = (end - start).total_seconds()
-                    duration = f"{duration_sec:.1f}s"
-                except:
-                    pass
-            
-            completed_table.add_row(
-                run.task_name[:30],
-                run.model[:25],
-                f"[{status_color}]{run.status.value}[/{status_color}]",
-                duration,
-            )
-
-        # Combine everything
-        layout = Table.grid(expand=True)
-        layout.add_column()
-        layout.add_row(Panel(summary, title="Execution Summary", border_style="blue"))
-        layout.add_row(runs_table)
-        if completed_runs:
-            layout.add_row(completed_table)
-
-        self.live.update(layout)
-
-    def show_final_summary(self, state: ExecutionState) -> None:
-        """Show final execution summary."""
-        self.console.print()
-        self.console.print(Panel(
-            f"[bold green]Execution Complete![/bold green]\n\n"
-            f"Total Runs: {state.total}\n"
-            f"Succeeded: [green]{state.succeeded}[/green]\n"
-            f"Failed: [red]{state.failed}[/red]\n"
-            f"Success Rate: {(state.succeeded / state.total * 100):.1f}%",
-            title="Final Results",
-            border_style="green" if state.failed == 0 else "yellow",
-        ))
-
-
-class QwenRunner:
-    """Executes the Qwen CLI for a specific task and model."""
-
-    def __init__(self, config: RunConfig, console: Console):
-        self.config = config
-        self.console = console
-
-    async def run(
-        self,
-        run: RunRecord,
-        worktree_dir: Path,
-        output_dir: Path,
-    ) -> None:
-        """Execute the Qwen CLI for each prompt sequentially."""
-        output_dir.mkdir(parents=True, exist_ok=True)
-        run.output_dir = str(output_dir)
-
-        # Get the task and its prompts
-        task = next((t for t in self.config.tasks if t.id == run.task_id), None)
-        if not task or not task.prompts:
-            raise ValueError(f"No prompts found for task {run.task_id}")
-
-        # Setup logs directory
-        run_logs_dir = (output_dir / "openai-logs").resolve()
-        run_logs_dir.mkdir(parents=True, exist_ok=True)
-        run.logs_dir = str(run_logs_dir)
-
-        # Create outputs subdirectory for cleaner structure
-        outputs_subdir = output_dir / "outputs"
-        outputs_subdir.mkdir(parents=True, exist_ok=True)
-
-        # Run each prompt sequentially
-        for prompt_index, prompt_text in enumerate(task.prompts, start=1):
-            self.console.print(f"[blue]Executing prompt {prompt_index}/{len(task.prompts)}...[/blue]")
-
-            # Build command for this prompt
-            cmd = self._build_command(run, prompt_text, prompt_index > 1)
-            self.console.print(f"[dim]Command: {' '.join(cmd)}[/dim]")
-
-            # Prepare output files for this prompt
-            stdout_file = outputs_subdir / f"stdout-{prompt_index}.txt"
-            stderr_file = outputs_subdir / f"stderr-{prompt_index}.txt"
-
-            # Run the CLI
-            env = os.environ.copy()
-            worktree_dir_resolved = worktree_dir.resolve()
-            env["QWEN_CODE_ROOT"] = str(worktree_dir_resolved)
-
-            proc = await asyncio.create_subprocess_exec(
-                *cmd,
-                cwd=worktree_dir_resolved,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                env=env,
-            )
-
-            # Capture output
-            async def read_stream(stream, file_path):
-                async with aiofiles.open(file_path, 'w') as f:
-                    while True:
-                        line = await stream.readline()
-                        if not line:
-                            break
-                        decoded = line.decode()
-                        await f.write(decoded)
-                        await f.flush()
-
-            await asyncio.gather(
-                read_stream(proc.stdout, stdout_file),
-                read_stream(proc.stderr, stderr_file),
-            )
-
-            returncode = await proc.wait()
-
-            # Record result for this prompt
-            prompt_result = PromptResult(
-                prompt_index=prompt_index,
-                prompt_text=prompt_text,
-                stdout_file=str(stdout_file),
-                stderr_file=str(stderr_file),
-                exit_code=returncode,
-                status="succeeded" if returncode == 0 else "failed",
-            )
-            run.prompt_results.append(prompt_result)
-
-            # Stop on failure
-            if returncode != 0:
-                run.exit_code = returncode
-                raise RuntimeError(f"Prompt {prompt_index} failed with exit code {returncode}")
-
-        # All prompts succeeded
-        run.exit_code = 0
-        # Set legacy stdout/stderr files to first prompt's files for backwards compatibility
-        if run.prompt_results:
-            run.stdout_file = run.prompt_results[0].stdout_file
-            run.stderr_file = run.prompt_results[0].stderr_file
-
-    def _build_command(self, run: RunRecord, prompt_text: str, use_continue: bool = False) -> List[str]:
-        """Build the qwen CLI command for a single prompt."""
-        cmd = ["qwen"]
-
-        # Add model
-        cmd.extend(["--model", run.model])
-
-        # Add auth-type when model uses non-OpenAI protocol (e.g. anthropic for glm-4.7)
-        if run.auth_type:
-            cmd.extend(["--auth-type", run.auth_type])
-
-        # Add yolo if enabled
-        if self.config.yolo:
-            cmd.append("--yolo")
-
-        # Always enable OpenAI logging to run-specific logs directory
-        cmd.append("--openai-logging")
-        cmd.extend(["--openai-logging-dir", run.logs_dir])
-
-        # Add --continue flag for follow-up prompts (to pick up chat history)
-        if use_continue:
-            cmd.append("--continue")
-
-        # Add the prompt
-        cmd.extend(["--prompt", prompt_text])
-
-        return cmd
-
-
-def generate_run_matrix(config: RunConfig) -> List[RunRecord]:
-    """Generate all task × model combinations."""
-    runs = []
-    for task in config.tasks:
-        for model in config.models:
-            runs.append(RunRecord(
-                run_id=str(uuid.uuid4())[:8],
-                task_id=task.id,
-                task_name=task.name,
-                model=model.name,
-                status=RunStatus.QUEUED,
-                auth_type=model.auth_type,
-            ))
-    return runs
-
-
-def _parse_models(data_models: List[Any]) -> List[ModelSpec]:
-    """Parse models: string or {name, auth_type/authType}; returns list of ModelSpec."""
-    specs: List[ModelSpec] = []
-    for item in data_models or []:
-        if isinstance(item, str):
-            name, auth = item, None
-        elif isinstance(item, dict) and item.get("name"):
-            name = item["name"]
-            auth = item.get("auth_type") or item.get("authType")
-        else:
-            continue
-        specs.append(ModelSpec(name=name, auth_type=auth))
-    return specs
-
-
-def load_config(config_path: Path) -> RunConfig:
-    """Load configuration from JSON file."""
-    with open(config_path, 'r') as f:
-        data = json.load(f)
-    tasks = [Task(**t) for t in data.get("tasks", [])]
-    models = _parse_models(data.get("models", []))
-    return RunConfig(
-        tasks=tasks,
-        models=models,
-        concurrency=data.get("concurrency", 4),
-        yolo=data.get("yolo", True),
-        source_repo=Path(data.get("source_repo", ".")).resolve(),
-        worktree_base=Path(data.get("worktree_base", "~/.qwen/worktrees")).expanduser(),
-        outputs_dir=Path(data.get("outputs_dir", "./outputs")),
-        results_file=Path(data.get("results_file", "./results.json")),
-        branch=data.get("branch"),
-        keep_worktree=data.get("keep_worktree", False),
-    )
-
-
-async def execute_single_run(
-    run: RunRecord,
-    config: RunConfig,
-    tracker: StatusTracker,
-    worktree_manager: GitWorktreeManager,
-    qwen_runner: QwenRunner,
-    console: Console,
-) -> None:
-    """Execute a single run with proper cleanup."""
-    worktree_dir = None
-    
-    try:
-        # Step 1: Create worktree
-        await tracker.update_status(run.run_id, RunStatus.PREPARING)
-        worktree_dir = config.worktree_base / f"run-{run.run_id}"
-        await worktree_manager.create(config.source_repo, worktree_dir, config.branch)
-        run.worktree_path = str(worktree_dir)
-        run.started_at = datetime.now().isoformat()
-        
-        # Step 2: Run CLI
-        await tracker.update_status(run.run_id, RunStatus.RUNNING)
-        output_dir = config.outputs_dir / run.run_id
-        await qwen_runner.run(run, worktree_dir, output_dir)
-        
-        # Step 3: Success
-        run.ended_at = datetime.now().isoformat()
-        await tracker.update_status(
-            run.run_id, 
-            RunStatus.SUCCEEDED,
-            exit_code=run.exit_code,
-            ended_at=run.ended_at,
-        )
-        console.print(f"[green]✓[/green] {run.task_name} / {run.model}")
-        
-    except Exception as e:
-        run.ended_at = datetime.now().isoformat()
-        await tracker.update_status(
-            run.run_id,
-            RunStatus.FAILED,
-            error_message=str(e),
-            ended_at=run.ended_at,
-        )
-        console.print(f"[red]✗[/red] {run.task_name} / {run.model}: {e}")
-
-    finally:
-        # Step 4: Capture git diff (before cleanup)
-        output_dir = config.outputs_dir / run.run_id
-        output_dir.mkdir(parents=True, exist_ok=True)
-
-        if worktree_dir and worktree_dir.exists():
-            try:
-                diff_content = await worktree_manager.get_diff(worktree_dir)
-                if diff_content.strip():
-                    diff_file = output_dir / "diff.patch"
-                    async with aiofiles.open(diff_file, 'w') as f:
-                        await f.write(diff_content)
-                    run.diff_file = str(diff_file)
-                    console.print(f"[dim]Diff saved to {diff_file}[/dim]")
-            except Exception as e:
-                console.print(f"[yellow]Warning: Failed to capture diff: {e}[/yellow]")
-
-        # Step 5: Collect session log (before cleanup)
-        if worktree_dir:
-            try:
-                result = await worktree_manager.collect_session_log(worktree_dir, output_dir)
-                if result:
-                    session_log, session_id, session_html = result
-                    run.session_log_file = str(session_log)
-                    run.session_html_file = str(session_html)
-                    run.session_id = session_id
-                    console.print(f"[dim]Session log saved: {session_log.name} (ID: {session_id})[/dim]")
-            except Exception as e:
-                console.print(f"[yellow]Warning: Failed to collect session log: {e}[/yellow]")
-
-        # Update tracker with all captured files
-        await tracker.update_status(
-            run.run_id,
-            run.status,
-            diff_file=run.diff_file,
-            session_log_file=run.session_log_file,
-            session_html_file=run.session_html_file,
-            session_id=run.session_id,
-        )
-
-        # Step 7: Cleanup
-        if worktree_dir:
-            if config.keep_worktree:
-                console.print(f"[dim]Keeping worktree: {worktree_dir}[/dim]")
-            else:
-                await worktree_manager.remove(worktree_dir)
-
-
-async def run_all(config: RunConfig, console: Console) -> ExecutionState:
-    """Run all task/model combinations concurrently."""
-    # Setup directories
-    config.worktree_base.mkdir(parents=True, exist_ok=True)
-    config.outputs_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Generate all runs
-    runs = generate_run_matrix(config)
-    console.print(f"[bold]Generated {len(runs)} runs:[/bold] {len(config.tasks)} tasks × {len(config.models)} models")
-    
-    # Initialize components
-    tracker = StatusTracker(config.results_file, console)
-    await tracker.initialize(runs)
-    
-    worktree_manager = GitWorktreeManager(console, config.source_repo)
-    await worktree_manager.ensure_git_repo()
-    qwen_runner = QwenRunner(config, console)
-    display = ProgressDisplay(console)
-
-    # Start progress display
-    display.start()
-
-    # Progress update task
-    stop_event = asyncio.Event()
-
-    async def update_progress():
-        while not stop_event.is_set():
-            state = tracker.get_state()
-            display.update(state)
-            if state.completed >= state.total:
-                stop_event.set()
-                break
-            try:
-                await asyncio.wait_for(stop_event.wait(), timeout=0.5)
-            except asyncio.TimeoutError:
-                continue
-
-    # Execute runs with semaphore-controlled concurrency
-    semaphore = asyncio.Semaphore(config.concurrency)
-
-    async def execute_with_limit(run: RunRecord):
-        async with semaphore:
-            await execute_single_run(
-                run, config, tracker, worktree_manager, qwen_runner, console
-            )
-
-    # Run everything
-    try:
-        await asyncio.gather(
-            update_progress(),
-            asyncio.gather(*[execute_with_limit(r) for r in runs]),
-        )
-    finally:
-        stop_event.set()
-        display.stop()
-
-    # Show final summary
-    final_state = tracker.get_state()
-    display.show_final_summary(final_state)
-    
-    return final_state
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Qwen Concurrent Runner - Execute multiple CLI tasks across models"
-    )
-    parser.add_argument(
-        "config",
-        type=Path,
-        help="Path to configuration JSON file",
-    )
-    parser.add_argument(
-        "--version",
-        action="version",
-        version="%(prog)s 1.0.0",
-    )
-    
-    args = parser.parse_args()
-    
-    if not args.config.exists():
-        print(f"Error: Config file not found: {args.config}", file=sys.stderr)
-        sys.exit(1)
-    
-    console = Console()
-    config = load_config(args.config)
-    
-    try:
-        final_state = asyncio.run(run_all(config, console))
-        sys.exit(0 if final_state.failed == 0 else 1)
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Interrupted by user[/yellow]")
-        sys.exit(130)
-    except Exception as e:
-        console.print(f"\n[red]Fatal error: {e}[/red]")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()