@tea-agent/loop-agent 0.11.0 → 0.12.0

package/dist/worker/observability/read-model.js

@@ -3,10 +3,13 @@ import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "./events.js";
+import { readBoundedJsonlTail } from "./event-history.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
 import { assessDagRunLiveness, assessDagRunRecoveryEligibility, deriveDagRunEffectiveStatus, } from "../../workflows/dag/lifecycle.js";
 import { parseDagSpec, resolveModelForTask, } from "../../workflows/dag/types.js";
 import { loadFeatureDecisionModels } from "../feature/decision-loader.js";
+export const TASK_RUN_HISTORY_DEFAULT_LIMIT = 20;
+export const TASK_RUN_HISTORY_MAX_LIMIT = 100;
 const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
 const ACTIVE_BATCH_STATUSES = new Set(["running", "pending"]);
 export async function buildGlobalSnapshot(options) {
@@ -15,7 +18,8 @@ export async function buildGlobalSnapshot(options) {
         const now = options.now ?? (() => new Date());
         const staleThresholdMs = options.staleThresholdMs ?? 90_000;
         const quietThresholdMs = options.quietThresholdMs ?? 60_000;
-        const [events, ledgerRuns, ledgerBatches, states, handoffs, dagRuns] = await Promise.all([
+        const taskPoolPresent = existsSync(getTaskPoolRoot(repoRoot));
+        const [eventsLoad, ledgerLoad, ledgerBatches, states, handoffs, dagRuns] = await Promise.all([
             loadObservabilityEvents(repoRoot),
             loadLedgerRuns(repoRoot),
             loadLedgerBatches(repoRoot),
@@ -23,6 +27,8 @@ export async function buildGlobalSnapshot(options) {
             loadFailureHandoffs(repoRoot),
             loadDagRuns(repoRoot, now()),
         ]);
+        const events = eventsLoad.events;
+        const ledgerRuns = ledgerLoad.runs;
         const taskMap = new Map();
         for (const state of states) {
             mergeStateRecord(taskMap, state);
@@ -45,7 +51,12 @@ export async function buildGlobalSnapshot(options) {
             tasks: batch.tasks.map((task) => normalizeTaskArtifactRefs(task, repoRoot)),
         }));
         const health = computeHealth(batches, tasks, dagRuns);
-        const { features, projectionWarnings } = await loadFeatureDecisionModels(repoRoot);
+        const featureLoad = await loadFeatureDecisionModels(repoRoot);
+        const projectionWarnings = [
+            ...(eventsLoad.warnings ?? []),
+            ...(ledgerLoad.warnings ?? []),
+            ...(featureLoad.projectionWarnings ?? []),
+        ];
         return {
             schemaVersion: 1,
             generatedAt: now().toISOString(),
@@ -53,7 +64,8 @@ export async function buildGlobalSnapshot(options) {
             batches,
             tasks,
             dagRuns,
-            features,
+            features: featureLoad.features,
+            taskPool: { present: taskPoolPresent },
             projectionWarnings,
             health,
         };
@@ -80,7 +92,99 @@ export async function buildGlobalSnapshot(options) {
         return snapshot;
     }
 }
+/**
+ * Bounded Task run history from Task Pool ledger facts (newest first).
+ * `before` is an exclusive upper bound on the sort key (`recordedAt` or empty).
+ */
+export async function listTaskRunHistory(repoRoot, taskId, options = {}) {
+    const limit = clampTaskRunHistoryLimit(options.limit);
+    const before = decodeTaskRunHistoryCursor(options.before);
+    const [ledgerLoad, eventsLoad] = await Promise.all([
+        loadLedgerRuns(path.resolve(repoRoot)),
+        loadObservabilityEvents(path.resolve(repoRoot)),
+    ]);
+    const ledgerRuns = ledgerLoad.runs;
+    const events = eventsLoad.events;
+    const historical = buildHistoricalRunMap(ledgerRuns, events);
+    const items = [];
+    for (const run of ledgerRuns) {
+        if (run.taskId !== taskId)
+            continue;
+        const enriched = historical.get(run.workerRunId);
+        items.push({
+            workerRunId: run.workerRunId,
+            taskId: run.taskId,
+            status: enriched?.status ?? mapRunRecordStatus(run.status),
+            startedAt: enriched?.startedAt,
+            finishedAt: enriched?.finishedAt ?? run.recordedAt,
+            recordedAt: run.recordedAt,
+            batchRunId: run.batchRunId,
+            dagRunId: enriched?.dagRunId,
+            ...(run.retryOfWorkerRunId
+                ? { retryOfWorkerRunId: run.retryOfWorkerRunId }
+                : {}),
+            failureCategory: run.failureCategory ?? enriched?.failureCategory,
+            recommendedFollowUp: run.recommendedFollowUp ?? enriched?.recommendedFollowUp,
+        });
+    }
+    items.sort((a, b) => {
+        const ta = a.recordedAt ?? a.finishedAt ?? "";
+        const tb = b.recordedAt ?? b.finishedAt ?? "";
+        if (ta !== tb)
+            return tb.localeCompare(ta);
+        return b.workerRunId.localeCompare(a.workerRunId);
+    });
+    const eligible = before
+        ? items.filter((item) => taskRunSortKey(item).localeCompare(before) < 0)
+        : items;
+    const page = eligible.slice(0, limit);
+    const nextBefore = eligible.length > limit
+        ? encodeTaskRunHistoryCursor(page[page.length - 1])
+        : null;
+    return {
+        taskId,
+        runs: page,
+        limit,
+        nextBefore,
+    };
+}
+function taskRunSortKey(item) {
+    return `${item.recordedAt ?? item.finishedAt ?? ""}\u0000${item.workerRunId}`;
+}
+function encodeTaskRunHistoryCursor(item) {
+    if (!item)
+        return null;
+    return `v1.${Buffer.from(taskRunSortKey(item), "utf-8").toString("base64url")}`;
+}
+function decodeTaskRunHistoryCursor(cursor) {
+    const value = cursor?.trim();
+    if (!value)
+        return null;
+    if (!value.startsWith("v1.")) {
+        // Compatibility with the initial timestamp-only cursor shape.
+        return `${value}\u0000`;
+    }
+    try {
+        return Buffer.from(value.slice(3), "base64url").toString("utf-8");
+    }
+    catch {
+        return `${value}\u0000`;
+    }
+}
+export function clampTaskRunHistoryLimit(limit) {
+    if (limit === undefined || !Number.isFinite(limit) || limit <= 0) {
+        return TASK_RUN_HISTORY_DEFAULT_LIMIT;
+    }
+    return Math.min(Math.floor(limit), TASK_RUN_HISTORY_MAX_LIMIT);
+}
 function emptySnapshot(repoRoot, now) {
+    let taskPoolPresent = false;
+    try {
+        taskPoolPresent = existsSync(getTaskPoolRoot(repoRoot));
+    }
+    catch {
+        taskPoolPresent = false;
+    }
     return {
         schemaVersion: 1,
         generatedAt: now().toISOString(),
@@ -88,6 +192,7 @@ function emptySnapshot(repoRoot, now) {
         batches: [],
         tasks: [],
         dagRuns: [],
+        taskPool: { present: taskPoolPresent },
         health: {
             activeBatches: 0,
             activeTasks: 0,
@@ -118,15 +223,21 @@ function emptySnapshot(repoRoot, now) {
     };
 }
 function toPublicTaskSummary(task) {
-    const { batchRunId: _batch, timeoutMs: _to, commandStartedAt: _cs, ...rest } = task;
+    const { timeoutMs: _to, commandStartedAt: _cs, ...rest } = task;
     return rest;
 }
 function mergeStateRecord(taskMap, state) {
-    const existing = taskMap.get(state.taskId) ?? { taskId: state.taskId, status: "unknown" };
+    const existing = taskMap.get(state.taskId) ?? {
+        taskId: state.taskId,
+        status: "unknown",
+    };
     taskMap.set(state.taskId, {
         ...existing,
-        status: existing.status !== "unknown" ? existing.status : mapStateStatus(state.status),
+        status: existing.status !== "unknown"
+            ? existing.status
+            : mapStateStatus(state.status),
         workerRunId: existing.workerRunId ?? state.workerRunId,
+        updatedAt: state.updatedAt ?? existing.updatedAt,
         artifactRefs: mergeArtifactRefs(existing.artifactRefs, {
             runRecordPath: state.lastRunRecordPath,
         }),
@@ -135,7 +246,10 @@ function mergeStateRecord(taskMap, state) {
     });
 }
 function mergeLedgerRun(taskMap, run) {
-    const existing = taskMap.get(run.taskId) ?? { taskId: run.taskId, status: "unknown" };
+    const existing = taskMap.get(run.taskId) ?? {
+        taskId: run.taskId,
+        status: "unknown",
+    };
     const sameRun = existing.workerRunId === run.workerRunId;
     const runArtifactRefs = {
         runRecordPath: run.runRecordPath,
@@ -158,7 +272,8 @@ function mergeLedgerRun(taskMap, run) {
         harnessTaskId: run.harnessTaskId ?? existing.harnessTaskId,
         finishedAt: run.recordedAt ?? (sameRun ? existing.finishedAt : undefined),
         failureCategory: run.failureCategory ?? (sameRun ? existing.failureCategory : undefined),
-        recommendedFollowUp: run.recommendedFollowUp ?? (sameRun ? existing.recommendedFollowUp : undefined),
+        recommendedFollowUp: run.recommendedFollowUp ??
+            (sameRun ? existing.recommendedFollowUp : undefined),
         artifactRefs: mergeArtifactRefs(sameRun ? existing.artifactRefs : undefined, runArtifactRefs),
     });
 }
@@ -172,7 +287,10 @@ function mergeEvents(taskMap, events) {
 }
 function applyTaskEvent(taskMap, event) {
     const taskId = event.taskId;
-    const existing = taskMap.get(taskId) ?? { taskId, status: "unknown" };
+    const existing = taskMap.get(taskId) ?? {
+        taskId,
+        status: "unknown",
+    };
     taskMap.set(taskId, applyEventToSummary(existing, event));
 }
 function applyEventToSummary(existing, event) {
@@ -320,7 +438,9 @@ function computeLiveness(task, nowMs, staleThresholdMs, quietThresholdMs) {
             task.timeoutAt = new Date(commandStartedMs + timeoutMs).toISOString();
         }
     }
-    const heartbeatMs = task.lastHeartbeatAt ? Date.parse(task.lastHeartbeatAt) : NaN;
+    const heartbeatMs = task.lastHeartbeatAt
+        ? Date.parse(task.lastHeartbeatAt)
+        : NaN;
     const outputMs = task.lastOutputAt ? Date.parse(task.lastOutputAt) : NaN;
     // Priority 1: timeout-risk (elapsed > 0.8 * timeoutMs), only if timeoutMs known.
     if (timeoutMs !== undefined &&
@@ -333,7 +453,9 @@ function computeLiveness(task, nowMs, staleThresholdMs, quietThresholdMs) {
     // (a) Heartbeat present but older than staleThresholdMs.
     // (b) No heartbeat but running longer than staleThresholdMs (startedAt known).
     const heartbeatStale = !Number.isNaN(heartbeatMs) && nowMs - heartbeatMs > staleThresholdMs;
-    const noHeartbeatStale = Number.isNaN(heartbeatMs) && elapsedMs !== undefined && elapsedMs > staleThresholdMs;
+    const noHeartbeatStale = Number.isNaN(heartbeatMs) &&
+        elapsedMs !== undefined &&
+        elapsedMs > staleThresholdMs;
     if (heartbeatStale || noHeartbeatStale) {
         task.liveness = "stale";
         task.status = "stale";
@@ -414,7 +536,8 @@ function summarizeTasks(tasks) {
 function computeHealth(batches, tasks, dagRuns) {
     const worker = {
         activeTasks: tasks.filter((t) => ACTIVE_TASK_STATUSES.has(t.status)).length,
-        activeBatches: batches.filter((b) => ACTIVE_BATCH_STATUSES.has(b.status)).length,
+        activeBatches: batches.filter((b) => ACTIVE_BATCH_STATUSES.has(b.status))
+            .length,
         quietCount: tasks.filter((t) => t.liveness === "quiet").length,
         staleCount: tasks.filter((t) => t.status === "stale").length,
         timeoutRiskCount: tasks.filter((t) => t.liveness === "timeout-risk").length,
@@ -451,7 +574,8 @@ const TERMINAL_RUN_STATUSES = new Set([
  * already-loaded DagRunSummary facts without touching app.js or new files.
  */
 function isDagRunActiveForHealth(dag) {
-    if (dag.effectiveStatus && ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)) {
+    if (dag.effectiveStatus &&
+        ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)) {
         return true;
     }
     // Only "unknown" (and absent) means liveness evidence is insufficient;
@@ -472,7 +596,16 @@ function isDagRunActiveForHealth(dag) {
 }
 function isNodeStatusActive(status) {
     const normalized = (status ?? "").toLowerCase();
-    if (["finished", "completed", "succeeded", "done", "error", "failed", "skipped", "partial_failed"].includes(normalized)) {
+    if ([
+        "finished",
+        "completed",
+        "succeeded",
+        "done",
+        "error",
+        "failed",
+        "skipped",
+        "partial_failed",
+    ].includes(normalized)) {
         return false;
     }
     return true;
@@ -511,13 +644,13 @@ function computeDagHealth(dagRuns) {
             interruptedRuns++;
         if (dag.stateConsistent === false)
             inconsistentRuns++;
-        if (lifecycle !== "completed"
-            && (lifecycle === "paused"
-                || liveness === "stale"
-                || liveness === "orphaned"
-                || dag.effectiveStatus === "interrupted"
-                || dag.effectiveStatus === "remote-unknown"
-                || dag.stateConsistent === false)) {
+        if (lifecycle !== "completed" &&
+            (lifecycle === "paused" ||
+                liveness === "stale" ||
+                liveness === "orphaned" ||
+                dag.effectiveStatus === "interrupted" ||
+                dag.effectiveStatus === "remote-unknown" ||
+                dag.stateConsistent === false)) {
             attentionRuns++;
         }
     }
@@ -547,12 +680,14 @@ function sanitizeProjectionError(error) {
     let name;
     let message;
     try {
-        name = typeof error.name === "string"
-            ? error.name
-            : undefined;
-        message = typeof error.message === "string"
-            ? error.message
-            : undefined;
+        name =
+            typeof error.name === "string"
+                ? error.name
+                : undefined;
+        message =
+            typeof error.message === "string"
+                ? error.message
+                : undefined;
     }
     catch {
         return { message: fallback, at };
@@ -563,12 +698,12 @@ function sanitizeProjectionError(error) {
     }
     // Reject anything that looks like a stack frame, an absolute path, or a secret.
     const raw = String(candidate);
-    if (raw.includes("\n")
-        || /\bat \S+/i.test(raw)
-        || /[A-Za-z]:\\/.test(raw)
-        || raw.includes("/Users/")
-        || raw.includes("/home/")
-        || /SECRET|TOKEN|PASSWORD|API_KEY/i.test(raw)) {
+    if (raw.includes("\n") ||
+        /\bat \S+/i.test(raw) ||
+        /[A-Za-z]:\\/.test(raw) ||
+        raw.includes("/Users/") ||
+        raw.includes("/home/") ||
+        /SECRET|TOKEN|PASSWORD|API_KEY/i.test(raw)) {
         return { message: name ? `${name}: 投影失败` : fallback, at };
     }
     const trimmed = raw.trim().slice(0, 200);
@@ -581,7 +716,11 @@ function mergeArtifactRefs(existing, incoming) {
     for (const [key, value] of Object.entries(incoming)) {
         if (!value)
             continue;
-        if (key === "runRecordPath" || key === "dagPath" || key === "reportMarkdown" || key === "doctorMarkdown" || key === "closeoutDraft") {
+        if (key === "runRecordPath" ||
+            key === "dagPath" ||
+            key === "reportMarkdown" ||
+            key === "doctorMarkdown" ||
+            key === "closeoutDraft") {
             merged[key] = value;
         }
     }
@@ -668,49 +807,86 @@ function mapBatchStatus(status) {
             return "unknown";
     }
 }
+/** Per-file hard cap for projection merge (snapshot must not embed unbounded ledger). */
+const SNAPSHOT_EVENTS_MAX_LINES_PER_FILE = 2_000;
+const SNAPSHOT_EVENTS_MAX_BYTES_PER_FILE = 4 * 1024 * 1024;
+/** Global hard cap after dedupe for snapshot projection merge. */
+const SNAPSHOT_EVENTS_MAX_TOTAL = 8_000;
+const SNAPSHOT_LEDGER_MAX_LINES = 10_000;
+const SNAPSHOT_LEDGER_MAX_BYTES = 8 * 1024 * 1024;
 async function loadObservabilityEvents(repoRoot) {
     const events = [];
+    const warnings = [];
     const obsRoot = path.join(getTaskPoolRoot(repoRoot), "observability");
-    await appendJsonlEvents(path.join(obsRoot, "events.jsonl"), events);
+    await appendJsonlEventsBounded(path.join(obsRoot, "events.jsonl"), events, warnings);
     const batchesDir = path.join(obsRoot, "batches");
-    await forEachSubdirJsonl(batchesDir, "events.jsonl", events);
+    await forEachSubdirJsonl(batchesDir, "events.jsonl", events, warnings);
     const runsDir = path.join(obsRoot, "runs");
-    await forEachSubdirJsonl(runsDir, "events.jsonl", events);
-    return [...new Map(events.map((event) => [event.id, event])).values()];
+    await forEachSubdirJsonl(runsDir, "events.jsonl", events, warnings);
+    const deduped = [
+        ...new Map(events.map((event) => [event.id, event])).values(),
+    ].sort(compareWorkerEvents);
+    if (deduped.length > SNAPSHOT_EVENTS_MAX_TOTAL) {
+        warnings.push(`observability event projection truncated to ${SNAPSHOT_EVENTS_MAX_TOTAL} events (capacity bound)`);
+        return {
+            events: deduped.slice(-SNAPSHOT_EVENTS_MAX_TOTAL),
+            warnings,
+        };
+    }
+    return { events: deduped, warnings };
 }
-async function forEachSubdirJsonl(parentDir, filename, events) {
+function compareWorkerEvents(a, b) {
+    const byTime = a.at.localeCompare(b.at);
+    if (byTime !== 0)
+        return byTime;
+    return a.id.localeCompare(b.id);
+}
+async function forEachSubdirJsonl(parentDir, filename, events, warnings) {
     try {
         const entries = await readdir(parentDir, { withFileTypes: true });
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
-            await appendJsonlEvents(path.join(parentDir, entry.name, filename), events);
+            await appendJsonlEventsBounded(path.join(parentDir, entry.name, filename), events, warnings);
         }
     }
     catch {
         // skip missing dir
     }
 }
-async function appendJsonlEvents(filePath, events) {
-    const raw = await safeReadText(filePath);
-    if (!raw)
-        return;
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
+async function appendJsonlEventsBounded(filePath, events, warnings) {
+    const tail = await readBoundedJsonlTail(filePath, {
+        maxBytes: SNAPSHOT_EVENTS_MAX_BYTES_PER_FILE,
+        maxLines: SNAPSHOT_EVENTS_MAX_LINES_PER_FILE,
+    });
+    let accepted = 0;
+    for (const line of tail.lines) {
+        const trimmed = line.text.trim();
         if (!trimmed)
             continue;
         const event = parseWorkerEventLine(trimmed);
-        if (event)
+        if (event) {
             events.push(event);
+            accepted += 1;
+        }
+    }
+    if (tail.truncated) {
+        warnings.push("truncated event tail for " + path.basename(path.dirname(filePath)) + "/" + path.basename(filePath) + " to newest " + accepted + " valid events");
     }
 }
 async function loadLedgerRuns(repoRoot) {
     const runs = [];
-    const raw = await safeReadText(path.join(getTaskPoolRoot(repoRoot), "runs.jsonl"));
-    if (!raw)
-        return runs;
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
+    const warnings = [];
+    const tail = await readBoundedJsonlTail(path.join(getTaskPoolRoot(repoRoot), "runs.jsonl"), { maxBytes: SNAPSHOT_LEDGER_MAX_BYTES, maxLines: SNAPSHOT_LEDGER_MAX_LINES });
+    if (tail.truncated) {
+        warnings.push("runs.jsonl projection truncated to newest " +
+            SNAPSHOT_LEDGER_MAX_LINES +
+            " lines / " +
+            SNAPSHOT_LEDGER_MAX_BYTES +
+            " bytes");
+    }
+    for (const line of tail.lines) {
+        const trimmed = line.text.trim();
         if (!trimmed)
             continue;
         const parsed = safeParseJson(trimmed);
@@ -724,6 +900,7 @@ async function loadLedgerRuns(repoRoot) {
             continue;
         const failure = readObject(parsed, "failure");
         const failureArtifacts = readObject(parsed, "failureArtifacts");
+        const retryOfWorkerRunId = readString(parsed, "retryOfWorkerRunId");
         runs.push({
             batchRunId,
             workerRunId,
@@ -734,8 +911,11 @@ async function loadLedgerRuns(repoRoot) {
             runRecordPath: readString(parsed, "runRecordPath"),
             dagPath: readString(parsed, "dagPath"),
             recordedAt: readString(parsed, "recordedAt"),
+            ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
             failureCategory: failure ? readString(failure, "category") : undefined,
-            recommendedFollowUp: failure ? readString(failure, "recommendedFollowUpKind") : undefined,
+            recommendedFollowUp: failure
+                ? readString(failure, "recommendedFollowUpKind")
+                : undefined,
             failureArtifacts: failureArtifacts
                 ? {
                     reportMarkdown: readString(failureArtifacts, "reportMarkdownArtifactPath"),
@@ -745,7 +925,7 @@ async function loadLedgerRuns(repoRoot) {
                 : undefined,
         });
     }
-    return runs;
+    return { runs, warnings };
 }
 async function loadLedgerBatches(repoRoot) {
     const batches = [];
@@ -761,20 +941,26 @@ async function loadLedgerBatches(repoRoot) {
             if (!parsed)
                 continue;
             const summaryObj = readObject(parsed, "summary");
+            let summary;
+            if (summaryObj) {
+                const recordErrors = readNumber(summaryObj, "recordErrors");
+                const runErrors = readNumber(summaryObj, "runErrors");
+                summary = {
+                    total: readNumber(summaryObj, "total") ?? 0,
+                    succeeded: readNumber(summaryObj, "succeeded") ?? 0,
+                    failed: readNumber(summaryObj, "failed") ?? 0,
+                    reused: readNumber(summaryObj, "reused") ?? 0,
+                    ...(recordErrors !== undefined ? { recordErrors } : {}),
+                    ...(runErrors !== undefined ? { runErrors } : {}),
+                };
+            }
             batches.push({
                 batchRunId: readString(parsed, "batchRunId") ?? batchRunId,
                 featureId: readString(parsed, "featureId"),
                 startedAt: readString(parsed, "startedAt"),
                 finishedAt: readString(parsed, "finishedAt"),
                 status: mapBatchStatus(readString(parsed, "status") ?? "unknown"),
-                summary: summaryObj
-                    ? {
-                        total: readNumber(summaryObj, "total") ?? 0,
-                        succeeded: readNumber(summaryObj, "succeeded") ?? 0,
-                        failed: readNumber(summaryObj, "failed") ?? 0,
-                        reused: readNumber(summaryObj, "reused") ?? 0,
-                    }
-                    : undefined,
+                summary,
                 tasks: [],
                 batchRunPath,
             });
@@ -806,8 +992,11 @@ async function loadStateRecords(repoRoot) {
                 status,
                 workerRunId: readString(parsed, "workerRunId"),
                 lastRunRecordPath: readString(parsed, "lastRunRecordPath"),
+                updatedAt: readString(parsed, "updatedAt"),
                 failureCategory: failure ? readString(failure, "category") : undefined,
-                recommendedFollowUp: failure ? readString(failure, "recommendedFollowUpKind") : undefined,
+                recommendedFollowUp: failure
+                    ? readString(failure, "recommendedFollowUpKind")
+                    : undefined,
             });
         }
     }
@@ -858,7 +1047,9 @@ function mergeDagRun(existing, incoming) {
         return incoming;
     const startedAt = incoming.startedAt ?? existing.startedAt;
     const finishedAt = incoming.finishedAt ?? existing.finishedAt;
-    const ranks = incoming.ranks && incoming.ranks.length > 0 ? incoming.ranks : existing.ranks;
+    const ranks = incoming.ranks && incoming.ranks.length > 0
+        ? incoming.ranks
+        : existing.ranks;
     const durationMs = incoming.durationMs ??
         existing.durationMs ??
         computeDurationMs(startedAt, finishedAt);
@@ -877,7 +1068,9 @@ function mergeDagRun(existing, incoming) {
         ...(ranks && ranks.length > 0 ? { ranks } : {}),
         nodes: mergeDagNodes(existing.nodes, incoming.nodes),
         edges: incoming.edges.length > 0 ? incoming.edges : existing.edges,
-        ...(incoming.dagPath ?? existing.dagPath ? { dagPath: incoming.dagPath ?? existing.dagPath } : {}),
+        ...((incoming.dagPath ?? existing.dagPath)
+            ? { dagPath: incoming.dagPath ?? existing.dagPath }
+            : {}),
     };
 }
 function mergeDagNodes(existing, incoming) {
@@ -921,7 +1114,9 @@ function isFailedNodeStatus(status) {
     if (!status)
         return false;
     const normalized = status.toLowerCase();
-    return normalized === "error" || normalized === "failed" || normalized === "partial_failed";
+    return (normalized === "error" ||
+        normalized === "failed" ||
+        normalized === "partial_failed");
 }
 function nodeOutputPreview(node) {
     const stdout = readString(node, "stdout") ?? readString(node, "assistantText");
@@ -997,13 +1192,19 @@ async function loadDagEventFiles(repoRoot) {
                 const outputPreview = readString(parsed, "outputPreview");
                 nodeMap.set(nodeId, {
                     nodeId,
-                    ...(rank ?? prev.rank ? { rank: rank ?? prev.rank } : {}),
-                    ...(executor ?? prev.executor ? { executor: executor ?? prev.executor } : {}),
-                    ...(model ?? prev.model ? { model: model ?? prev.model } : {}),
-                    ...(label ?? prev.label ? { label: label ?? prev.label } : {}),
-                    ...(status ?? prev.status ? { status: status ?? prev.status } : {}),
-                    ...(durationMs ?? prev.durationMs ? { durationMs: durationMs ?? prev.durationMs } : {}),
-                    ...(outputPreview ?? prev.outputPreview ? { outputPreview: outputPreview ?? prev.outputPreview } : {}),
+                    ...((rank ?? prev.rank) ? { rank: rank ?? prev.rank } : {}),
+                    ...((executor ?? prev.executor)
+                        ? { executor: executor ?? prev.executor }
+                        : {}),
+                    ...((model ?? prev.model) ? { model: model ?? prev.model } : {}),
+                    ...((label ?? prev.label) ? { label: label ?? prev.label } : {}),
+                    ...((status ?? prev.status) ? { status: status ?? prev.status } : {}),
+                    ...((durationMs ?? prev.durationMs)
+                        ? { durationMs: durationMs ?? prev.durationMs }
+                        : {}),
+                    ...((outputPreview ?? prev.outputPreview)
+                        ? { outputPreview: outputPreview ?? prev.outputPreview }
+                        : {}),
                 });
                 byId.set(dagRunId, nodeMap);
             }
@@ -1059,7 +1260,9 @@ async function parseDagStateFile(statePath, now) {
             return undefined;
         const runDir = path.dirname(statePath);
         const lifecycleName = path.basename(path.dirname(runDir));
-        const lifecycle = lifecycleName === "active" || lifecycleName === "paused" || lifecycleName === "completed"
+        const lifecycle = lifecycleName === "active" ||
+            lifecycleName === "paused" ||
+            lifecycleName === "completed"
             ? lifecycleName
             : undefined;
         const dagRunId = readString(parsed, "runId") ?? path.basename(runDir);
@@ -1077,14 +1280,29 @@ async function parseDagStateFile(statePath, now) {
         const state = parsed;
         const liveness = assessDagRunLiveness({ state, now });
         const effectiveStatus = lifecycle
-            ? deriveDagRunEffectiveStatus({ lifecycle, state, liveness: liveness.status })
+            ? deriveDagRunEffectiveStatus({
+                lifecycle,
+                state,
+                liveness: liveness.status,
+            })
             : "unknown";
         const stateConsistent = lifecycle === undefined
             ? false
-            : !((lifecycle === "paused" && state.status !== "paused")
-                || (lifecycle === "completed" && !["finished", "failed", "partial_failed", "superseded", "abandoned"].includes(state.status)));
+            : !((lifecycle === "paused" && state.status !== "paused") ||
+                (lifecycle === "completed" &&
+                    ![
+                        "finished",
+                        "failed",
+                        "partial_failed",
+                        "superseded",
+                        "abandoned",
+                    ].includes(state.status)));
         const recoveryEligibility = lifecycle
-            ? assessDagRunRecoveryEligibility({ lifecycle, state, liveness: liveness.status })
+            ? assessDagRunRecoveryEligibility({
+                lifecycle,
+                state,
+                liveness: liveness.status,
+            })
             : undefined;
         return {
             dagRunId,
@@ -1122,7 +1340,9 @@ async function parseDagEdges(runPath, nodes) {
         if (!taskId || !knownNodeIds.has(taskId))
             continue;
         const dependencies = readStringArray(task, "depends_on");
-        const compatibleDependencies = dependencies.length > 0 ? dependencies : readStringArray(task, "dependsOn");
+        const compatibleDependencies = dependencies.length > 0
+            ? dependencies
+            : readStringArray(task, "dependsOn");
         for (const dependencyId of compatibleDependencies) {
             if (dependencyId === taskId || !knownNodeIds.has(dependencyId))
                 continue;
@@ -1169,7 +1389,10 @@ async function loadDagNodeModels(runPath) {
         const legacy = raw;
         const tasks = legacy.tasks;
         const executorModels = legacy.executorModels;
-        if (!Array.isArray(tasks) || typeof executorModels !== "object" || executorModels === null || Array.isArray(executorModels)) {
+        if (!Array.isArray(tasks) ||
+            typeof executorModels !== "object" ||
+            executorModels === null ||
+            Array.isArray(executorModels)) {
             return models;
         }
         for (const task of tasks) {
@@ -1194,7 +1417,9 @@ async function loadDagNodeModels(runPath) {
 function parseDagNodes(parsed, rankByNode, modelByNode) {
     const nodes = [];
     const nodesValue = parsed.nodes;
-    if (nodesValue && typeof nodesValue === "object" && !Array.isArray(nodesValue)) {
+    if (nodesValue &&
+        typeof nodesValue === "object" &&
+        !Array.isArray(nodesValue)) {
         for (const [nodeId, nodeVal] of Object.entries(nodesValue)) {
             if (!nodeVal || typeof nodeVal !== "object" || Array.isArray(nodeVal))
                 continue;
@@ -1261,7 +1486,9 @@ async function safeReadJson(filePath) {
 function safeParseJson(raw) {
     try {
         const parsed = JSON.parse(raw);
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        if (parsed === null ||
+            typeof parsed !== "object" ||
+            Array.isArray(parsed)) {
             return undefined;
         }
         return parsed;
@@ -1304,7 +1531,9 @@ function readNumber(value, key) {
     if (!value || typeof value !== "object")
         return undefined;
     const child = value[key];
-    return typeof child === "number" && Number.isFinite(child) ? child : undefined;
+    return typeof child === "number" && Number.isFinite(child)
+        ? child
+        : undefined;
 }
 function readStringMatrix(value, key) {
     if (!value || typeof value !== "object")