@weldr/runr 0.3.0

package/dist/commands/paths.js

@@ -0,0 +1,31 @@
+/**
+ * runr paths command - Display canonical runr directory paths.
+ *
+ * Single source of truth for all runr paths. Use this in scripts,
+ * CI, and external tools instead of hardcoding paths.
+ */
+import { getRunrPaths } from '../store/runs-root.js';
+/**
+ * Execute the paths command.
+ */
+export async function pathsCommand(options) {
+    const paths = getRunrPaths(options.repo);
+    if (options.json) {
+        console.log(JSON.stringify(paths, null, 2));
+    }
+    else {
+        console.log('Runr Paths');
+        console.log('==========');
+        console.log('');
+        console.log(`repo_root:          ${paths.repo_root}`);
+        console.log(`runr_root:          ${paths.runr_root}`);
+        console.log(`runs_dir:           ${paths.runs_dir}`);
+        console.log(`worktrees_dir:      ${paths.worktrees_dir}`);
+        console.log(`orchestrations_dir: ${paths.orchestrations_dir}`);
+        if (paths.using_legacy) {
+            console.log('');
+            console.log('\x1b[33m⚠ Using legacy .agent/ directory. Consider migrating to .runr/\x1b[0m');
+        }
+    }
+    process.exitCode = 0;
+}

