@weldr/runr 0.3.0

package/dist/commands/gc.js

@@ -0,0 +1,161 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getRunrPaths } from '../store/runs-root.js';
+/**
+ * Get directory size recursively (in bytes)
+ */
+function getDirSize(dirPath) {
+    let size = 0;
+    try {
+        const items = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item.name);
+            if (item.isDirectory()) {
+                size += getDirSize(itemPath);
+            }
+            else if (item.isFile()) {
+                const stat = fs.statSync(itemPath);
+                size += stat.size;
+            }
+        }
+    }
+    catch {
+        // Ignore errors (permission denied, etc.)
+    }
+    return size;
+}
+/**
+ * Format bytes to human-readable size
+ */
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
+/**
+ * Get modification time of directory (most recent file)
+ */
+function getDirModTime(dirPath) {
+    try {
+        const stat = fs.statSync(dirPath);
+        return stat.mtime;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Recursively delete a directory
+ */
+function rmDir(dirPath) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+}
+/**
+ * Scan worktrees (current and legacy) and gather usage info
+ */
+function listRunIds(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    return fs.readdirSync(dirPath, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && /^\d{14}$/.test(entry.name))
+        .map(entry => entry.name);
+}
+/**
+ * Scan worktrees in all locations:
+ * - Current: .runr-worktrees/<runId>/ (or .agent-worktrees/ for legacy)
+ * - Legacy v1: .agent/runs/<runId>/worktree/
+ * - Legacy v2: .agent/worktrees/<runId>/ (pre-migration)
+ */
+function scanWorktrees(runsDir, worktreesDir, runrRoot) {
+    const worktrees = [];
+    const now = new Date();
+    // Legacy v2 location: .agent/worktrees/ (worktrees inside .agent before the fix)
+    const legacyWorktreesDir = path.join(runrRoot, 'worktrees');
+    const runIds = new Set([
+        ...listRunIds(runsDir),
+        ...listRunIds(worktreesDir),
+        ...listRunIds(legacyWorktreesDir)
+    ]);
+    for (const runId of runIds) {
+        const newPath = path.join(worktreesDir, runId);
+        const legacyV1Path = path.join(runsDir, runId, 'worktree');
+        const legacyV2Path = path.join(legacyWorktreesDir, runId);
+        const candidates = [];
+        if (fs.existsSync(newPath)) {
+            candidates.push({ path: newPath, label: runId });
+        }
+        if (fs.existsSync(legacyV2Path) && legacyV2Path !== newPath) {
+            candidates.push({ path: legacyV2Path, label: `${runId} (legacy v2)` });
+        }
+        if (fs.existsSync(legacyV1Path)) {
+            candidates.push({ path: legacyV1Path, label: `${runId} (legacy v1)` });
+        }
+        for (const candidate of candidates) {
+            const worktreeSize = getDirSize(candidate.path);
+            const worktreeModified = getDirModTime(candidate.path);
+            const ageDays = worktreeModified
+                ? Math.floor((now.getTime() - worktreeModified.getTime()) / (1000 * 60 * 60 * 24))
+                : null;
+            worktrees.push({
+                runId,
+                label: candidate.label,
+                worktreePath: candidate.path,
+                worktreeSize,
+                worktreeModified,
+                ageDays
+            });
+        }
+    }
+    return worktrees.sort((a, b) => a.runId.localeCompare(b.runId));
+}
+export async function gcCommand(options) {
+    const paths = getRunrPaths(options.repo);
+    const worktrees = scanWorktrees(paths.runs_dir, paths.worktrees_dir, paths.runr_root);
+    // Calculate totals
+    const totalRuns = worktrees.length;
+    const totalWorktreeSize = worktrees.reduce((sum, r) => sum + r.worktreeSize, 0);
+    // Find runs eligible for cleanup
+    const eligibleForCleanup = worktrees.filter(r => r.ageDays !== null && r.ageDays >= options.olderThan);
+    const cleanupSize = eligibleForCleanup.reduce((sum, r) => sum + r.worktreeSize, 0);
+    console.log('=== Disk Usage Summary ===\n');
+    console.log(`Total worktrees: ${totalRuns}`);
+    console.log(`Total worktree size: ${formatSize(totalWorktreeSize)}`);
+    console.log('');
+    if (worktrees.length > 0) {
+        console.log('=== Worktree Details ===\n');
+        console.log('| Worktree        | Age (days) | Size     |');
+        console.log('|-----------------|------------|----------|');
+        for (const run of worktrees) {
+            const age = run.ageDays !== null ? String(run.ageDays).padStart(10) : '       N/A';
+            const size = formatSize(run.worktreeSize).padStart(8);
+            console.log(`| ${run.label} | ${age} | ${size} |`);
+        }
+        console.log('');
+    }
+    if (eligibleForCleanup.length === 0) {
+        console.log(`No worktrees older than ${options.olderThan} days found.`);
+        return;
+    }
+    console.log(`=== Cleanup ${options.dryRun ? '(DRY RUN)' : ''} ===\n`);
+    console.log(`Found ${eligibleForCleanup.length} worktrees older than ${options.olderThan} days`);
+    console.log(`Total size to reclaim: ${formatSize(cleanupSize)}\n`);
+    for (const run of eligibleForCleanup) {
+        const msg = `${options.dryRun ? '[DRY RUN] Would delete' : 'Deleting'}: ${run.label} (${formatSize(run.worktreeSize)}, ${run.ageDays}d old)`;
+        console.log(msg);
+        if (!options.dryRun) {
+            rmDir(run.worktreePath);
+        }
+    }
+    console.log('');
+    if (options.dryRun) {
+        console.log(`Dry run complete. Use without --dry-run to actually delete.`);
+    }
+    else {
+        console.log(`Cleanup complete. Reclaimed ${formatSize(cleanupSize)}.`);
+    }
+}

package/dist/commands/guards-only.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig, resolveConfigPath } from '../config/load.js';
+import { RunStore } from '../store/run-store.js';
+import { getRunsRoot } from '../store/runs-root.js';
+import { buildMilestonesFromTask } from '../supervisor/planner.js';
+import { runPreflight } from './preflight.js';
+function makeRunId() {
+    const now = new Date();
+    const parts = [
+        now.getUTCFullYear(),
+        String(now.getUTCMonth() + 1).padStart(2, '0'),
+        String(now.getUTCDate()).padStart(2, '0'),
+        String(now.getUTCHours()).padStart(2, '0'),
+        String(now.getUTCMinutes()).padStart(2, '0'),
+        String(now.getUTCSeconds()).padStart(2, '0')
+    ];
+    return parts.join('');
+}
+function slugFromTask(taskPath) {
+    const base = path.basename(taskPath, path.extname(taskPath));
+    return base.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+}
+function formatSummaryLine(input) {
+    return [
+        `run_id=${input.runId}`,
+        `run_dir=${input.runDir}`,
+        `repo_root=${input.repoRoot}`,
+        `current_branch=${input.currentBranch}`,
+        `planned_run_branch=${input.plannedRunBranch}`,
+        `guard=${input.guardOk ? 'pass' : 'fail'}`,
+        `tiers=${input.tiers.join('|')}`,
+        `tier_reasons=${input.tierReasons.join('|') || 'none'}`,
+        `no_write=${input.noWrite ? 'true' : 'false'}`
+    ].join(' ');
+}
+export async function guardsOnlyCommand(options) {
+    const repoPath = path.resolve(options.repo);
+    const taskPath = path.resolve(options.task);
+    const configPath = resolveConfigPath(repoPath, options.config);
+    const config = loadConfig(configPath);
+    const taskText = fs.readFileSync(taskPath, 'utf-8');
+    const milestones = buildMilestonesFromTask(taskText);
+    const milestoneRiskLevel = milestones[0]?.risk_level ?? 'medium';
+    const runId = makeRunId();
+    const slug = slugFromTask(taskPath);
+    const runDir = path.join(getRunsRoot(repoPath), runId);
+    const preflight = await runPreflight({
+        repoPath,
+        runId,
+        slug,
+        config,
+        allowDeps: options.allowDeps,
+        allowDirty: options.allowDirty,
+        milestoneRiskLevel,
+        skipPing: options.skipPing ?? true // Skip ping by default for guards-only
+    });
+    if (!options.noWrite) {
+        const runStore = RunStore.init(runId, repoPath);
+        runStore.writeConfigSnapshot(config);
+        runStore.writeArtifact('task.md', taskText);
+        runStore.appendEvent({
+            type: 'preflight',
+            source: 'cli',
+            payload: {
+                repo: preflight.repo_context,
+                guard: preflight.guard,
+                binary: preflight.binary,
+                ping: preflight.ping,
+                tiers: preflight.tiers,
+                tier_reasons: preflight.tier_reasons,
+                allow_dirty: options.allowDirty,
+                allow_deps: options.allowDeps
+            }
+        });
+    }
+    const summaryLine = formatSummaryLine({
+        runId,
+        runDir,
+        repoRoot: preflight.repo_context.git_root,
+        currentBranch: preflight.repo_context.current_branch,
+        plannedRunBranch: preflight.repo_context.run_branch,
+        guardOk: preflight.guard.ok,
+        tiers: preflight.tiers,
+        tierReasons: preflight.tier_reasons,
+        noWrite: options.noWrite
+    });
+    console.log(summaryLine);
+}

