@runloop/rl-cli 1.7.1 → 1.9.0

package/dist/screens/BenchmarkJobDetailScreen.js

@@ -0,0 +1,614 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * BenchmarkJobDetailScreen - Detail page for benchmark jobs
+ * Uses the generic ResourceDetailPage component
+ */
+import React from "react";
+import { Text } from "ink";
+import figures from "figures";
+import { useNavigation } from "../store/navigationStore.js";
+import { useBenchmarkJobStore, } from "../store/benchmarkJobStore.js";
+import { ResourceDetailPage, formatTimestamp, } from "../components/ResourceDetailPage.js";
+import { getBenchmarkJob } from "../services/benchmarkJobService.js";
+import { getBenchmarkRun } from "../services/benchmarkService.js";
+import { SpinnerComponent } from "../components/Spinner.js";
+import { ErrorMessage } from "../components/ErrorMessage.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+import { colors } from "../utils/theme.js";
+export function BenchmarkJobDetailScreen({ benchmarkJobId, }) {
+    const { goBack, navigate } = useNavigation();
+    const benchmarkJobs = useBenchmarkJobStore((state) => state.benchmarkJobs);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [fetchedJob, setFetchedJob] = React.useState(null);
+    const [runNames, setRunNames] = React.useState(new Map());
+    // Find job in store first
+    const jobFromStore = benchmarkJobs.find((j) => j.id === benchmarkJobId);
+    // Polling function
+    const pollJob = React.useCallback(async () => {
+        if (!benchmarkJobId)
+            return null;
+        return getBenchmarkJob(benchmarkJobId);
+    }, [benchmarkJobId]);
+    // Fetch job from API if not in store
+    React.useEffect(() => {
+        if (benchmarkJobId && !loading && !fetchedJob) {
+            setLoading(true);
+            setError(null);
+            getBenchmarkJob(benchmarkJobId)
+                .then((job) => {
+                setFetchedJob(job);
+                setLoading(false);
+            })
+                .catch((err) => {
+                setError(err);
+                setLoading(false);
+            });
+        }
+    }, [benchmarkJobId, loading, fetchedJob]);
+    // Use fetched job for full details, fall back to store for basic display
+    const job = fetchedJob || jobFromStore;
+    // Fetch run names when job is loaded
+    React.useEffect(() => {
+        if (!job)
+            return;
+        const runIds = [];
+        // Collect run IDs from outcomes
+        if (job.benchmark_outcomes) {
+            job.benchmark_outcomes.forEach((outcome) => {
+                runIds.push(outcome.benchmark_run_id);
+            });
+        }
+        // Collect run IDs from in-progress runs
+        if (job.in_progress_runs) {
+            job.in_progress_runs.forEach((run) => {
+                if (!runIds.includes(run.benchmark_run_id)) {
+                    runIds.push(run.benchmark_run_id);
+                }
+            });
+        }
+        // Fetch run details for each run ID
+        Promise.all(runIds.map(async (runId) => {
+            try {
+                const run = await getBenchmarkRun(runId);
+                return { id: runId, name: run.name || runId };
+            }
+            catch {
+                return { id: runId, name: runId };
+            }
+        })).then((results) => {
+            const namesMap = new Map();
+            results.forEach((result) => {
+                namesMap.set(result.id, result.name);
+            });
+            setRunNames(namesMap);
+        });
+    }, [job]);
+    // Show loading state
+    if (!job && benchmarkJobId && !error) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Home" },
+                        { label: "Benchmark Jobs" },
+                        { label: "Loading...", active: true },
+                    ] }), _jsx(SpinnerComponent, { message: "Loading benchmark job details..." })] }));
+    }
+    // Show error state
+    if (error && !job) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Home" },
+                        { label: "Benchmark Jobs" },
+                        { label: "Error", active: true },
+                    ] }), _jsx(ErrorMessage, { message: "Failed to load benchmark job details", error: error })] }));
+    }
+    // Show not found error
+    if (!job) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Home" },
+                        { label: "Benchmark Jobs" },
+                        { label: "Not Found", active: true },
+                    ] }), _jsx(ErrorMessage, { message: `Benchmark job ${benchmarkJobId || "unknown"} not found`, error: new Error("Benchmark job not found") })] }));
+    }
+    // Helper to format duration
+    const formatDuration = (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 `${minutes}m ${remainingSeconds}s`;
+        const hours = Math.floor(minutes / 60);
+        const remainingMinutes = minutes % 60;
+        return `${hours}h ${remainingMinutes}m`;
+    };
+    // Build detail sections
+    const detailSections = [];
+    // Basic details section
+    const basicFields = [];
+    if (job.create_time_ms) {
+        basicFields.push({
+            label: "Created",
+            value: formatTimestamp(job.create_time_ms),
+        });
+    }
+    // Calculate overall score if available
+    if (job.benchmark_outcomes && job.benchmark_outcomes.length > 0) {
+        const scores = job.benchmark_outcomes
+            .map((o) => o.average_score)
+            .filter((s) => s !== null && s !== undefined);
+        if (scores.length > 0) {
+            const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
+            basicFields.push({
+                label: "Overall Score",
+                value: (_jsx(Text, { color: colors.success, bold: true, children: avgScore.toFixed(2) })),
+            });
+        }
+    }
+    // Summary stats
+    if (job.benchmark_outcomes && job.benchmark_outcomes.length > 0) {
+        const totalCompleted = job.benchmark_outcomes.reduce((acc, o) => acc + o.n_completed, 0);
+        const totalFailed = job.benchmark_outcomes.reduce((acc, o) => acc + o.n_failed, 0);
+        const totalTimeout = job.benchmark_outcomes.reduce((acc, o) => acc + o.n_timeout, 0);
+        const total = totalCompleted + totalFailed + totalTimeout;
+        basicFields.push({
+            label: "Scenarios",
+            value: (_jsxs(Text, { children: [_jsxs(Text, { color: colors.success, children: [totalCompleted, " completed"] }), totalFailed > 0 && (_jsxs(Text, { color: colors.error, children: [" / ", totalFailed, " failed"] })), totalTimeout > 0 && (_jsxs(Text, { color: colors.warning, children: [" / ", totalTimeout, " timeout"] })), _jsxs(Text, { dimColor: true, children: [" (", total, " total)"] })] })),
+        });
+    }
+    if (job.failure_reason) {
+        basicFields.push({
+            label: "Failure Reason",
+            value: _jsx(Text, { color: colors.error, children: job.failure_reason }),
+        });
+    }
+    if (basicFields.length > 0) {
+        detailSections.push({
+            title: "Summary",
+            icon: figures.squareSmallFilled,
+            color: colors.warning,
+            fields: basicFields,
+        });
+    }
+    const agentRuns = [];
+    // First, add completed runs from benchmark_outcomes
+    if (job.benchmark_outcomes) {
+        job.benchmark_outcomes.forEach((outcome) => {
+            const total = outcome.n_completed + outcome.n_failed + outcome.n_timeout;
+            const status = outcome.n_failed > 0 || outcome.n_timeout > 0
+                ? outcome.n_completed === 0
+                    ? "failed"
+                    : "completed"
+                : "completed";
+            agentRuns.push({
+                agentName: outcome.agent_name,
+                modelName: outcome.model_name || undefined,
+                status,
+                benchmarkRunId: outcome.benchmark_run_id,
+                score: outcome.average_score ?? undefined,
+                nCompleted: outcome.n_completed,
+                nFailed: outcome.n_failed,
+                nTimeout: outcome.n_timeout,
+                duration: outcome.duration_ms ?? undefined,
+            });
+        });
+    }
+    // Add in-progress runs
+    if (job.in_progress_runs) {
+        job.in_progress_runs.forEach((run) => {
+            // Get agent name from agent_config if available
+            let agentName = "Unknown Agent";
+            if (run.agent_config && "name" in run.agent_config) {
+                agentName = run.agent_config.name;
+            }
+            agentRuns.push({
+                agentName,
+                status: "running",
+                benchmarkRunId: run.benchmark_run_id,
+                duration: run.duration_ms ?? undefined,
+                startTime: run.start_time_ms,
+            });
+        });
+    }
+    // Add pending agents from job_spec that don't have runs yet
+    if (job.job_spec?.agent_configs) {
+        const runningOrCompletedAgents = new Set(agentRuns.map((r) => r.agentName));
+        job.job_spec.agent_configs.forEach((agent) => {
+            if (!runningOrCompletedAgents.has(agent.name)) {
+                agentRuns.push({
+                    agentName: agent.name,
+                    modelName: agent.model_name || undefined,
+                    status: "pending",
+                });
+            }
+        });
+    }
+    // Benchmark Runs section - show all agent runs with their status
+    if (agentRuns.length > 0) {
+        const runsFields = agentRuns.map((run) => {
+            const parts = [];
+            // Status indicator
+            switch (run.status) {
+                case "pending":
+                    parts.push(_jsxs(Text, { color: colors.textDim, children: [figures.circleDotted, " Pending"] }, "status"));
+                    break;
+                case "running":
+                    parts.push(_jsxs(Text, { color: colors.info, children: [figures.play, " Running"] }, "status"));
+                    if (run.duration) {
+                        parts.push(_jsxs(Text, { dimColor: true, children: [" ", "(", formatDuration(run.duration), ")"] }, "dur"));
+                    }
+                    break;
+                case "completed":
+                    parts.push(_jsxs(Text, { color: colors.success, children: [figures.tick, " Completed"] }, "status"));
+                    if (run.score !== undefined) {
+                        parts.push(_jsxs(Text, { color: colors.success, bold: true, children: [" ", "Score: ", run.score.toFixed(2)] }, "score"));
+                    }
+                    break;
+                case "failed":
+                    parts.push(_jsxs(Text, { color: colors.error, children: [figures.cross, " Failed"] }, "status"));
+                    if (run.score !== undefined) {
+                        parts.push(_jsxs(Text, { dimColor: true, children: [" ", "Score: ", run.score.toFixed(2)] }, "score"));
+                    }
+                    break;
+                case "timeout":
+                    parts.push(_jsxs(Text, { color: colors.warning, children: [figures.warning, " Timeout"] }, "status"));
+                    break;
+            }
+            // Stats for completed/failed runs
+            if (run.nCompleted !== undefined) {
+                parts.push(_jsxs(Text, { dimColor: true, children: [" ", "(", run.nCompleted, "\u2713", run.nFailed ? ` ${run.nFailed}✗` : "", run.nTimeout ? ` ${run.nTimeout}⏱` : "", ")"] }, "stats"));
+            }
+            // Duration for completed runs
+            if (run.status !== "running" && run.duration) {
+                parts.push(_jsxs(Text, { dimColor: true, children: [" ", formatDuration(run.duration)] }, "dur"));
+            }
+            // Benchmark Run ID (clickable hint)
+            if (run.benchmarkRunId) {
+                parts.push(_jsxs(Text, { dimColor: true, children: ["\n", "  ", figures.arrowRight, " Run:", " ", _jsx(Text, { color: colors.idColor, children: run.benchmarkRunId })] }, "id"));
+            }
+            // Model name
+            if (run.modelName) {
+                parts.push(_jsxs(Text, { dimColor: true, children: [" ", "[", run.modelName, "]"] }, "model"));
+            }
+            return {
+                label: run.agentName,
+                value: _jsx(Text, { children: parts }),
+                ...(run.benchmarkRunId
+                    ? {
+                        action: {
+                            type: "navigate",
+                            screen: "benchmark-run-detail",
+                            params: { benchmarkRunId: run.benchmarkRunId },
+                            hint: "View Run",
+                        },
+                    }
+                    : {}),
+            };
+        });
+        const pendingCount = agentRuns.filter((r) => r.status === "pending").length;
+        const runningCount = agentRuns.filter((r) => r.status === "running").length;
+        const completedCount = agentRuns.filter((r) => r.status === "completed" || r.status === "failed").length;
+        let sectionTitle = `Benchmark Runs (${agentRuns.length} agents)`;
+        if (pendingCount > 0 || runningCount > 0) {
+            const statusParts = [];
+            if (completedCount > 0)
+                statusParts.push(`${completedCount} done`);
+            if (runningCount > 0)
+                statusParts.push(`${runningCount} running`);
+            if (pendingCount > 0)
+                statusParts.push(`${pendingCount} pending`);
+            sectionTitle = `Benchmark Runs - ${statusParts.join(", ")}`;
+        }
+        detailSections.push({
+            title: sectionTitle,
+            icon: figures.pointer,
+            color: colors.primary,
+            fields: runsFields,
+        });
+    }
+    // Job Configuration section (condensed)
+    if (job.job_spec) {
+        const spec = job.job_spec;
+        const specFields = [];
+        if (spec.scenario_ids && spec.scenario_ids.length > 0) {
+            specFields.push({
+                label: "Scenarios",
+                value: `${spec.scenario_ids.length} scenario(s)`,
+            });
+        }
+        if (spec.orchestrator_config) {
+            const orch = spec.orchestrator_config;
+            const orchParts = [];
+            if (orch.n_concurrent_trials)
+                orchParts.push(`${orch.n_concurrent_trials} concurrent`);
+            if (orch.n_attempts)
+                orchParts.push(`${orch.n_attempts} retries`);
+            if (orch.timeout_multiplier && orch.timeout_multiplier !== 1) {
+                orchParts.push(`${orch.timeout_multiplier}x timeout`);
+            }
+            if (orchParts.length > 0) {
+                specFields.push({
+                    label: "Orchestrator",
+                    value: orchParts.join(", "),
+                });
+            }
+        }
+        if (specFields.length > 0) {
+            detailSections.push({
+                title: "Job Configuration",
+                icon: figures.circleFilled,
+                color: colors.secondary,
+                fields: specFields,
+            });
+        }
+    }
+    // Job Source section
+    if (job.job_source) {
+        const source = job.job_source;
+        const sourceFields = [];
+        if ("type" in source) {
+            sourceFields.push({
+                label: "Source Type",
+                value: source.type,
+            });
+        }
+        if ("benchmark_id" in source && source.benchmark_id) {
+            sourceFields.push({
+                label: "Benchmark ID",
+                value: _jsx(Text, { color: colors.idColor, children: source.benchmark_id }),
+                action: {
+                    type: "navigate",
+                    screen: "benchmark-detail",
+                    params: { benchmarkId: source.benchmark_id },
+                    hint: "View Benchmark",
+                },
+            });
+        }
+        if (sourceFields.length > 0) {
+            detailSections.push({
+                title: "Job Source",
+                icon: figures.info,
+                color: colors.textDim,
+                fields: sourceFields,
+            });
+        }
+    }
+    // Collect benchmark run IDs for operations
+    const benchmarkRunIds = [];
+    if (job.benchmark_outcomes) {
+        job.benchmark_outcomes.forEach((outcome) => {
+            // Use fetched run name from state, fallback to run ID
+            const runName = runNames.get(outcome.benchmark_run_id) || outcome.benchmark_run_id;
+            benchmarkRunIds.push({
+                id: outcome.benchmark_run_id,
+                name: runName,
+            });
+        });
+    }
+    if (job.in_progress_runs) {
+        job.in_progress_runs.forEach((run) => {
+            // Avoid duplicates
+            if (!benchmarkRunIds.find((r) => r.id === run.benchmark_run_id)) {
+                // Use fetched run name from state, fallback to run ID
+                const runName = runNames.get(run.benchmark_run_id) || run.benchmark_run_id;
+                benchmarkRunIds.push({ id: run.benchmark_run_id, name: runName });
+            }
+        });
+    }
+    // Operations available for benchmark jobs
+    const operations = [];
+    // Add "View Run" operations for each benchmark run (limit to first 9 for shortcuts)
+    benchmarkRunIds.slice(0, 9).forEach((run, idx) => {
+        operations.push({
+            key: `view-run-${idx}`,
+            label: `View Run: ${run.name}`,
+            color: colors.info,
+            icon: figures.arrowRight,
+            shortcut: String(idx + 1),
+        });
+    });
+    // Always add clone job option
+    operations.push({
+        key: "clone-job",
+        label: "Clone Job",
+        color: colors.success,
+        icon: figures.play,
+        shortcut: "c",
+    });
+    // Handle operation selection
+    const handleOperation = async (operation, resource) => {
+        if (operation.startsWith("view-run-")) {
+            const idx = parseInt(operation.replace("view-run-", ""), 10);
+            if (benchmarkRunIds[idx]) {
+                navigate("benchmark-run-detail", {
+                    benchmarkRunId: benchmarkRunIds[idx].id,
+                });
+            }
+        }
+        else if (operation === "clone-job") {
+            // Pass job data for cloning
+            const cloneParams = {
+                cloneFromJobId: resource.id,
+                cloneJobName: resource.name,
+            };
+            // Determine source type and extract IDs
+            if (resource.job_spec) {
+                const spec = resource.job_spec;
+                // Check if it's a scenarios spec (has scenario_ids array)
+                if (spec.scenario_ids && Array.isArray(spec.scenario_ids)) {
+                    cloneParams.cloneSourceType = "scenarios";
+                    cloneParams.initialScenarioIds = spec.scenario_ids.join(",");
+                }
+                // Check if it's a benchmark spec (has benchmark_id)
+                else if (spec.benchmark_id) {
+                    cloneParams.cloneSourceType = "benchmark";
+                    cloneParams.initialBenchmarkIds = spec.benchmark_id;
+                }
+                // Fallback: check job_source
+                else if (resource.job_source) {
+                    const source = resource.job_source;
+                    if (source.scenario_ids && Array.isArray(source.scenario_ids)) {
+                        cloneParams.cloneSourceType = "scenarios";
+                        cloneParams.initialScenarioIds = source.scenario_ids.join(",");
+                    }
+                    else if (source.benchmark_id) {
+                        cloneParams.cloneSourceType = "benchmark";
+                        cloneParams.initialBenchmarkIds = source.benchmark_id;
+                    }
+                }
+            }
+            // Extract agent configs - both full configs and legacy fields
+            if (resource.job_spec?.agent_configs) {
+                const agentConfigs = resource.job_spec.agent_configs.map((a) => ({
+                    agentId: a.agent_id,
+                    name: a.name,
+                    modelName: a.model_name,
+                    timeoutSeconds: a.timeout_seconds,
+                    kwargs: a.kwargs,
+                    environmentVariables: a.agent_environment?.environment_variables,
+                    secrets: a.agent_environment?.secrets,
+                }));
+                cloneParams.cloneAgentConfigs = JSON.stringify(agentConfigs);
+                // Also extract legacy fields for form initialization
+                cloneParams.cloneAgentIds = resource.job_spec.agent_configs
+                    .map((a) => a.agent_id)
+                    .join(",");
+                cloneParams.cloneAgentNames = resource.job_spec.agent_configs
+                    .map((a) => a.name)
+                    .join(",");
+            }
+            // Extract orchestrator config
+            if (resource.job_spec?.orchestrator_config) {
+                const orch = resource.job_spec.orchestrator_config;
+                cloneParams.cloneOrchestratorConfig = JSON.stringify({
+                    nAttempts: orch.n_attempts,
+                    nConcurrentTrials: orch.n_concurrent_trials,
+                    quiet: orch.quiet,
+                    timeoutMultiplier: orch.timeout_multiplier,
+                });
+            }
+            navigate("benchmark-job-create", cloneParams);
+        }
+    };
+    // Build detailed info lines for full details view
+    const buildDetailLines = (j) => {
+        const lines = [];
+        // Core Information
+        lines.push(_jsx(Text, { color: colors.warning, bold: true, children: "Benchmark Job Details" }, "core-title"));
+        lines.push(_jsxs(Text, { color: colors.idColor, children: [" ", "ID: ", j.id] }, "core-id"));
+        lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Name: ", j.name || "(none)"] }, "core-name"));
+        lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Status: ", j.state] }, "core-status"));
+        if (j.create_time_ms) {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Created: ", new Date(j.create_time_ms).toLocaleString()] }, "core-created"));
+        }
+        if (j.failure_reason) {
+            lines.push(_jsxs(Text, { color: colors.error, children: [" ", "Failure: ", j.failure_reason] }, "core-failure"));
+        }
+        lines.push(_jsx(Text, { children: " " }, "core-space"));
+        // Benchmark Runs - unified view
+        lines.push(_jsx(Text, { color: colors.primary, bold: true, children: "Benchmark Runs" }, "runs-title"));
+        // Completed runs from benchmark_outcomes
+        if (j.benchmark_outcomes && j.benchmark_outcomes.length > 0) {
+            j.benchmark_outcomes.forEach((outcome, idx) => {
+                const scoreStr = outcome.average_score !== undefined && outcome.average_score !== null
+                    ? `Score: ${outcome.average_score.toFixed(2)}`
+                    : "No score";
+                const statsStr = `${outcome.n_completed}✓ ${outcome.n_failed}✗ ${outcome.n_timeout}⏱`;
+                const durationStr = outcome.duration_ms
+                    ? formatDuration(outcome.duration_ms)
+                    : "";
+                const statusIcon = outcome.n_failed > 0 ? figures.cross : figures.tick;
+                const statusColor = outcome.n_failed > 0 ? colors.error : colors.success;
+                lines.push(_jsxs(Text, { children: [" ", _jsx(Text, { color: statusColor, children: statusIcon }), _jsxs(Text, { color: colors.info, children: [" ", outcome.agent_name || `Agent ${idx + 1}`] }), _jsxs(Text, { dimColor: true, children: [": ", scoreStr, " (", statsStr, ") ", durationStr] })] }, `outcome-${idx}`));
+                lines.push(_jsxs(Text, { dimColor: true, children: ["   ", "Run ID: ", outcome.benchmark_run_id] }, `outcome-${idx}-id`));
+                // Show scenario outcomes
+                if (outcome.scenario_outcomes && outcome.scenario_outcomes.length > 0) {
+                    outcome.scenario_outcomes.forEach((scenario, sIdx) => {
+                        const scenarioScore = scenario.score !== undefined && scenario.score !== null
+                            ? scenario.score.toFixed(2)
+                            : "-";
+                        const scenarioDur = scenario.duration_ms
+                            ? formatDuration(scenario.duration_ms)
+                            : "";
+                        const scenarioIcon = scenario.state === "COMPLETED"
+                            ? figures.tick
+                            : scenario.state === "FAILED"
+                                ? figures.cross
+                                : figures.warning;
+                        const scenarioColor = scenario.state === "COMPLETED"
+                            ? colors.success
+                            : scenario.state === "FAILED"
+                                ? colors.error
+                                : colors.warning;
+                        lines.push(_jsxs(Text, { children: ["   ", _jsx(Text, { color: scenarioColor, children: scenarioIcon }), _jsxs(Text, { dimColor: true, children: [" ", scenario.scenario_name, ": ", scenario.state, " (score:", " ", scenarioScore, ") ", scenarioDur] })] }, `outcome-${idx}-scenario-${sIdx}`));
+                        if (scenario.failure_reason) {
+                            lines.push(_jsxs(Text, { color: colors.error, children: ["     ", scenario.failure_reason.exception_type, ":", " ", scenario.failure_reason.exception_message] }, `outcome-${idx}-scenario-${sIdx}-fail`));
+                        }
+                    });
+                }
+            });
+        }
+        // In-progress runs
+        if (j.in_progress_runs && j.in_progress_runs.length > 0) {
+            j.in_progress_runs.forEach((run, idx) => {
+                let agentName = "Unknown Agent";
+                if (run.agent_config && "name" in run.agent_config) {
+                    agentName = run.agent_config.name;
+                }
+                const durationStr = run.duration_ms
+                    ? formatDuration(run.duration_ms)
+                    : "";
+                lines.push(_jsxs(Text, { children: [" ", _jsx(Text, { color: colors.info, children: figures.play }), _jsxs(Text, { color: colors.info, children: [" ", agentName] }), _jsxs(Text, { dimColor: true, children: [": Running ", durationStr] })] }, `run-${idx}`));
+                lines.push(_jsxs(Text, { dimColor: true, children: ["   ", "Run ID: ", run.benchmark_run_id] }, `run-${idx}-id`));
+            });
+        }
+        // Pending agents
+        if (j.job_spec?.agent_configs) {
+            const runningOrCompletedAgents = new Set();
+            j.benchmark_outcomes?.forEach((o) => runningOrCompletedAgents.add(o.agent_name));
+            j.in_progress_runs?.forEach((r) => {
+                if (r.agent_config && "name" in r.agent_config) {
+                    runningOrCompletedAgents.add(r.agent_config.name);
+                }
+            });
+            j.job_spec.agent_configs.forEach((agent, idx) => {
+                if (!runningOrCompletedAgents.has(agent.name)) {
+                    lines.push(_jsxs(Text, { children: [" ", _jsx(Text, { color: colors.textDim, children: figures.circleDotted }), _jsxs(Text, { dimColor: true, children: [" ", agent.name, ": Pending"] })] }, `pending-${idx}`));
+                }
+            });
+        }
+        lines.push(_jsx(Text, { children: " " }, "runs-space"));
+        // Job Configuration
+        if (j.job_spec) {
+            lines.push(_jsx(Text, { color: colors.secondary, bold: true, children: "Job Configuration" }, "spec-title"));
+            if (j.job_spec.scenario_ids) {
+                lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Scenarios: ", j.job_spec.scenario_ids.length] }, "spec-scenarios"));
+            }
+            if (j.job_spec.orchestrator_config) {
+                const orch = j.job_spec.orchestrator_config;
+                const orchInfo = [];
+                if (orch.n_concurrent_trials)
+                    orchInfo.push(`${orch.n_concurrent_trials} concurrent`);
+                if (orch.n_attempts)
+                    orchInfo.push(`${orch.n_attempts} retries`);
+                if (orchInfo.length > 0) {
+                    lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Orchestrator: ", orchInfo.join(", ")] }, "spec-orch"));
+                }
+            }
+            lines.push(_jsx(Text, { children: " " }, "spec-space"));
+        }
+        // Raw JSON
+        lines.push(_jsx(Text, { color: colors.warning, bold: true, children: "Raw JSON" }, "json-title"));
+        const jsonLines = JSON.stringify(j, null, 2).split("\n");
+        jsonLines.forEach((line, idx) => {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", line] }, `json-${idx}`));
+        });
+        return lines;
+    };
+    // Check if job is still in progress for polling
+    const isRunning = job.state === "running" ||
+        job.state === "queued" ||
+        job.state === "initializing";
+    return (_jsx(ResourceDetailPage, { resource: job, resourceType: "Benchmark Jobs", getDisplayName: (j) => j.name || j.id, getId: (j) => j.id, getStatus: (j) => j.state, detailSections: detailSections, operations: operations, onOperation: handleOperation, onBack: goBack, buildDetailLines: buildDetailLines, pollResource: isRunning ? pollJob : undefined, breadcrumbPrefix: [{ label: "Home" }] }));
+}