package/dist/commands/preflight.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execa } from 'execa';
+import { buildRepoContext } from '../repo/context.js';
+import { checkLockfiles, checkScope, partitionChangedFiles } from '../supervisor/scope-guard.js';
+import { selectTiersWithReasons } from '../supervisor/verification-policy.js';
+import { pingClaude } from '../workers/claude.js';
+import { pingCodex } from '../workers/codex.js';
+/**
+ * Check worker binary exists and can report version.
+ * This is cheaper than ping (no API call).
+ */
+async function checkWorkerBinary(name, worker) {
+    try {
+        const result = await execa(worker.bin, ['--version'], {
+            timeout: 5000,
+            reject: false
+        });
+        if (result.exitCode === 0) {
+            const version = result.stdout.trim().split('\n')[0];
+            return { worker: name, bin: worker.bin, ok: true, version };
+        }
+        return {
+            worker: name,
+            bin: worker.bin,
+            ok: false,
+            error: result.stderr || 'Version check failed'
+        };
+    }
+    catch (err) {
+        const error = err;
+        return {
+            worker: name,
+            bin: worker.bin,
+            ok: false,
+            error: error.message.includes('ENOENT')
+                ? `Command not found: ${worker.bin}`
+                : error.message
+        };
+    }
+}
+export async function runPreflight(options) {
+    const repoContext = await buildRepoContext(options.repoPath, options.runId, options.slug, options.config.repo.default_branch ?? 'main');
+    // Partition changed files into env artifacts vs semantic changes
+    // Env artifacts (node_modules, .next, .agent, etc.) are allowed noise
+    // Built-in patterns ensure agent artifacts never trigger guard failures
+    const builtinEnvAllowlist = ['.agent/**', '.agent-worktrees/**'];
+    const effectiveEnvAllowlist = Array.from(new Set([...(options.config.scope.env_allowlist ?? []), ...builtinEnvAllowlist]));
+    const { env_touched, semantic_changed } = partitionChangedFiles(repoContext.changed_files, effectiveEnvAllowlist);
+    const dirty_files = repoContext.changed_files;
+    const dirty_is_env_only = dirty_files.length > 0 && semantic_changed.length === 0;
+    // "Dirty" means semantic dirty, not env noise
+    const dirty = semantic_changed.length > 0;
+    // Scope/lockfile checks should only consider semantic changes
+    const scopeCheck = checkScope(semantic_changed, options.config.scope.allowlist, options.config.scope.denylist);
+    const lockfileCheck = checkLockfiles(semantic_changed, options.config.scope.lockfiles, options.allowDeps);
+    const reasons = [];
+    if (dirty && !options.allowDirty) {
+        reasons.push('dirty_worktree');
+    }
+    if (!scopeCheck.ok) {
+        reasons.push('scope_violation');
+    }
+    if (!lockfileCheck.ok) {
+        reasons.push('lockfile_violation');
+    }
+    // Check verification.cwd exists if specified
+    if (options.config.verification.cwd) {
+        const verifyCwd = path.join(options.repoPath, options.config.verification.cwd);
+        if (!fs.existsSync(verifyCwd)) {
+            reasons.push(`verification_cwd_missing:${options.config.verification.cwd}`);
+        }
+    }
+    // Check worker binaries exist (cheaper than ping, catches "command not found")
+    const workers = options.config.workers;
+    const binaryCheckPromises = [];
+    if (workers.claude) {
+        binaryCheckPromises.push(checkWorkerBinary('claude', workers.claude));
+    }
+    if (workers.codex) {
+        binaryCheckPromises.push(checkWorkerBinary('codex', workers.codex));
+    }
+    const binaryResults = await Promise.all(binaryCheckPromises);
+    // Add binary failures to reasons
+    for (const result of binaryResults) {
+        if (!result.ok) {
+            reasons.push(`binary_missing:${result.worker}:${result.error}`);
+        }
+    }
+    const binaryStatus = {
+        ok: binaryResults.every(r => r.ok),
+        results: binaryResults
+    };
+    // Ping workers to verify auth/connectivity (after binary checks)
+    // Skip ping if binaries failed (no point pinging missing binaries)
+    let pingStatus;
+    if (options.skipPing || !binaryStatus.ok) {
+        pingStatus = {
+            ok: true,
+            skipped: true,
+            results: []
+        };
+    }
+    else {
+        const pingResults = [];
+        // Ping all configured workers in parallel
+        const pingPromises = [];
+        if (workers.claude) {
+            pingPromises.push(pingClaude(workers.claude));
+        }
+        if (workers.codex) {
+            pingPromises.push(pingCodex(workers.codex));
+        }
+        const results = await Promise.all(pingPromises);
+        pingResults.push(...results);
+        // Add failures to reasons
+        for (const result of pingResults) {
+            if (!result.ok) {
+                const category = result.category || 'unknown';
+                reasons.push(`ping_failed:${result.worker}:${category}`);
+            }
+        }
+        pingStatus = {
+            ok: pingResults.every(r => r.ok),
+            skipped: false,
+            results: pingResults
+        };
+    }
+    const selection = selectTiersWithReasons(options.config.verification, {
+        changed_files: repoContext.changed_files,
+        risk_level: options.milestoneRiskLevel,
+        is_milestone_end: false,
+        is_run_end: false
+    });
+    return {
+        repo_context: repoContext,
+        guard: {
+            ok: reasons.length === 0,
+            reasons,
+            dirty,
+            scope_violations: scopeCheck.violations,
+            lockfile_violations: lockfileCheck.violations,
+            dirty_files,
+            env_touched,
+            dirty_is_env_only,
+        },
+        binary: binaryStatus,
+        ping: pingStatus,
+        tiers: selection.tiers,
+        tier_reasons: selection.reasons
+    };
+}

package/dist/commands/report.js

