acpus 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,2 +1,243 @@
-import { $ as ReduceStageSchema, A as renderStagePrompt, B as DecisionRuleSchema, C as collectWorkflowOutputCandidates, D as repairFailedEnvelope, E as isRepairableOutputFailure, F as ArtifactSchema, G as FindingSchema, H as FanoutLaneGroupSchema, I as BaseOutputSchema, J as ImplementationOutputSchema, K as GateOutputSchema, L as CheckSchema, M as topologicalOrder, N as EXECUTION_PLAN_VERSION, O as compileExecutionPlan, P as AgentTaskStageSchema, Q as LoopStageSchema, R as ConditionSchema, S as syncRun, T as formatRepairPrompt, U as FanoutLaneSchema, V as DiscoverStageSchema, W as FanoutStageSchema, X as InputTypeSchema, Y as InputDeclarationSchema, Z as LoopBodyStageSchema, _t as RUN_DIAGNOSTICS_VIEW_VERSION, a as previewRunView, at as StageLimitsSchema, b as issue, bt as readNdjsonTail, c as TASK_DETAIL_VIEW_VERSION, ct as TransformSchema, dt as WorkflowLimitsSchema, et as RoleCategorySchema, ft as WorkflowSpecSchema, g as lintWorkflowSpec, h as loadWorkflowSpec, ht as OutputContractNameSchema, i as estimateFanoutWork, it as SeverityCountsSchema, j as stageRoleName, k as renderPromptMap, l as buildRunMonitorView, lt as ValidationOutputSchema, mt as getOutputContract, n as startPreparedRun, nt as RoleSchema, o as runViewFromIndex, ot as StageSchema, pt as contractNameForStage, q as GateStageSchema, r as estimateAgentCalls, rt as SCHEMA_VERSION, s as RUN_MONITOR_VIEW_VERSION, st as SummarizeStageSchema, t as prepareRun, tt as RoleModeSchema, u as buildTaskDetailView, ut as VariableSchema, vt as RunDiagnosticCodes, w as parseWorkflowOutput, x as resultFromIssues, y as OrchestratorError, yt as buildRunDiagnosticsView, z as DecisionGateStageSchema } from "./run-workflow-CbxKhAqF.mjs";
-export { AgentTaskStageSchema, ArtifactSchema, BaseOutputSchema, CheckSchema, ConditionSchema, DecisionGateStageSchema, DecisionRuleSchema, DiscoverStageSchema, EXECUTION_PLAN_VERSION, FanoutLaneGroupSchema, FanoutLaneSchema, FanoutStageSchema, FindingSchema, GateOutputSchema, GateStageSchema, ImplementationOutputSchema, InputDeclarationSchema, InputTypeSchema, LoopBodyStageSchema, LoopStageSchema, OrchestratorError, OutputContractNameSchema, RUN_DIAGNOSTICS_VIEW_VERSION, RUN_MONITOR_VIEW_VERSION, ReduceStageSchema, RoleCategorySchema, RoleModeSchema, RoleSchema, RunDiagnosticCodes, SCHEMA_VERSION, SeverityCountsSchema, StageLimitsSchema, StageSchema, SummarizeStageSchema, TASK_DETAIL_VIEW_VERSION, TransformSchema, ValidationOutputSchema, VariableSchema, WorkflowLimitsSchema, WorkflowSpecSchema, buildRunDiagnosticsView, buildRunMonitorView, buildTaskDetailView, collectWorkflowOutputCandidates, compileExecutionPlan, contractNameForStage, estimateAgentCalls, estimateFanoutWork, formatRepairPrompt, getOutputContract, isRepairableOutputFailure, issue, lintWorkflowSpec, loadWorkflowSpec, parseWorkflowOutput, prepareRun, previewRunView, readNdjsonTail, renderPromptMap, renderStagePrompt, repairFailedEnvelope, resultFromIssues, runViewFromIndex, stageRoleName, startPreparedRun, syncRun, topologicalOrder };
+import { $ as ConditionSchema, B as retryCountByReason, C as RUN_MONITOR_VIEW_VERSION, Ct as TaskStageSchema, Dt as WorkflowLimitsSchema, E as buildTaskDetailView, Et as WorkflowInputSchema, F as parseWorkflowOutput, Ft as runDir, G as compileSchemaDsl, H as retryableOutputFailure, I as AGENT_TASK_RETRY_BUDGET, J as outputSchemaFooter, K as defaultAgentOutputZod, L as AGENT_TASK_RETRY_DELAY_MS, N as syncRun, Ot as WorkflowSpecSchema, P as collectWorkflowOutputCandidates, Q as AgentFaninSchema, R as agentTaskRetryDelayMs, S as resultFromIssues, St as TaskProgramStageSchema, T as buildRunMonitorView, Tt as VariableSchema, U as setAgentTaskRetryDelayForTests, V as retryExhaustedEnvelope, W as DEFAULT_AGENT_OUTPUT_SCHEMA, X as ActorModeSchema, Y as zodForCompiledSchema, Z as ActorSchema, _t as RouteStageSchema, a as renderStagePrompt, at as GateAgentStageSchema, b as OrchestratorError, bt as StageSchema, c as EXECUTION_PLAN_VERSION, ct as LimitBindingSchema, d as previewRunView, dt as LoopStageSchema, et as FaninSchema, f as runViewFromIndex, ft as PositiveIntegerLimitSchema, g as lintWorkflowSpec, gt as RouteRuleSchema, h as stringifyWorkflowSpec, ht as RouteProgramStageSchema, i as renderPromptMap, it as FanoutStageSchema, kt as RuntimeErrorCodes, l as estimateAgentCalls, lt as LimitValueSchema, m as loadWorkflowSpec, mt as RouteAgentStageSchema, n as startPreparedRun, nt as FanoutPolicySchema, o as stageActorLabel, ot as GateProgramStageSchema, p as isWorkflowYamlPath, pt as ProgramFaninSchema, q as formatSchema, r as compileExecutionPlan, rt as FanoutStageLimitsSchema, s as topologicalOrder, st as GateStageSchema, t as prepareRun, tt as FanoutLaneSchema, u as estimateFanoutWork, ut as LoopBodyStageSchema, vt as SCHEMA_VERSION, w as TASK_DETAIL_VIEW_VERSION, wt as TransformSchema, x as issue, xt as TaskAgentStageSchema, yt as StageLimitsSchema, z as formatContinuationPrompt } from "./run-workflow-DdIAC8Zu.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/projections/run-diagnostics.ts
+const RUN_DIAGNOSTICS_VIEW_VERSION = "acpus.diagnostics/v1";
+const RUN_LEVEL_RUNTIME_CODES = new Set([
+	RuntimeErrorCodes.EVENT_APPEND_LOCK_TIMEOUT,
+	RuntimeErrorCodes.RUN_INDEX_LOCK_TIMEOUT,
+	RuntimeErrorCodes.AGENT_TASK_RETRY_EXHAUSTED,
+	RuntimeErrorCodes.FANOUT_ITEM_UNSTARTED_TIMEOUT,
+	RuntimeErrorCodes.FANOUT_ITEM_BLOCKED,
+	RuntimeErrorCodes.FANOUT_ITEM_CASCADE_BLOCKED,
+	RuntimeErrorCodes.FANOUT_LANE_RESULT_MISMATCH,
+	RuntimeErrorCodes.NO_SELECTED_LANES,
+	RuntimeErrorCodes.MISSING_FANOUT_ITEM_OUTPUT,
+	RuntimeErrorCodes.FANOUT_STAGE_STUCK_PENDING_BATCH,
+	RuntimeErrorCodes.RUN_INDEX_OUTPUT_MISMATCH,
+	RuntimeErrorCodes.LOOP_EXHAUSTED,
+	RuntimeErrorCodes.LOOP_BODY_STAGE_BLOCKED,
+	RuntimeErrorCodes.LOOP_BODY_STAGE_FAILED,
+	RuntimeErrorCodes.LOOP_BODY_OUTPUT_MISSING,
+	RuntimeErrorCodes.VARIABLE_RESOLUTION_FAILED,
+	RuntimeErrorCodes.AGENT_RUNTIME_ERROR,
+	RuntimeErrorCodes.AGENT_TURN_FAILED,
+	RuntimeErrorCodes.AGENT_TURN_CANCELLED,
+	RuntimeErrorCodes.AGENT_STAGE_STALE_RECOVERY,
+	RuntimeErrorCodes.GATE_CONDITION_FAILED,
+	RuntimeErrorCodes.GATE_VERDICT_BLOCKED,
+	RuntimeErrorCodes.GATE_VERDICT_FAILED,
+	RuntimeErrorCodes.GATE_VERDICT_UNKNOWN
+]);
+const RunDiagnosticCodes = { SCHEDULER_RECOVERY_SUCCEEDED_WITH_BLOCKED_VERDICT: "SCHEDULER_RECOVERY_SUCCEEDED_WITH_BLOCKED_VERDICT" };
+const DEFAULT_EVENT_TAIL_LIMIT = 50;
+const DEFAULT_EVENT_TAIL_MAX_BYTES = 256 * 1024;
+async function buildRunDiagnosticsView(cwd, index, options = {}) {
+	const dir = runDir(index.logicalRunId, cwd);
+	const eventTail = await readEventTail(path.join(dir, "events.ndjson"), {
+		limit: options.eventTailLimit ?? DEFAULT_EVENT_TAIL_LIMIT,
+		maxBytes: options.eventTailMaxBytes ?? DEFAULT_EVENT_TAIL_MAX_BYTES
+	});
+	const diagnostics = [...await buildRuntimeDiagnostics(dir, index), ...buildEventTailDiagnostics(path.join(dir, "events.ndjson"), eventTail)];
+	return {
+		version: RUN_DIAGNOSTICS_VIEW_VERSION,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		run: {
+			logicalRunId: index.logicalRunId,
+			workflowName: index.workflowName,
+			status: index.status,
+			blockedReason: index.blockedReason,
+			gateVerdict: index.gateVerdict,
+			runDir: dir
+		},
+		diagnostics,
+		eventTail
+	};
+}
+async function readNdjsonTail(filePath, maxLines, maxBytes = DEFAULT_EVENT_TAIL_MAX_BYTES) {
+	if (maxLines <= 0 || maxBytes <= 0) return [];
+	let handle;
+	try {
+		const stat = await fs.stat(filePath);
+		if (stat.size === 0) return [];
+		const bytesToRead = Math.min(stat.size, maxBytes);
+		const start = stat.size - bytesToRead;
+		const buffer = Buffer.alloc(bytesToRead);
+		handle = await fs.open(filePath, "r");
+		await handle.read(buffer, 0, bytesToRead, start);
+		let lines = buffer.toString("utf8").split("\n");
+		if (start > 0) lines = lines.slice(1);
+		return lines.filter((line) => line.trim().length > 0).slice(-maxLines);
+	} catch {
+		return [];
+	} finally {
+		await handle?.close().catch(() => void 0);
+	}
+}
+async function readEventTail(filePath, options) {
+	return (await readNdjsonTail(filePath, options.limit, options.maxBytes)).map(parseEventLine).filter((event) => event !== void 0);
+}
+async function buildRuntimeDiagnostics(dir, index) {
+	const diagnostics = [];
+	if (index.blockedReason && isRunLevelRuntimeCode(index.blockedReason)) diagnostics.push(runtimeDiagnostic({
+		code: index.blockedReason,
+		path: path.join(dir, "run.json"),
+		summary: runLevelBlockedSummary(index),
+		source: "run_index"
+	}));
+	for (const stage of Object.values(index.stages)) {
+		if (!stage.fanout && (stage.blockedReason === RuntimeErrorCodes.AGENT_RUNTIME_ERROR || stage.blockedReason === RuntimeErrorCodes.AGENT_STAGE_STALE_RECOVERY || stage.blockedReason === RuntimeErrorCodes.AGENT_TASK_RETRY_EXHAUSTED)) {
+			const outputPath = stage.outputPath ? path.join(dir, stage.outputPath) : path.join(dir, "outputs", `${stage.stageId}.json`);
+			const code = stage.blockedReason;
+			diagnostics.push(runtimeDiagnostic({
+				code,
+				stageId: stage.stageId,
+				path: outputPath,
+				summary: stageRetryDiagnosticSummary(code),
+				source: "run_index"
+			}));
+		}
+		if (!stage.fanout) continue;
+		const hasRunningItems = stage.fanout.items.some((item) => item.status === "running");
+		const queuedItems = stage.fanout.items.filter((item) => item.status === "pending" || item.status === "ready");
+		if (stage.status === "running" && !hasRunningItems && queuedItems.length > 0) diagnostics.push(runtimeDiagnostic({
+			code: RuntimeErrorCodes.FANOUT_STAGE_STUCK_PENDING_BATCH,
+			stageId: stage.stageId,
+			path: path.join(dir, "run.json"),
+			summary: `Fanout stage ${stage.stageId} is running with no running items and ${queuedItems.length} queued item(s).`,
+			source: "run_index"
+		}));
+		for (const item of stage.fanout.items) {
+			const outputPath = item.outputPath ? path.join(dir, item.outputPath) : path.join(dir, "outputs", stage.stageId, `${safeFileName(item.id)}.json`);
+			if (item.status === "running" && await fileExists(outputPath)) diagnostics.push(runtimeDiagnostic({
+				code: RuntimeErrorCodes.RUN_INDEX_OUTPUT_MISMATCH,
+				stageId: stage.stageId,
+				itemId: item.id,
+				path: outputPath,
+				summary: `Fanout item ${stage.stageId}/${item.id} is running in run.json but has an output file.`,
+				source: "stage_output"
+			}));
+			if (item.errorCode) diagnostics.push(runtimeDiagnostic({
+				code: item.errorCode,
+				stageId: stage.stageId,
+				itemId: item.id,
+				path: outputPath,
+				summary: item.errorMessage ?? item.blockedReason ?? item.errorCode,
+				source: "run_index"
+			}));
+		}
+	}
+	const recoveryVerdictDiagnostic = buildRecoverySucceededWithBlockedVerdictDiagnostic(dir, index);
+	if (recoveryVerdictDiagnostic) diagnostics.push(recoveryVerdictDiagnostic);
+	return diagnostics;
+}
+function stageRetryDiagnosticSummary(code) {
+	if (code === RuntimeErrorCodes.AGENT_STAGE_STALE_RECOVERY) return "Agent task retry exhausted after scheduler stale recovery.";
+	if (code === RuntimeErrorCodes.AGENT_TASK_RETRY_EXHAUSTED) return "Agent task retry budget exhausted.";
+	return "Agent runtime failed after retry exhaustion.";
+}
+function buildEventTailDiagnostics(eventPath, eventTail) {
+	const diagnostics = [];
+	for (const event of eventTail) {
+		if (!(event.summary?.includes("Lock file is already being held") || event.errorCode === RuntimeErrorCodes.RUN_INDEX_LOCK_TIMEOUT || event.errorCode === RuntimeErrorCodes.EVENT_APPEND_LOCK_TIMEOUT)) continue;
+		diagnostics.push(runtimeDiagnostic({
+			code: event.errorCode ?? "LOCK_CONTENTION",
+			stageId: event.stageId,
+			itemId: event.itemId,
+			attemptId: event.attemptId,
+			path: eventPath,
+			summary: "Runtime lock contention was observed in recent events.",
+			source: "event_tail",
+			status: "blocked"
+		}));
+	}
+	return diagnostics;
+}
+function buildRecoverySucceededWithBlockedVerdictDiagnostic(dir, index) {
+	if (!isBlockedGateVerdictCode(index.blockedReason) || !index.gateVerdict) return void 0;
+	const recoveredFanoutStages = Object.values(index.stages).filter((stage) => {
+		if (!stage.fanout) return false;
+		if (stage.fanout.items.some((item) => item.status === "running" || item.status === "pending" || item.status === "ready")) return false;
+		return stage.fanout.items.some((item) => item.errorCode === RuntimeErrorCodes.AGENT_TASK_RETRY_EXHAUSTED || item.errorCode === RuntimeErrorCodes.FANOUT_ITEM_CASCADE_BLOCKED || item.errorCode === RuntimeErrorCodes.FANOUT_ITEM_UNSTARTED_TIMEOUT || item.errorCode === RuntimeErrorCodes.RUN_INDEX_OUTPUT_MISMATCH);
+	});
+	if (recoveredFanoutStages.length === 0) return void 0;
+	const stageIds = recoveredFanoutStages.map((stage) => stage.stageId);
+	return {
+		id: `runtime-${RunDiagnosticCodes.SCHEDULER_RECOVERY_SUCCEEDED_WITH_BLOCKED_VERDICT}-run-all`,
+		code: RunDiagnosticCodes.SCHEDULER_RECOVERY_SUCCEEDED_WITH_BLOCKED_VERDICT,
+		status: "completed",
+		summary: `Scheduler recovery completed for fanout stage(s) ${stageIds.join(", ")}, but workflow gate verdict remains ${index.gateVerdict}.`,
+		path: path.join(dir, "run.json"),
+		source: "run_index"
+	};
+}
+function runtimeDiagnostic(input) {
+	return {
+		id: `runtime-${input.code}-${input.stageId ?? "run"}-${input.itemId ?? input.attemptId ?? "all"}`,
+		code: input.code,
+		stageId: input.stageId,
+		itemId: input.itemId,
+		attemptId: input.attemptId,
+		status: input.status ?? "blocked",
+		summary: input.summary,
+		path: input.path,
+		source: input.source
+	};
+}
+function isRunLevelRuntimeCode(value) {
+	return RUN_LEVEL_RUNTIME_CODES.has(value);
+}
+function isBlockedGateVerdictCode(value) {
+	return value === RuntimeErrorCodes.GATE_VERDICT_BLOCKED || value === RuntimeErrorCodes.GATE_VERDICT_FAILED || value === RuntimeErrorCodes.GATE_VERDICT_UNKNOWN;
+}
+function runLevelBlockedSummary(index) {
+	if (index.blockedReason === RuntimeErrorCodes.AGENT_TASK_RETRY_EXHAUSTED) return "Agent Task Retry budget exhausted.";
+	if (index.blockedReason === RuntimeErrorCodes.AGENT_RUNTIME_ERROR) return "Agent runtime failed after Agent Task Retry budget exhaustion.";
+	if (index.blockedReason === RuntimeErrorCodes.AGENT_STAGE_STALE_RECOVERY) return "Agent stage stale recovery exhausted Agent Task Retry budget.";
+	if (index.blockedReason === RuntimeErrorCodes.FANOUT_ITEM_BLOCKED) return "Fanout stage blocked because one or more items did not complete.";
+	if (index.blockedReason === RuntimeErrorCodes.GATE_CONDITION_FAILED) return "Program gate condition failed.";
+	if (index.gateVerdict === "blocked") return "Gate returned verdict=blocked.";
+	if (index.gateVerdict === "failed") return "Gate returned verdict=failed.";
+	return "Gate returned verdict=unknown.";
+}
+function parseEventLine(line) {
+	const record = objectRecord(safeJson(line));
+	if (!record) return void 0;
+	const errorCode = stringField(record, "errorCode") ?? stringField(record, "code");
+	return {
+		at: stringField(record, "at"),
+		type: stringField(record, "type"),
+		stageId: stringField(record, "stageId"),
+		itemId: stringField(record, "itemId"),
+		attemptId: stringField(record, "attemptId"),
+		errorCode,
+		summary: stringField(record, "summary") ?? stringField(record, "error") ?? stringField(record, "errorMessage")
+	};
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function safeJson(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function objectRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function stringField(value, key) {
+	const field = value?.[key];
+	return typeof field === "string" ? field : void 0;
+}
+function safeFileName(value) {
+	return String(value || "item").replace(/[^A-Za-z0-9_.-]/g, "_");
+}
+//#endregion
+export { AGENT_TASK_RETRY_BUDGET, AGENT_TASK_RETRY_DELAY_MS, ActorModeSchema, ActorSchema, AgentFaninSchema, ConditionSchema, DEFAULT_AGENT_OUTPUT_SCHEMA, EXECUTION_PLAN_VERSION, FaninSchema, FanoutLaneSchema, FanoutPolicySchema, FanoutStageLimitsSchema, FanoutStageSchema, GateAgentStageSchema, GateProgramStageSchema, GateStageSchema, LimitBindingSchema, LimitValueSchema, LoopBodyStageSchema, LoopStageSchema, OrchestratorError, PositiveIntegerLimitSchema, ProgramFaninSchema, RUN_DIAGNOSTICS_VIEW_VERSION, RUN_MONITOR_VIEW_VERSION, RouteAgentStageSchema, RouteProgramStageSchema, RouteRuleSchema, RouteStageSchema, RunDiagnosticCodes, SCHEMA_VERSION, StageLimitsSchema, StageSchema, TASK_DETAIL_VIEW_VERSION, TaskAgentStageSchema, TaskProgramStageSchema, TaskStageSchema, TransformSchema, VariableSchema, WorkflowInputSchema, WorkflowLimitsSchema, WorkflowSpecSchema, agentTaskRetryDelayMs, buildRunDiagnosticsView, buildRunMonitorView, buildTaskDetailView, collectWorkflowOutputCandidates, compileExecutionPlan, compileSchemaDsl, defaultAgentOutputZod, estimateAgentCalls, estimateFanoutWork, formatContinuationPrompt, formatSchema, isWorkflowYamlPath, issue, lintWorkflowSpec, loadWorkflowSpec, outputSchemaFooter, parseWorkflowOutput, prepareRun, previewRunView, readNdjsonTail, renderPromptMap, renderStagePrompt, resultFromIssues, retryCountByReason, retryExhaustedEnvelope, retryableOutputFailure, runViewFromIndex, setAgentTaskRetryDelayForTests, stageActorLabel, startPreparedRun, stringifyWorkflowSpec, syncRun, topologicalOrder, zodForCompiledSchema };

package/dist/{monitor-app-CSjUPe9j.mjs → monitor-app-CPlEcyHR.mjs}

@@ -1,6 +1,9 @@
-import { Dt as runDir, S as syncRun, ft as WorkflowSpecSchema, gt as resolveRunLocator, l as buildRunMonitorView, u as buildTaskDetailView } from "./run-workflow-CbxKhAqF.mjs";
+import { E as buildTaskDetailView, Ft as runDir, N as syncRun, Ot as WorkflowSpecSchema, T as buildRunMonitorView } from "./run-workflow-DdIAC8Zu.mjs";
+import { n as resolveRunLocator } from "./cli.mjs";
+import { a as nextIndex, c as shorten, d as tasksForStage, i as formatDuration, l as stageProgressLabel, n as defaultStageIndex, o as runProgressLabel, r as detailSummary, s as runStatusLabel, t as clampIndex, u as statusMark } from "./monitor-rendering-LGr9Ebd_.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
+import YAML from "yaml";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -8,7 +11,7 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 async function loadMonitorSnapshot(runArg) {
 	const locator = await resolveRunLocator(runArg);
 	const index = await syncRun(locator.cwd, locator.runId, { startPending: false });
-	const spec = WorkflowSpecSchema.parse(JSON.parse(await fs.readFile(path.join(runDir(locator.runId, locator.cwd), "workflow.spec.json"), "utf8")));
+	const spec = WorkflowSpecSchema.parse(YAML.parse(await fs.readFile(path.join(runDir(locator.runId, locator.cwd), "workflow.spec.yaml"), "utf8")));
 	return {
 		locator,
 		view: await buildRunMonitorView(locator.cwd, spec, index)
@@ -16,78 +19,10 @@ async function loadMonitorSnapshot(runArg) {
 }
 async function loadTaskDetail(locator, taskId) {
 	const index = await syncRun(locator.cwd, locator.runId, { startPending: false });
-	const spec = WorkflowSpecSchema.parse(JSON.parse(await fs.readFile(path.join(runDir(locator.runId, locator.cwd), "workflow.spec.json"), "utf8")));
+	const spec = WorkflowSpecSchema.parse(YAML.parse(await fs.readFile(path.join(runDir(locator.runId, locator.cwd), "workflow.spec.yaml"), "utf8")));
 	return buildTaskDetailView(locator.cwd, spec, index, taskId);
 }
 //#endregion
-//#region src/tui/monitor-rendering.ts
-function defaultStageIndex(stages) {
-	const running = stages.findIndex((stage) => stage.status === "running");
-	if (running >= 0) return running;
-	const blocked = stages.findIndex((stage) => stage.status === "blocked" || stage.status === "failed");
-	if (blocked >= 0) return blocked;
-	const open = stages.findIndex((stage) => stage.status !== "completed" && stage.status !== "skipped");
-	return open >= 0 ? open : 0;
-}
-function clampIndex(index, length) {
-	if (length <= 0) return 0;
-	return Math.min(Math.max(index, 0), length - 1);
-}
-function tasksForStage(view, stageId) {
-	if (!view || !stageId) return [];
-	return view.tasks.filter((task) => task.stageId === stageId);
-}
-function stageProgressLabel(stage) {
-	const counts = stage.taskCounts;
-	return `${counts.completed}/${counts.total}`;
-}
-function runProgressLabel(view) {
-	return `${view.progress.completedTasks}/${view.progress.knownTasks} tasks`;
-}
-function statusMark(status) {
-	if (status === "completed") return "✔";
-	if (status === "running" || status === "raw_received" || status === "parsing" || status === "repairing") return "●";
-	if (status === "blocked" || status === "failed" || status === "cancelled" || status === "timed_out") return "!";
-	if (status === "skipped") return "-";
-	return " ";
-}
-function shorten(value, width) {
-	if (!value) return "";
-	if (width <= 0) return "";
-	if (value.length <= width) return value;
-	if (width <= 3) return value.slice(0, width);
-	return `${value.slice(0, width - 3)}...`;
-}
-function detailSummary(detail) {
-	if (!detail) return ["No task selected"];
-	return [
-		`${statusMark(detail.task.status)} ${detail.task.status} - ${detail.task.execution}${detail.task.agent ? ` - ${detail.task.agent}` : ""}`,
-		detail.task.durationMs !== void 0 || detail.task.elapsedMs !== void 0 ? `Time: ${formatDuration(detail.task.durationMs ?? detail.task.elapsedMs ?? 0)}` : void 0,
-		detail.task.blockedReason ? `Reason: ${detail.task.blockedReason}` : void 0,
-		detail.outcome?.summary ? `Outcome: ${detail.outcome.summary}` : void 0,
-		detail.outcome?.path ? `Output: ${detail.outcome.path}` : void 0,
-		detail.prompt ? `Prompt: ${detail.prompt.lines} line(s)` : void 0,
-		detail.prompt?.preview ? detail.prompt.preview : void 0,
-		detail.activity.totalAttempts > 0 ? `Attempts: ${detail.activity.totalAttempts}` : "No agent attempts",
-		...detail.activity.attempts.map((attempt) => `${attempt.id} ${attempt.status} ${attempt.path}`),
-		...(detail.outcome?.artifacts ?? []).map((artifact) => `Artifact: ${artifact.label ?? artifact.kind ?? "artifact"} ${artifact.path ?? artifact.url ?? ""}`)
-	].filter((line) => typeof line === "string" && line.length > 0);
-}
-function nextIndex(current, delta, length) {
-	return clampIndex(current + delta, length);
-}
-function formatDuration(milliseconds) {
-	if (milliseconds === void 0 || !Number.isFinite(milliseconds)) return "";
-	const totalSeconds = Math.max(0, Math.floor(milliseconds / 1e3));
-	const seconds = totalSeconds % 60;
-	const totalMinutes = Math.floor(totalSeconds / 60);
-	const minutes = totalMinutes % 60;
-	const hours = Math.floor(totalMinutes / 60);
-	if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
-	if (minutes > 0) return `${minutes}m ${seconds}s`;
-	return `${seconds}s`;
-}
-//#endregion
 //#region src/tui/monitor-app.tsx
 function MonitorApp({ runArg, pollMs = 1e3, initialView, initialLocator, initialFocus = "stages", loadSnapshot = loadMonitorSnapshot, loadDetail = loadTaskDetail }) {
 	const { exit } = useApp();
@@ -247,7 +182,7 @@ function Header({ view }) {
 	const title = `${view.run.workflowName}`;
 	const worker = view.run.worker ? ` - worker ${view.run.worker.status}` : "";
 	const runTime = formatDuration(view.run.durationMs ?? view.run.elapsedMs);
-	const meta = `${runProgressLabel(view)} - ${view.run.status}${runTime ? ` - ${runTime}` : ""}${worker}`;
+	const meta = `${runProgressLabel(view)} - ${runStatusLabel(view)}${runTime ? ` - ${runTime}` : ""}${worker}`;
 	return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "column",
 		children: [/* @__PURE__ */ jsx(Text, {
@@ -413,7 +348,7 @@ function StatusMark({ status }) {
 		color: "green",
 		children: mark
 	});
-	if (status === "running" || status === "raw_received" || status === "parsing" || status === "repairing") return /* @__PURE__ */ jsx(Text, {
+	if (status === "running" || status === "raw_received" || status === "parsing") return /* @__PURE__ */ jsx(Text, {
 		color: "yellow",
 		children: mark
 	});

package/dist/monitor-rendering-LGr9Ebd_.mjs

@@ -0,0 +1,78 @@
+//#region src/tui/monitor-rendering.ts
+function defaultStageIndex(stages) {
+	const running = stages.findIndex((stage) => stage.status === "running");
+	if (running >= 0) return running;
+	const blocked = stages.findIndex((stage) => stage.status === "blocked" || stage.status === "failed");
+	if (blocked >= 0) return blocked;
+	const open = stages.findIndex((stage) => stage.status !== "completed" && stage.status !== "skipped");
+	return open >= 0 ? open : 0;
+}
+function clampIndex(index, length) {
+	if (length <= 0) return 0;
+	return Math.min(Math.max(index, 0), length - 1);
+}
+function tasksForStage(view, stageId) {
+	if (!view || !stageId) return [];
+	return view.tasks.filter((task) => task.stageId === stageId);
+}
+function stageProgressLabel(stage) {
+	const counts = stage.taskCounts;
+	return `${counts.completed}/${counts.total}`;
+}
+function runProgressLabel(view) {
+	return `${view.progress.completedTasks}/${view.progress.knownTasks} tasks`;
+}
+function runStatusLabel(view) {
+	if ((view.run.status === "running" || view.run.status === "pending") && view.run.worker?.status === "stale") return "stale";
+	return view.run.status;
+}
+function statusMark(status) {
+	if (status === "completed") return "✔";
+	if (status === "running" || status === "raw_received" || status === "parsing") return "●";
+	if (status === "blocked" || status === "failed" || status === "cancelled" || status === "timed_out") return "!";
+	if (status === "skipped") return "-";
+	return " ";
+}
+function shorten(value, width) {
+	if (!value) return "";
+	if (width <= 0) return "";
+	if (value.length <= width) return value;
+	if (width <= 3) return value.slice(0, width);
+	return `${value.slice(0, width - 3)}...`;
+}
+function detailSummary(detail) {
+	if (!detail) return ["No task selected"];
+	return [
+		`${statusMark(detail.task.status)} ${detail.task.status} - ${detail.task.execution}${detail.task.agent ? ` - ${detail.task.agent}` : ""}`,
+		detail.task.durationMs !== void 0 || detail.task.elapsedMs !== void 0 ? `Time: ${formatDuration(detail.task.durationMs ?? detail.task.elapsedMs ?? 0)}` : void 0,
+		detail.task.blockedReason ? `Reason: ${detail.task.blockedReason}` : void 0,
+		detail.task.lastRetryReason ? `Retry: ${detail.task.lastRetryReason} ${detail.task.retryBudgetUsed ?? 0}/${detail.task.retryBudgetLimit ?? "?"}` : void 0,
+		detail.task.lastFailureCode ? `Last failure: ${detail.task.lastFailureCode}` : void 0,
+		detail.outcome?.summary ? `Outcome: ${detail.outcome.summary}` : void 0,
+		detail.outcome?.path ? `Output: ${detail.outcome.path}` : void 0,
+		detail.prompt ? `Prompt: ${detail.prompt.lines} line(s)` : void 0,
+		detail.prompt?.preview ? detail.prompt.preview : void 0,
+		detail.activity.totalAttempts > 0 ? `Attempts: ${detail.activity.totalAttempts}` : "No agent attempts",
+		...detail.activity.attempts.map((attempt) => {
+			const retry = attempt.isRetry ? ` retry=${attempt.retryReason ?? "unknown"}#${attempt.retryOrdinal ?? "?"}` : "";
+			const failure = attempt.lastFailureCode ? ` last=${attempt.lastFailureCode}` : "";
+			return `${attempt.id} ${attempt.status}${retry}${failure} ${attempt.path}`;
+		})
+	].filter((line) => typeof line === "string" && line.length > 0);
+}
+function nextIndex(current, delta, length) {
+	return clampIndex(current + delta, length);
+}
+function formatDuration(milliseconds) {
+	if (milliseconds === void 0 || !Number.isFinite(milliseconds)) return "";
+	const totalSeconds = Math.max(0, Math.floor(milliseconds / 1e3));
+	const seconds = totalSeconds % 60;
+	const totalMinutes = Math.floor(totalSeconds / 60);
+	const minutes = totalMinutes % 60;
+	const hours = Math.floor(totalMinutes / 60);
+	if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+//#endregion
+export { nextIndex as a, shorten as c, tasksForStage as d, formatDuration as i, stageProgressLabel as l, defaultStageIndex as n, runProgressLabel as o, detailSummary as r, runStatusLabel as s, clampIndex as t, statusMark as u };

package/dist/run-picker-app-utJ2f5CU.mjs

@@ -0,0 +1,104 @@
+import { t as listRunSummaries } from "./cli.mjs";
+import { a as nextIndex, c as shorten, i as formatDuration, u as statusMark } from "./monitor-rendering-LGr9Ebd_.mjs";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/tui/run-picker-app.tsx
+function RunPickerApp({ title, pollMs = 1e3, initialList, loadRuns = listRunSummaries, onSelect }) {
+	const { exit } = useApp();
+	const { stdout } = useStdout();
+	const [list, setList] = useState(initialList);
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const [error, setError] = useState();
+	const loadRunsRef = useRef(loadRuns);
+	useEffect(() => {
+		loadRunsRef.current = loadRuns;
+	}, [loadRuns]);
+	const refresh = useCallback(async () => {
+		try {
+			const next = await loadRunsRef.current();
+			setList(next);
+			setSelectedIndex((current) => Math.max(0, Math.min(current, Math.max(0, next.entries.length - 1))));
+			setError(void 0);
+		} catch (loadError) {
+			setError(loadError instanceof Error ? loadError.message : String(loadError));
+		}
+	}, []);
+	useEffect(() => {
+		refresh();
+		const timer = setInterval(() => void refresh(), pollMs);
+		return () => clearInterval(timer);
+	}, [pollMs, refresh]);
+	useInput((input, key) => {
+		if (input === "q" || key.ctrl && input === "c") {
+			onSelect(void 0);
+			exit();
+			return;
+		}
+		if (input === "r") refresh();
+		if (key.upArrow) setSelectedIndex((current) => nextIndex(current, -1, list?.entries.length ?? 0));
+		if (key.downArrow) setSelectedIndex((current) => nextIndex(current, 1, list?.entries.length ?? 0));
+		if (key.return) {
+			const selected = list?.entries[selectedIndex];
+			if (!selected || selected.invalid) return;
+			onSelect(selected.runId);
+			exit();
+		}
+	});
+	const width = Math.max(80, stdout.columns ?? 120);
+	const entries = useMemo(() => list?.entries ?? [], [list?.entries]);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: "blue",
+				bold: true,
+				children: title
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: list ? `runs in ${list.dir}` : "Loading runs..."
+			}),
+			error ? /* @__PURE__ */ jsxs(Text, {
+				color: "red",
+				children: ["Error: ", error]
+			}) : null,
+			entries.length === 0 ? /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "No runs found."
+			}) : null,
+			/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				children: entries.map((entry, index) => /* @__PURE__ */ jsxs(Box, { children: [
+					/* @__PURE__ */ jsxs(Text, { children: [index === selectedIndex ? ">" : " ", " "] }),
+					/* @__PURE__ */ jsxs(Text, {
+						dimColor: entry.invalid,
+						children: [statusMark(entry.status ?? "invalid"), " "]
+					}),
+					/* @__PURE__ */ jsxs(Text, { children: [shorten(entry.runId, 40), " "] }),
+					/* @__PURE__ */ jsxs(Text, { children: [shorten(entry.status ?? "invalid", 10), " "] }),
+					/* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [shorten(entry.progress?.label ?? "-", 12), " "]
+					}),
+					/* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						children: [shorten(entry.worker ? `worker ${entry.worker.status}` : "", 16), " "]
+					}),
+					/* @__PURE__ */ jsxs(Text, { children: [shorten(entry.workflowName ?? "", Math.max(12, width - 100)), " "] }),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: formatDuration(entry.durationMs ?? entry.elapsedMs)
+					})
+				] }, entry.runId))
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "up/down move - enter select - r refresh - q quit"
+			})
+		]
+	});
+}
+//#endregion
+export { RunPickerApp };