package/dist/commands/metrics.js

@@ -0,0 +1,441 @@
+/**
+ * Metrics aggregation command.
+ *
+ * Collects and aggregates metrics across all runs and orchestrations.
+ * Designed for fast collection with O(n) file reads.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getRunsRoot, getOrchestrationsRoot, getAgentPaths } from '../store/runs-root.js';
+// Get agent version from package.json
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = path.resolve(__dirname, '../../package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+const AGENT_VERSION = packageJson.version;
+/**
+ * Parse a run ID to get its timestamp.
+ * Run IDs are in format YYYYMMDDHHmmss.
+ */
+function parseRunTimestamp(runId) {
+    const match = runId.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/);
+    if (!match)
+        return null;
+    const [, year, month, day, hour, minute, second] = match;
+    return new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), parseInt(hour, 10), parseInt(minute, 10), parseInt(second, 10));
+}
+/**
+ * Parse an orchestrator ID to get its timestamp.
+ * Orchestrator IDs are in format orch-YYYYMMDD-HHmmss-XXX.
+ */
+function parseOrchTimestamp(orchId) {
+    const match = orchId.match(/^orch-(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})/);
+    if (!match)
+        return null;
+    const [, year, month, day, hour, minute, second] = match;
+    return new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), parseInt(hour, 10), parseInt(minute, 10), parseInt(second, 10));
+}
+/**
+ * Compute percentiles from a sorted array of numbers.
+ */
+function computePercentiles(sortedDurations) {
+    if (sortedDurations.length === 0) {
+        return { p50: null, p90: null, max: null };
+    }
+    const p50Index = Math.floor(sortedDurations.length * 0.5);
+    const p90Index = Math.floor(sortedDurations.length * 0.9);
+    return {
+        p50: Math.round(sortedDurations[p50Index]),
+        p90: Math.round(sortedDurations[p90Index]),
+        max: Math.round(sortedDurations[sortedDurations.length - 1])
+    };
+}
+/**
+ * Get top N stop reasons sorted by count descending.
+ */
+function getTopStopReasons(byStopReason, limit = 5) {
+    return Object.entries(byStopReason)
+        .map(([reason, count]) => ({ reason, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, limit);
+}
+/**
+ * Collect metrics from all runs and orchestrations.
+ */
+export function collectMetrics(repoPath, days = 30, windowLimit) {
+    const now = new Date();
+    const cutoffDate = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+    const runsRoot = getRunsRoot(repoPath);
+    const orchRoot = getOrchestrationsRoot(repoPath);
+    const agentPaths = getAgentPaths(repoPath);
+    // Track filtering
+    let runsFilteredOut = 0;
+    let orchsFilteredOut = 0;
+    // Track durations for percentile calculation
+    const runDurations = [];
+    const orchDurations = [];
+    // Track orchestration stop reasons
+    const orchByStopReason = {};
+    // Track collisions
+    let totalCollisions = 0;
+    const collisionsByStage = {};
+    // Initialize counters
+    const metrics = {
+        schema_version: 1,
+        agent_version: AGENT_VERSION,
+        repo_root: path.resolve(repoPath),
+        collected_at: now.toISOString(),
+        period: {
+            days,
+            from: cutoffDate.toISOString(),
+            to: now.toISOString(),
+            runs_considered: 0,
+            runs_filtered_out: 0,
+            window: windowLimit ?? null
+        },
+        paths: agentPaths,
+        runs: {
+            total: 0,
+            complete: 0,
+            stopped: 0,
+            running: 0,
+            success_rate: 0,
+            by_stop_reason: {},
+            top_stop_reasons: [],
+            avg_duration_ms: null,
+            durations_ms: { p50: null, p90: null, max: null }
+        },
+        orchestrations: {
+            total: 0,
+            complete: 0,
+            stopped: 0,
+            failed: 0,
+            running: 0,
+            success_rate: 0,
+            by_collision_policy: {},
+            top_stop_reasons: [],
+            durations_ms: { p50: null, p90: null, max: null }
+        },
+        collisions: {
+            total: 0,
+            by_stage: {}
+        },
+        workers: {
+            total_calls: 0,
+            claude: 0,
+            codex: 0
+        },
+        auto_resume: {
+            total_attempts: 0,
+            successful_recoveries: 0
+        },
+        milestones: {
+            total_completed: 0,
+            avg_per_run: 0
+        }
+    };
+    let totalDurationMs = 0;
+    let durationCount = 0;
+    let oldestRun = null;
+    // Collect run metrics (fast path: only read state.json, not timeline)
+    if (fs.existsSync(runsRoot)) {
+        // Get all run directories with their timestamps
+        const runDirs = fs.readdirSync(runsRoot, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => ({ name: d.name, timestamp: parseRunTimestamp(d.name) }))
+            .filter(r => r.timestamp !== null);
+        // Sort by timestamp descending (newest first) for window limiting
+        runDirs.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        // Apply window limit (default 50 for runs)
+        const runWindowLimit = windowLimit ?? 50;
+        let runCount = 0;
+        for (const { name: runId, timestamp } of runDirs) {
+            // Filter by date cutoff
+            if (timestamp < cutoffDate) {
+                runsFilteredOut++;
+                continue;
+            }
+            // Apply window limit
+            if (runCount >= runWindowLimit) {
+                runsFilteredOut++;
+                continue;
+            }
+            runCount++;
+            if (!oldestRun || timestamp < oldestRun) {
+                oldestRun = timestamp;
+            }
+            const statePath = path.join(runsRoot, runId, 'state.json');
+            if (!fs.existsSync(statePath))
+                continue;
+            try {
+                const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                metrics.runs.total++;
+                // Count by phase/outcome
+                if (state.phase === 'STOPPED') {
+                    metrics.runs.stopped++;
+                    const reason = state.stop_reason ?? 'unknown';
+                    metrics.runs.by_stop_reason[reason] = (metrics.runs.by_stop_reason[reason] ?? 0) + 1;
+                }
+                else if (state.phase === 'FINALIZE') {
+                    metrics.runs.complete++;
+                }
+                else {
+                    metrics.runs.running++;
+                }
+                // Duration (use updated_at for ended runs)
+                if (state.started_at && state.updated_at &&
+                    (state.phase === 'STOPPED' || state.phase === 'FINALIZE')) {
+                    const duration = new Date(state.updated_at).getTime() - new Date(state.started_at).getTime();
+                    if (duration > 0) {
+                        totalDurationMs += duration;
+                        durationCount++;
+                        runDurations.push(duration);
+                    }
+                }
+                // Auto-resume count
+                if (state.auto_resume_count && state.auto_resume_count > 0) {
+                    metrics.auto_resume.total_attempts += state.auto_resume_count;
+                    // If completed after auto-resume, count as successful recovery
+                    if (state.phase === 'FINALIZE') {
+                        metrics.auto_resume.successful_recoveries++;
+                    }
+                }
+                // Milestones completed (milestone_index indicates progress)
+                // If run is complete, all milestones are done; otherwise use milestone_index
+                const milestonesComplete = state.phase === 'FINALIZE'
+                    ? state.milestones.length
+                    : state.milestone_index;
+                metrics.milestones.total_completed += milestonesComplete;
+            }
+            catch {
+                // Skip runs with invalid state
+            }
+        }
+    }
+    // Set period filtering counts
+    metrics.period.runs_considered = metrics.runs.total;
+    metrics.period.runs_filtered_out = runsFilteredOut;
+    // Compute derived run metrics
+    if (metrics.runs.total > 0) {
+        // Use float with 1 decimal place for success_rate
+        metrics.runs.success_rate = Math.round((metrics.runs.complete / metrics.runs.total) * 1000) / 10;
+        metrics.milestones.avg_per_run = Math.round((metrics.milestones.total_completed / metrics.runs.total) * 10) / 10;
+        // Top stop reasons
+        metrics.runs.top_stop_reasons = getTopStopReasons(metrics.runs.by_stop_reason);
+    }
+    if (durationCount > 0) {
+        metrics.runs.avg_duration_ms = Math.round(totalDurationMs / durationCount);
+        // Duration percentiles
+        runDurations.sort((a, b) => a - b);
+        metrics.runs.durations_ms = computePercentiles(runDurations);
+    }
+    if (oldestRun) {
+        metrics.period.from = oldestRun.toISOString();
+    }
+    // Collect orchestration metrics
+    if (fs.existsSync(orchRoot)) {
+        // Get all orchestration directories with their timestamps
+        const orchDirs = fs.readdirSync(orchRoot, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => ({ name: d.name, timestamp: parseOrchTimestamp(d.name) }))
+            .filter(o => o.timestamp !== null);
+        // Sort by timestamp descending (newest first) for window limiting
+        orchDirs.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        // Apply window limit (default 20 for orchestrations)
+        const orchWindowLimit = windowLimit ? Math.ceil(windowLimit * 0.4) : 20;
+        let orchCount = 0;
+        for (const { name: orchId, timestamp } of orchDirs) {
+            // Filter by date cutoff
+            if (timestamp < cutoffDate) {
+                orchsFilteredOut++;
+                continue;
+            }
+            // Apply window limit
+            if (orchCount >= orchWindowLimit) {
+                orchsFilteredOut++;
+                continue;
+            }
+            orchCount++;
+            const statePath = path.join(orchRoot, orchId, 'state.json');
+            if (!fs.existsSync(statePath))
+                continue;
+            try {
+                const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                metrics.orchestrations.total++;
+                // Count by status
+                switch (state.status) {
+                    case 'complete':
+                        metrics.orchestrations.complete++;
+                        break;
+                    case 'stopped':
+                        metrics.orchestrations.stopped++;
+                        orchByStopReason['stopped'] = (orchByStopReason['stopped'] ?? 0) + 1;
+                        break;
+                    case 'failed':
+                        metrics.orchestrations.failed++;
+                        orchByStopReason['failed'] = (orchByStopReason['failed'] ?? 0) + 1;
+                        break;
+                    case 'running':
+                        metrics.orchestrations.running++;
+                        break;
+                }
+                // Count by collision policy
+                const policy = state.policy?.collision_policy ?? state.collision_policy ?? 'serialize';
+                metrics.orchestrations.by_collision_policy[policy] =
+                    (metrics.orchestrations.by_collision_policy[policy] ?? 0) + 1;
+                // Duration (calculate from started_at to ended_at)
+                if (state.started_at && state.ended_at &&
+                    (state.status === 'complete' || state.status === 'stopped' || state.status === 'failed')) {
+                    const duration = new Date(state.ended_at).getTime() - new Date(state.started_at).getTime();
+                    if (duration > 0) {
+                        orchDurations.push(duration);
+                    }
+                }
+                // Read summary.json for collision data if it exists
+                const summaryPath = path.join(orchRoot, orchId, 'summary.json');
+                if (fs.existsSync(summaryPath)) {
+                    try {
+                        const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf-8'));
+                        if (summary.collisions && Array.isArray(summary.collisions)) {
+                            for (const collision of summary.collisions) {
+                                totalCollisions++;
+                                const stage = collision.stage ?? 'unknown';
+                                collisionsByStage[stage] = (collisionsByStage[stage] ?? 0) + 1;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip invalid summary
+                    }
+                }
+            }
+            catch {
+                // Skip orchestrations with invalid state
+            }
+        }
+    }
+    // Compute derived orchestration metrics
+    if (metrics.orchestrations.total > 0) {
+        // Use float with 1 decimal place for success_rate
+        metrics.orchestrations.success_rate = Math.round((metrics.orchestrations.complete / metrics.orchestrations.total) * 1000) / 10;
+        // Top stop reasons
+        metrics.orchestrations.top_stop_reasons = getTopStopReasons(orchByStopReason);
+    }
+    // Duration percentiles for orchestrations
+    if (orchDurations.length > 0) {
+        orchDurations.sort((a, b) => a - b);
+        metrics.orchestrations.durations_ms = computePercentiles(orchDurations);
+    }
+    // Collision stats
+    metrics.collisions.total = totalCollisions;
+    metrics.collisions.by_stage = collisionsByStage;
+    return metrics;
+}
+/**
+ * Format duration in human-readable form.
+ */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${Math.round(ms / 1000)}s`;
+    return `${Math.round(ms / 60000)}m`;
+}
+/**
+ * Format metrics for human-readable output.
+ */
+function formatMetrics(metrics) {
+    const lines = [];
+    lines.push('='.repeat(60));
+    lines.push('METRICS SUMMARY');
+    lines.push('='.repeat(60));
+    lines.push('');
+    lines.push(`Agent: v${metrics.agent_version} (schema v${metrics.schema_version})`);
+    lines.push(`Repo: ${metrics.repo_root}`);
+    lines.push('');
+    lines.push(`Period: ${metrics.period.days} days`);
+    if (metrics.period.window) {
+        lines.push(`Window: ${metrics.period.window} runs`);
+    }
+    lines.push(`From: ${metrics.period.from ?? 'N/A'}`);
+    lines.push(`To: ${metrics.period.to}`);
+    lines.push(`Runs considered: ${metrics.period.runs_considered} (${metrics.period.runs_filtered_out} filtered out)`);
+    lines.push('');
+    lines.push('RUNS');
+    lines.push('-'.repeat(30));
+    lines.push(`Total: ${metrics.runs.total}`);
+    lines.push(`Complete: ${metrics.runs.complete}`);
+    lines.push(`Stopped: ${metrics.runs.stopped}`);
+    lines.push(`Running: ${metrics.runs.running}`);
+    lines.push(`Success rate: ${metrics.runs.success_rate}%`);
+    if (metrics.runs.avg_duration_ms !== null) {
+        lines.push(`Avg duration: ${formatDuration(metrics.runs.avg_duration_ms)}`);
+    }
+    if (metrics.runs.durations_ms.p50 !== null) {
+        lines.push(`Duration p50/p90/max: ${formatDuration(metrics.runs.durations_ms.p50)}/${formatDuration(metrics.runs.durations_ms.p90)}/${formatDuration(metrics.runs.durations_ms.max)}`);
+    }
+    lines.push('');
+    if (metrics.runs.top_stop_reasons.length > 0) {
+        lines.push('Top stop reasons:');
+        for (const { reason, count } of metrics.runs.top_stop_reasons) {
+            lines.push(`  ${reason}: ${count}`);
+        }
+        lines.push('');
+    }
+    lines.push('ORCHESTRATIONS');
+    lines.push('-'.repeat(30));
+    lines.push(`Total: ${metrics.orchestrations.total}`);
+    lines.push(`Complete: ${metrics.orchestrations.complete}`);
+    lines.push(`Stopped: ${metrics.orchestrations.stopped}`);
+    lines.push(`Failed: ${metrics.orchestrations.failed}`);
+    lines.push(`Running: ${metrics.orchestrations.running}`);
+    lines.push(`Success rate: ${metrics.orchestrations.success_rate}%`);
+    if (metrics.orchestrations.durations_ms.p50 !== null) {
+        lines.push(`Duration p50/p90/max: ${formatDuration(metrics.orchestrations.durations_ms.p50)}/${formatDuration(metrics.orchestrations.durations_ms.p90)}/${formatDuration(metrics.orchestrations.durations_ms.max)}`);
+    }
+    lines.push('');
+    if (Object.keys(metrics.orchestrations.by_collision_policy).length > 0) {
+        lines.push('By collision policy:');
+        for (const [policy, count] of Object.entries(metrics.orchestrations.by_collision_policy)) {
+            lines.push(`  ${policy}: ${count}`);
+        }
+        lines.push('');
+    }
+    if (metrics.collisions.total > 0) {
+        lines.push('COLLISIONS');
+        lines.push('-'.repeat(30));
+        lines.push(`Total: ${metrics.collisions.total}`);
+        for (const [stage, count] of Object.entries(metrics.collisions.by_stage)) {
+            lines.push(`  ${stage}: ${count}`);
+        }
+        lines.push('');
+    }
+    lines.push('MILESTONES');
+    lines.push('-'.repeat(30));
+    lines.push(`Total completed: ${metrics.milestones.total_completed}`);
+    lines.push(`Avg per run: ${metrics.milestones.avg_per_run}`);
+    lines.push('');
+    if (metrics.auto_resume.total_attempts > 0) {
+        lines.push('AUTO-RESUME');
+        lines.push('-'.repeat(30));
+        lines.push(`Total attempts: ${metrics.auto_resume.total_attempts}`);
+        lines.push(`Successful recoveries: ${metrics.auto_resume.successful_recoveries}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Run the metrics command.
+ */
+export async function metricsCommand(options) {
+    const repoPath = path.resolve(options.repo);
+    const days = options.days ?? 30;
+    const windowLimit = options.window;
+    const metrics = collectMetrics(repoPath, days, windowLimit);
+    if (options.json) {
+        console.log(JSON.stringify(metrics, null, 2));
+    }
+    else {
+        console.log(formatMetrics(metrics));
+    }
+}