@@ -0,0 +1,478 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { readContextPackArtifact, formatContextPackStatus } from '../context/index.js';
+import { findLatestRunId } from '../store/run-utils.js';
+import { getRunsRoot } from '../store/runs-root.js';
+// Re-export for backward compatibility with cli.ts
+export { findLatestRunId };
+export async function reportCommand(options) {
+    const runDir = path.join(getRunsRoot(options.repo), options.runId);
+    if (!fs.existsSync(runDir)) {
+        throw new Error(`${missingRunMessage(runDir)}`);
+    }
+    const statePath = path.join(runDir, 'state.json');
+    if (!fs.existsSync(statePath)) {
+        throw new Error(`State not found: ${statePath}`);
+    }
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+    const timelinePath = path.join(runDir, 'timeline.jsonl');
+    const defaultKpi = {
+        version: 1,
+        total_duration_ms: null,
+        unattributed_ms: null,
+        started_at: null,
+        ended_at: null,
+        phases: {},
+        workers: { claude: 'unknown', codex: 'unknown' },
+        verify: { attempts: 0, retries: 0, total_duration_ms: 0 },
+        milestones: { completed: 0 },
+        reliability: {
+            infra_retries: 0,
+            fallback_used: false,
+            fallback_count: 0,
+            stalls_triggered: 0,
+            late_results_ignored: 0
+        },
+        outcome: 'unknown',
+        stop_reason: null
+    };
+    const scan = fs.existsSync(timelinePath)
+        ? await scanTimeline(timelinePath, options.tail)
+        : { tailEvents: [], kpi: defaultKpi };
+    const flags = readFlags(scan.runStarted);
+    const contextPackArtifact = readContextPackArtifact(runDir);
+    const header = [
+        'Run',
+        `run_id: ${options.runId}`,
+        `repo: ${state.repo_path}`,
+        `run_dir: ${runDir}`,
+        `current_phase: ${state.phase}`,
+        `milestone_index: ${state.milestone_index}`,
+        `phase_attempt: ${state.phase_attempt ?? 0}`,
+        `last_error: ${state.last_error ?? 'none'}`,
+        `dry_run: ${flags.dry_run ?? 'unknown'}`,
+        `no_branch: ${flags.no_branch ?? 'unknown'}`,
+        `allow_dirty: ${flags.allow_dirty ?? 'unknown'}`,
+        `allow_deps: ${flags.allow_deps ?? 'unknown'}`
+    ].join('\n');
+    const kpiBlock = formatKpiBlock(scan.kpi, contextPackArtifact);
+    if (options.kpiOnly) {
+        // Compact output: just run_id and KPIs
+        console.log(`${options.runId}: ${scan.kpi.outcome} ${formatDuration(scan.kpi.total_duration_ms)} milestones=${scan.kpi.milestones.completed}`);
+        return;
+    }
+    const events = formatEvents(scan.tailEvents);
+    const pointers = formatPointers({
+        statePath,
+        timelinePath,
+        runDir,
+        checkpoint: state.checkpoint_commit_sha
+    });
+    console.log([header, '', 'KPIs', kpiBlock, '', 'Last events', events, '', 'Pointers', pointers].join('\n'));
+}
+function formatDuration(ms) {
+    if (ms === null)
+        return 'unknown';
+    if (ms < 0)
+        return `-${formatPositiveDuration(Math.abs(ms))}`;
+    return formatPositiveDuration(ms);
+}
+function formatPositiveDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return remainingSeconds > 0 ? `${minutes}m${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h${remainingMinutes}m` : `${hours}h`;
+}
+function missingRunMessage(runDir) {
+    const runsRoot = path.dirname(runDir);
+    if (!fs.existsSync(runsRoot)) {
+        return `Run not found: ${runDir}. Known runs: none.`;
+    }
+    const candidates = fs
+        .readdirSync(runsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort()
+        .reverse()
+        .slice(0, 5);
+    const hint = candidates.length ? candidates.join(', ') : 'none';
+    return `Run not found: ${runDir}. Known runs: ${hint}.`;
+}
+function readFlags(runStarted) {
+    if (!runStarted?.payload || typeof runStarted.payload !== 'object') {
+        return {};
+    }
+    const payload = runStarted.payload;
+    return {
+        dry_run: payload.dry_run,
+        no_branch: payload.no_branch,
+        allow_dirty: payload.allow_dirty,
+        allow_deps: payload.allow_deps
+    };
+}
+function formatKpiBlock(kpi, contextPackArtifact) {
+    const lines = [];
+    // Total duration + unattributed
+    const durationStr = kpi.total_duration_ms !== null ? formatDuration(kpi.total_duration_ms) : 'unknown';
+    let unattributedStr;
+    if (kpi.unattributed_ms === null) {
+        unattributedStr = 'unknown';
+    }
+    else if (kpi.unattributed_ms < 0) {
+        // Negative = phases exceed tracked time (e.g., resumed runs with gaps)
+        unattributedStr = `-${formatPositiveDuration(Math.abs(kpi.unattributed_ms))} (resume/gap)`;
+    }
+    else {
+        unattributedStr = formatPositiveDuration(kpi.unattributed_ms);
+    }
+    lines.push(`total_duration: ${durationStr} (unattributed: ${unattributedStr})`);
+    // Outcome
+    const outcomeStr = kpi.stop_reason
+        ? `${kpi.outcome} (${kpi.stop_reason})`
+        : kpi.outcome;
+    lines.push(`outcome: ${outcomeStr}`);
+    // Milestones
+    lines.push(`milestones_completed: ${kpi.milestones.completed}`);
+    // Worker calls
+    const claudeCalls = kpi.workers.claude;
+    const codexCalls = kpi.workers.codex;
+    lines.push(`worker_calls: claude=${claudeCalls} codex=${codexCalls}`);
+    // Phase durations (sorted by typical order: plan, implement, review, verify)
+    const phaseOrder = ['plan', 'implement', 'review', 'verify'];
+    const phaseEntries = Object.entries(kpi.phases);
+    if (phaseEntries.length > 0) {
+        const sortedPhases = phaseEntries.sort(([a], [b]) => {
+            const aIdx = phaseOrder.indexOf(a);
+            const bIdx = phaseOrder.indexOf(b);
+            if (aIdx === -1 && bIdx === -1)
+                return a.localeCompare(b);
+            if (aIdx === -1)
+                return 1;
+            if (bIdx === -1)
+                return -1;
+            return aIdx - bIdx;
+        });
+        const phaseParts = sortedPhases.map(([phase, data]) => `${phase}=${formatDuration(data.duration_ms)}(x${data.count})`);
+        lines.push(`phases: ${phaseParts.join(' ')}`);
+    }
+    else {
+        lines.push('phases: (no phase data)');
+    }
+    // Verification stats
+    if (kpi.verify.attempts > 0) {
+        const verifyDur = formatDuration(kpi.verify.total_duration_ms);
+        lines.push(`verify: attempts=${kpi.verify.attempts} retries=${kpi.verify.retries} duration=${verifyDur}`);
+    }
+    else {
+        lines.push('verify: (no verification data)');
+    }
+    // Reliability metrics
+    const rel = kpi.reliability;
+    const relParts = [];
+    if (rel.infra_retries > 0)
+        relParts.push(`retries=${rel.infra_retries}`);
+    if (rel.fallback_used)
+        relParts.push(`fallback=${rel.fallback_count}`);
+    if (rel.stalls_triggered > 0)
+        relParts.push(`stalls=${rel.stalls_triggered}`);
+    if (rel.late_results_ignored > 0)
+        relParts.push(`late_ignored=${rel.late_results_ignored}`);
+    lines.push(`reliability: ${relParts.length ? relParts.join(' ') : 'clean'}`);
+    // Context pack status
+    lines.push(formatContextPackStatus(contextPackArtifact ?? null));
+    return lines.join('\n');
+}
+// Exported for testing - computes KPIs from an array of timeline events
+export function computeKpiFromEvents(events) {
+    let startedAt = null;
+    let endedAt = null;
+    const phases = {};
+    let currentPhase = null;
+    let currentPhaseStart = null;
+    let workersClaude = 'unknown';
+    let workersCodex = 'unknown';
+    let verifyAttempts = 0;
+    let verifyRetries = 0;
+    let verifyDurationMs = 0;
+    let milestonesCompleted = 0;
+    let outcome = 'unknown';
+    let stopReason = null;
+    // Reliability metrics
+    let infraRetries = 0;
+    let fallbackCount = 0;
+    let stallsTriggered = 0;
+    let lateResultsIgnored = 0;
+    for (const event of events) {
+        const eventType = event.type;
+        const timestamp = event.timestamp;
+        const payload = event.payload && typeof event.payload === 'object'
+            ? event.payload
+            : {};
+        // Track run_started
+        if (eventType === 'run_started' && startedAt === null) {
+            startedAt = timestamp ?? null;
+            outcome = 'running';
+        }
+        // Track phase_start events for phase durations
+        if (eventType === 'phase_start' && payload.phase) {
+            // Close previous phase if any
+            if (currentPhase && currentPhaseStart !== null && timestamp) {
+                const phaseEnd = new Date(timestamp).getTime();
+                const phaseDuration = phaseEnd - currentPhaseStart;
+                if (!phases[currentPhase]) {
+                    phases[currentPhase] = { duration_ms: 0, count: 0 };
+                }
+                phases[currentPhase].duration_ms += phaseDuration;
+            }
+            // Start new phase
+            currentPhase = payload.phase;
+            currentPhaseStart = timestamp ? new Date(timestamp).getTime() : null;
+            if (!phases[currentPhase]) {
+                phases[currentPhase] = { duration_ms: 0, count: 0 };
+            }
+            phases[currentPhase].count += 1;
+        }
+        // Track worker_stats event (emitted at finalize)
+        if (eventType === 'worker_stats' && payload.stats) {
+            const stats = payload.stats;
+            if (typeof stats.claude === 'number') {
+                workersClaude = stats.claude;
+            }
+            if (typeof stats.codex === 'number') {
+                workersCodex = stats.codex;
+            }
+        }
+        // Track verification events
+        if (eventType === 'verification') {
+            verifyAttempts += 1;
+            if (payload.duration_ms && typeof payload.duration_ms === 'number') {
+                verifyDurationMs += payload.duration_ms;
+            }
+        }
+        // Track verify retries (retry_count in verification payload)
+        if (eventType === 'verification' && typeof payload.retry === 'number') {
+            verifyRetries += payload.retry;
+        }
+        // Track milestone completion
+        if (eventType === 'milestone_complete') {
+            milestonesCompleted += 1;
+        }
+        // Track stop event
+        if (eventType === 'stop') {
+            endedAt = timestamp ?? null;
+            outcome = 'stopped';
+            stopReason = payload.reason ?? null;
+            // Close current phase
+            if (currentPhase && currentPhaseStart !== null && timestamp) {
+                const phaseEnd = new Date(timestamp).getTime();
+                const phaseDuration = phaseEnd - currentPhaseStart;
+                if (!phases[currentPhase]) {
+                    phases[currentPhase] = { duration_ms: 0, count: 0 };
+                }
+                phases[currentPhase].duration_ms += phaseDuration;
+            }
+        }
+        // Track run_complete event
+        if (eventType === 'run_complete') {
+            endedAt = timestamp ?? null;
+            outcome = 'complete';
+            // Close current phase
+            if (currentPhase && currentPhaseStart !== null && timestamp) {
+                const phaseEnd = new Date(timestamp).getTime();
+                const phaseDuration = phaseEnd - currentPhaseStart;
+                if (!phases[currentPhase]) {
+                    phases[currentPhase] = { duration_ms: 0, count: 0 };
+                }
+                phases[currentPhase].duration_ms += phaseDuration;
+            }
+        }
+        // Track reliability metrics
+        if (eventType === 'parse_failed') {
+            const retryCount = payload.retry_count ?? 0;
+            infraRetries += retryCount;
+        }
+        if (eventType === 'worker_fallback') {
+            fallbackCount += 1;
+        }
+        if (eventType === 'stop' && payload.reason === 'stalled_timeout') {
+            stallsTriggered += 1;
+        }
+        if (eventType === 'late_worker_result_ignored') {
+            lateResultsIgnored += 1;
+        }
+    }
+    // Compute total duration
+    let totalDurationMs = null;
+    if (startedAt && endedAt) {
+        totalDurationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+    }
+    // Compute unattributed time (total - sum of phase durations)
+    let unattributedMs = null;
+    if (totalDurationMs !== null) {
+        const attributedMs = Object.values(phases).reduce((sum, p) => sum + p.duration_ms, 0);
+        unattributedMs = totalDurationMs - attributedMs;
+    }
+    return {
+        version: 1,
+        total_duration_ms: totalDurationMs,
+        unattributed_ms: unattributedMs,
+        started_at: startedAt,
+        ended_at: endedAt,
+        phases,
+        workers: {
+            claude: workersClaude,
+            codex: workersCodex
+        },
+        verify: {
+            attempts: verifyAttempts,
+            retries: verifyRetries,
+            total_duration_ms: verifyDurationMs
+        },
+        milestones: {
+            completed: milestonesCompleted
+        },
+        reliability: {
+            infra_retries: infraRetries,
+            fallback_used: fallbackCount > 0,
+            fallback_count: fallbackCount,
+            stalls_triggered: stallsTriggered,
+            late_results_ignored: lateResultsIgnored
+        },
+        outcome,
+        stop_reason: stopReason
+    };
+}
+async function scanTimeline(timelinePath, tailCount) {
+    const allEvents = [];
+    const tailEvents = [];
+    let runStarted;
+    const stream = fs.createReadStream(timelinePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            const event = JSON.parse(trimmed);
+            allEvents.push(event);
+            if (!runStarted && event.type === 'run_started') {
+                runStarted = event;
+            }
+            tailEvents.push(event);
+            if (tailEvents.length > tailCount) {
+                tailEvents.shift();
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    const kpi = computeKpiFromEvents(allEvents);
+    return { runStarted, tailEvents, kpi };
+}
+function formatEvents(events) {
+    if (events.length === 0) {
+        return '(no events)';
+    }
+    const lines = events.map((event) => {
+        const seq = event.seq ?? '?';
+        const ts = event.timestamp ?? '?';
+        const type = event.type ?? 'unknown';
+        const source = event.source ?? 'unknown';
+        const summary = summarizeEvent(event);
+        return `${seq} ${ts} ${type} ${source} ${summary}`.trim();
+    });
+    return lines.join('\n');
+}
+function summarizeEvent(event) {
+    const payload = event.payload && typeof event.payload === 'object'
+        ? event.payload
+        : {};
+    if (event.type === 'phase_start' && payload.phase) {
+        return `phase=${payload.phase}`;
+    }
+    if (event.type === 'verification' && payload.tier) {
+        return `tier=${payload.tier} ok=${payload.ok}`;
+    }
+    if (event.type === 'verify_complete' && Array.isArray(payload.results)) {
+        return `results=${payload.results.join('; ')}`;
+    }
+    if (event.type === 'guard_violation') {
+        if (payload.guard && typeof payload.guard === 'object') {
+            const guard = payload.guard;
+            const reasons = Array.isArray(guard.reasons) ? guard.reasons.join(',') : '';
+            return `guard=${reasons || 'violation'}`;
+        }
+        return 'guard_violation';
+    }
+    if (event.type === 'stop' && payload.reason) {
+        return `reason=${payload.reason}`;
+    }
+    if (event.type === 'parse_failed') {
+        const context = payload.parser_context ?? 'unknown';
+        const retry = payload.retry_count ?? 0;
+        const snippet = payload.output_snippet ? clip(String(payload.output_snippet), 120) : '';
+        return `context=${context} retry=${retry} ${snippet ? `snippet="${snippet}"` : ''}`.trim();
+    }
+    if (event.type === 'run_started') {
+        const flags = [
+            `dry_run=${payload.dry_run}`,
+            `no_branch=${payload.no_branch}`,
+            `allow_dirty=${payload.allow_dirty}`,
+            `allow_deps=${payload.allow_deps}`
+        ].join(' ');
+        return flags;
+    }
+    if (event.type === 'run_resumed') {
+        return `max_ticks=${payload.max_ticks ?? '?'} time=${payload.time ?? '?'}`;
+    }
+    const keys = Object.keys(payload);
+    if (keys.length) {
+        return `keys=${keys.slice(0, 4).join(',')}`;
+    }
+    return '';
+}
+function formatPointers(input) {
+    const artifactsDir = path.join(input.runDir, 'artifacts');
+    const lastVerifyLog = findLatestVerifyLog(artifactsDir);
+    const lines = [
+        `state: ${input.statePath}`,
+        `timeline: ${input.timelinePath}`,
+        `last_verification_log: ${lastVerifyLog ?? 'none'}`,
+        `checkpoint_sha: ${input.checkpoint ?? 'none'}`
+    ];
+    return lines.join('\n');
+}
+function findLatestVerifyLog(artifactsDir) {
+    if (!fs.existsSync(artifactsDir)) {
+        return null;
+    }
+    const logs = fs
+        .readdirSync(artifactsDir)
+        .filter((file) => file.startsWith('tests_') && file.endsWith('.log'))
+        .map((file) => path.join(artifactsDir, file));
+    if (logs.length === 0) {
+        return null;
+    }
+    const withTimes = logs
+        .map((file) => ({ file, mtime: fs.statSync(file).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+    return withTimes[0]?.file ?? null;
+}
+function clip(value, max) {
+    if (value.length <= max) {
+        return value;
+    }
+    return `${value.slice(0, max)}...`;
+}