@tea-agent/loop-agent 0.5.0 → 0.6.0

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

@@ -0,0 +1,1013 @@
+import { existsSync, readFileSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { truncateUtf8Preview } from "../../shared/preview.js";
+import { parseWorkerEventLine } from "./events.js";
+const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
+const ACTIVE_BATCH_STATUSES = new Set(["running", "pending"]);
+export async function buildGlobalSnapshot(options) {
+    try {
+        const repoRoot = path.resolve(options.repoRoot);
+        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([
+            loadObservabilityEvents(repoRoot),
+            loadLedgerRuns(repoRoot),
+            loadLedgerBatches(repoRoot),
+            loadStateRecords(repoRoot),
+            loadFailureHandoffs(repoRoot),
+            loadDagRuns(repoRoot),
+        ]);
+        const taskMap = new Map();
+        for (const state of states) {
+            mergeStateRecord(taskMap, state);
+        }
+        for (const run of ledgerRuns) {
+            mergeLedgerRun(taskMap, run);
+        }
+        mergeEvents(taskMap, events);
+        mergeHandoffs(taskMap, handoffs);
+        applyStaleDetection(taskMap, now(), staleThresholdMs, quietThresholdMs);
+        const historicalRunMap = buildHistoricalRunMap(ledgerRuns, events);
+        mergeHandoffs(historicalRunMap, handoffs);
+        applyStaleDetection(historicalRunMap, now(), staleThresholdMs, quietThresholdMs);
+        const tasks = [...taskMap.values()]
+            .map(toPublicTaskSummary)
+            .map((task) => normalizeTaskArtifactRefs(task, repoRoot))
+            .sort((a, b) => a.taskId.localeCompare(b.taskId));
+        const batches = buildBatches(ledgerBatches, events, historicalRunMap).map((batch) => ({
+            ...batch,
+            tasks: batch.tasks.map((task) => normalizeTaskArtifactRefs(task, repoRoot)),
+        }));
+        const health = computeHealth(batches, tasks);
+        return {
+            schemaVersion: 1,
+            generatedAt: now().toISOString(),
+            repoRoot,
+            batches,
+            tasks,
+            dagRuns,
+            health,
+        };
+    }
+    catch {
+        const now = options.now ?? (() => new Date());
+        return emptySnapshot(path.resolve(options.repoRoot), now);
+    }
+}
+function emptySnapshot(repoRoot, now) {
+    return {
+        schemaVersion: 1,
+        generatedAt: now().toISOString(),
+        repoRoot,
+        batches: [],
+        tasks: [],
+        dagRuns: [],
+        health: {
+            activeBatches: 0,
+            activeTasks: 0,
+            quietCount: 0,
+            staleCount: 0,
+            timeoutRiskCount: 0,
+            failuresCount: 0,
+        },
+    };
+}
+function toPublicTaskSummary(task) {
+    const { batchRunId: _batch, timeoutMs: _to, commandStartedAt: _cs, ...rest } = task;
+    return rest;
+}
+function mergeStateRecord(taskMap, state) {
+    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),
+        workerRunId: existing.workerRunId ?? state.workerRunId,
+        artifactRefs: mergeArtifactRefs(existing.artifactRefs, {
+            runRecordPath: state.lastRunRecordPath,
+        }),
+        failureCategory: existing.failureCategory ?? state.failureCategory,
+        recommendedFollowUp: existing.recommendedFollowUp ?? state.recommendedFollowUp,
+    });
+}
+function mergeLedgerRun(taskMap, run) {
+    const existing = taskMap.get(run.taskId) ?? { taskId: run.taskId, status: "unknown" };
+    const sameRun = existing.workerRunId === run.workerRunId;
+    const runArtifactRefs = {
+        runRecordPath: run.runRecordPath,
+        dagPath: run.dagPath,
+        ...run.failureArtifacts,
+    };
+    taskMap.set(run.taskId, {
+        ...(sameRun
+            ? existing
+            : {
+                taskId: run.taskId,
+                status: "unknown",
+                featureId: existing.featureId,
+                harnessTaskId: existing.harnessTaskId,
+            }),
+        batchRunId: run.batchRunId,
+        featureId: run.featureId ?? existing.featureId,
+        status: mapRunRecordStatus(run.status),
+        workerRunId: run.workerRunId,
+        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),
+        artifactRefs: mergeArtifactRefs(sameRun ? existing.artifactRefs : undefined, runArtifactRefs),
+    });
+}
+function mergeEvents(taskMap, events) {
+    const sorted = [...events].sort((a, b) => a.at.localeCompare(b.at));
+    for (const event of sorted) {
+        if (event.taskId) {
+            applyTaskEvent(taskMap, event);
+        }
+    }
+}
+function applyTaskEvent(taskMap, event) {
+    const taskId = event.taskId;
+    const existing = taskMap.get(taskId) ?? { taskId, status: "unknown" };
+    taskMap.set(taskId, applyEventToSummary(existing, event));
+}
+function applyEventToSummary(existing, event) {
+    const updated = {
+        ...existing,
+        batchRunId: event.batchRunId ?? existing.batchRunId,
+        featureId: existing.featureId,
+        workerRunId: event.workerRunId ?? existing.workerRunId,
+        harnessTaskId: event.harnessTaskId ?? existing.harnessTaskId,
+        dagRunId: event.dagRunId ?? existing.dagRunId,
+        failureCategory: event.failureCategory ?? existing.failureCategory,
+        recommendedFollowUp: event.recommendedFollowUp ?? existing.recommendedFollowUp,
+        artifactRefs: mergeArtifactRefs(existing.artifactRefs, event.artifactRefs),
+    };
+    const derivedStatus = deriveEventStatus(event);
+    if (derivedStatus) {
+        updated.status = derivedStatus;
+    }
+    if (event.type === "task.started" || event.type === "step.started") {
+        if (!updated.startedAt || event.at < updated.startedAt) {
+            updated.startedAt = event.at;
+        }
+    }
+    if (event.type === "task.finished" || event.type === "task.reused") {
+        updated.finishedAt = event.at;
+        if (event.durationMs !== undefined) {
+            updated.durationMs = event.durationMs;
+        }
+    }
+    if (event.type === "command.heartbeat" || event.type === "step.heartbeat") {
+        updated.lastHeartbeatAt = event.at;
+    }
+    if (event.type === "command.output" ||
+        event.type === "step.output" ||
+        event.type === "dag.node.output") {
+        updated.lastOutputAt = event.at;
+    }
+    if (event.type === "command.started") {
+        if (event.timeoutMs !== undefined)
+            updated.timeoutMs = event.timeoutMs;
+        if (event.pid !== undefined)
+            updated.pid = event.pid;
+        updated.commandStartedAt = event.at;
+    }
+    if (event.type === "command.finished") {
+        delete updated.timeoutMs;
+        delete updated.pid;
+        delete updated.commandStartedAt;
+    }
+    return updated;
+}
+function buildHistoricalRunMap(ledgerRuns, events) {
+    const runMap = new Map();
+    for (const run of ledgerRuns) {
+        runMap.set(run.workerRunId, {
+            taskId: run.taskId,
+            batchRunId: run.batchRunId,
+            featureId: run.featureId,
+            status: mapRunRecordStatus(run.status),
+            workerRunId: run.workerRunId,
+            harnessTaskId: run.harnessTaskId,
+            finishedAt: run.recordedAt,
+            failureCategory: run.failureCategory,
+            recommendedFollowUp: run.recommendedFollowUp,
+            artifactRefs: mergeArtifactRefs(undefined, {
+                runRecordPath: run.runRecordPath,
+                dagPath: run.dagPath,
+                ...run.failureArtifacts,
+            }),
+        });
+    }
+    for (const event of [...events].sort((a, b) => a.at.localeCompare(b.at))) {
+        if (!event.workerRunId || !event.taskId)
+            continue;
+        const existing = runMap.get(event.workerRunId) ?? {
+            taskId: event.taskId,
+            workerRunId: event.workerRunId,
+            status: "unknown",
+        };
+        runMap.set(event.workerRunId, applyEventToSummary(existing, event));
+    }
+    return runMap;
+}
+function deriveEventStatus(event) {
+    switch (event.type) {
+        case "task.queued":
+            return event.status ?? "pending";
+        case "task.started":
+            return event.status ?? "running";
+        case "task.reused":
+            return event.status ?? "reused";
+        case "task.finished":
+            return event.status ?? "succeeded";
+        case "state.updated":
+            return event.status;
+        case "failure.routed":
+            return "failed";
+        default:
+            return undefined;
+    }
+}
+function mergeHandoffs(taskMap, handoffs) {
+    for (const handoff of handoffs) {
+        for (const task of taskMap.values()) {
+            if (task.workerRunId === handoff.workerRunId) {
+                task.artifactRefs = mergeArtifactRefs(task.artifactRefs, {
+                    closeoutDraft: handoff.closeoutDraftPath,
+                });
+            }
+        }
+    }
+}
+function applyStaleDetection(taskMap, now, staleThresholdMs, quietThresholdMs) {
+    const nowMs = now.getTime();
+    for (const task of taskMap.values()) {
+        if (task.status !== "running")
+            continue;
+        try {
+            computeLiveness(task, nowMs, staleThresholdMs, quietThresholdMs);
+        }
+        catch {
+            // Fault tolerance: keep task as-is if liveness computation fails.
+            task.liveness = "active";
+        }
+    }
+}
+function computeLiveness(task, nowMs, staleThresholdMs, quietThresholdMs) {
+    const startedAt = task.startedAt;
+    let elapsedMs;
+    if (startedAt) {
+        const startedMs = Date.parse(startedAt);
+        if (!Number.isNaN(startedMs)) {
+            elapsedMs = Math.max(0, nowMs - startedMs);
+            task.elapsedMs = elapsedMs;
+        }
+    }
+    const timeoutMs = task.timeoutMs;
+    let commandElapsedMs;
+    const commandStartedMs = task.commandStartedAt
+        ? Date.parse(task.commandStartedAt)
+        : NaN;
+    if (!Number.isNaN(commandStartedMs)) {
+        commandElapsedMs = Math.max(0, nowMs - commandStartedMs);
+        if (timeoutMs !== undefined) {
+            task.timeoutAt = new Date(commandStartedMs + timeoutMs).toISOString();
+        }
+    }
+    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 &&
+        commandElapsedMs !== undefined &&
+        commandElapsedMs > 0.8 * timeoutMs) {
+        task.liveness = "timeout-risk";
+        return;
+    }
+    // Priority 2: stale.
+    // (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;
+    if (heartbeatStale || noHeartbeatStale) {
+        task.liveness = "stale";
+        task.status = "stale";
+        return;
+    }
+    // Priority 3: quiet — alive (recent heartbeat) but output older than quietThresholdMs.
+    const quietBaselineMs = !Number.isNaN(outputMs) ? outputMs : commandStartedMs;
+    if (!Number.isNaN(heartbeatMs) &&
+        !Number.isNaN(quietBaselineMs) &&
+        nowMs - quietBaselineMs > quietThresholdMs) {
+        task.liveness = "quiet";
+        return;
+    }
+    // Default: active.
+    task.liveness = "active";
+}
+function buildBatches(ledgerBatches, events, taskMap) {
+    const batchMap = new Map();
+    for (const batch of ledgerBatches) {
+        batchMap.set(batch.batchRunId, { ...batch, tasks: [] });
+    }
+    for (const event of events) {
+        if (!event.batchRunId)
+            continue;
+        if (!batchMap.has(event.batchRunId)) {
+            batchMap.set(event.batchRunId, {
+                batchRunId: event.batchRunId,
+                status: "unknown",
+                tasks: [],
+            });
+        }
+        const batch = batchMap.get(event.batchRunId);
+        if (event.type === "batch.started") {
+            batch.startedAt = event.at;
+            batch.status = "running";
+        }
+        if (event.type === "batch.finished") {
+            batch.finishedAt = event.at;
+            batch.status = event.status ?? "succeeded";
+        }
+    }
+    for (const task of taskMap.values()) {
+        if (!task.batchRunId)
+            continue;
+        if (!batchMap.has(task.batchRunId)) {
+            batchMap.set(task.batchRunId, {
+                batchRunId: task.batchRunId,
+                status: "unknown",
+                tasks: [],
+            });
+        }
+        const batch = batchMap.get(task.batchRunId);
+        batch.featureId = batch.featureId ?? task.featureId;
+        batch.tasks.push(toPublicTaskSummary(task));
+    }
+    for (const batch of batchMap.values()) {
+        batch.tasks.sort((a, b) => a.taskId.localeCompare(b.taskId));
+        if (batch.summary === undefined && batch.tasks.length > 0) {
+            batch.summary = summarizeTasks(batch.tasks);
+        }
+    }
+    return [...batchMap.values()].sort((a, b) => a.batchRunId.localeCompare(b.batchRunId));
+}
+function summarizeTasks(tasks) {
+    let succeeded = 0;
+    let failed = 0;
+    let reused = 0;
+    for (const task of tasks) {
+        if (task.status === "succeeded")
+            succeeded++;
+        else if (task.status === "failed")
+            failed++;
+        else if (task.status === "reused")
+            reused++;
+    }
+    return { total: tasks.length, succeeded, failed, reused };
+}
+function computeHealth(batches, tasks) {
+    return {
+        activeBatches: batches.filter((b) => ACTIVE_BATCH_STATUSES.has(b.status)).length,
+        activeTasks: tasks.filter((t) => ACTIVE_TASK_STATUSES.has(t.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,
+        failuresCount: tasks.filter((t) => t.status === "failed").length,
+    };
+}
+function mergeArtifactRefs(existing, incoming) {
+    if (!incoming)
+        return existing;
+    const merged = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+        if (!value)
+            continue;
+        if (key === "runRecordPath" || key === "dagPath" || key === "reportMarkdown" || key === "doctorMarkdown" || key === "closeoutDraft") {
+            merged[key] = value;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function normalizeTaskArtifactRefs(task, repoRoot) {
+    if (!task.artifactRefs)
+        return task;
+    const normalized = {};
+    const keys = [
+        "runRecordPath",
+        "dagPath",
+        "reportMarkdown",
+        "doctorMarkdown",
+        "closeoutDraft",
+    ];
+    for (const key of keys) {
+        const value = task.artifactRefs[key];
+        if (!value)
+            continue;
+        const normalizedPath = normalizeRepoRelativePath(repoRoot, value);
+        if (normalizedPath)
+            normalized[key] = normalizedPath;
+    }
+    return {
+        ...task,
+        artifactRefs: Object.keys(normalized).length > 0 ? normalized : undefined,
+    };
+}
+function normalizeRepoRelativePath(repoRoot, value) {
+    const resolvedRoot = path.resolve(repoRoot);
+    const resolved = path.isAbsolute(value)
+        ? path.resolve(value)
+        : path.resolve(resolvedRoot, value);
+    const relative = path.relative(resolvedRoot, resolved);
+    if (relative === "" ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative)) {
+        return undefined;
+    }
+    return relative.split(path.sep).join("/");
+}
+function mapRunRecordStatus(status) {
+    switch (status) {
+        case "succeeded":
+            return "succeeded";
+        case "failed":
+            return "failed";
+        case "reused":
+            return "reused";
+        case "run-error":
+        case "record-error":
+            return "failed";
+        default:
+            return "unknown";
+    }
+}
+function mapStateStatus(status) {
+    switch (status) {
+        case "Running":
+            return "running";
+        case "Queued":
+            return "pending";
+        case "Done":
+            return "succeeded";
+        case "Failed":
+            return "failed";
+        case "Blocked":
+            return "blocked";
+        default:
+            return "unknown";
+    }
+}
+function mapBatchStatus(status) {
+    switch (status) {
+        case "completed":
+            return "succeeded";
+        case "failed":
+            return "failed";
+        case "running":
+            return "running";
+        default:
+            return "unknown";
+    }
+}
+async function loadObservabilityEvents(repoRoot) {
+    const events = [];
+    const obsRoot = path.join(repoRoot, ".task-pool", "observability");
+    await appendJsonlEvents(path.join(obsRoot, "events.jsonl"), events);
+    const batchesDir = path.join(obsRoot, "batches");
+    await forEachSubdirJsonl(batchesDir, "events.jsonl", events);
+    const runsDir = path.join(obsRoot, "runs");
+    await forEachSubdirJsonl(runsDir, "events.jsonl", events);
+    return [...new Map(events.map((event) => [event.id, event])).values()];
+}
+async function forEachSubdirJsonl(parentDir, filename, events) {
+    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);
+        }
+    }
+    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();
+        if (!trimmed)
+            continue;
+        const event = parseWorkerEventLine(trimmed);
+        if (event)
+            events.push(event);
+    }
+}
+async function loadLedgerRuns(repoRoot) {
+    const runs = [];
+    const raw = await safeReadText(path.join(repoRoot, ".task-pool", "runs", "runs.jsonl"));
+    if (!raw)
+        return runs;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parsed = safeParseJson(trimmed);
+        if (!parsed)
+            continue;
+        const taskId = readString(parsed, "taskId");
+        const batchRunId = readString(parsed, "batchRunId");
+        const workerRunId = readString(parsed, "workerRunId");
+        const status = readString(parsed, "status");
+        if (!taskId || !batchRunId || !workerRunId || !status)
+            continue;
+        const failure = readObject(parsed, "failure");
+        const failureArtifacts = readObject(parsed, "failureArtifacts");
+        runs.push({
+            batchRunId,
+            workerRunId,
+            taskId,
+            featureId: readString(parsed, "featureId"),
+            status,
+            harnessTaskId: readString(parsed, "harnessTaskId"),
+            runRecordPath: readString(parsed, "runRecordPath"),
+            dagPath: readString(parsed, "dagPath"),
+            recordedAt: readString(parsed, "recordedAt"),
+            failureCategory: failure ? readString(failure, "category") : undefined,
+            recommendedFollowUp: failure ? readString(failure, "recommendedFollowUpKind") : undefined,
+            failureArtifacts: failureArtifacts
+                ? {
+                    reportMarkdown: readString(failureArtifacts, "reportMarkdownArtifactPath"),
+                    doctorMarkdown: readString(failureArtifacts, "doctorMarkdownArtifactPath"),
+                    closeoutDraft: readString(failureArtifacts, "closeoutDraftPath"),
+                }
+                : undefined,
+        });
+    }
+    return runs;
+}
+async function loadLedgerBatches(repoRoot) {
+    const batches = [];
+    const runsDir = path.join(repoRoot, ".task-pool", "runs");
+    try {
+        const entries = await readdir(runsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name === "runs.jsonl")
+                continue;
+            const batchRunId = entry.name.replace(/\.json$/, "");
+            const parsed = await safeReadJson(path.join(runsDir, entry.name));
+            if (!parsed)
+                continue;
+            const summaryObj = readObject(parsed, "summary");
+            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,
+                tasks: [],
+                batchRunPath: path.join(runsDir, entry.name),
+            });
+        }
+    }
+    catch {
+        // skip
+    }
+    return batches;
+}
+async function loadStateRecords(repoRoot) {
+    const states = [];
+    const stateDir = path.join(repoRoot, ".task-pool", "state");
+    try {
+        const entries = await readdir(stateDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".json"))
+                continue;
+            const parsed = await safeReadJson(path.join(stateDir, entry.name));
+            if (!parsed)
+                continue;
+            const taskId = readString(parsed, "taskId") ?? entry.name.replace(/\.json$/, "");
+            const status = readString(parsed, "status");
+            if (!status)
+                continue;
+            const failure = readObject(parsed, "failure");
+            states.push({
+                taskId,
+                status,
+                workerRunId: readString(parsed, "workerRunId"),
+                lastRunRecordPath: readString(parsed, "lastRunRecordPath"),
+                failureCategory: failure ? readString(failure, "category") : undefined,
+                recommendedFollowUp: failure ? readString(failure, "recommendedFollowUpKind") : undefined,
+            });
+        }
+    }
+    catch {
+        // skip
+    }
+    return states;
+}
+async function loadFailureHandoffs(repoRoot) {
+    const handoffs = [];
+    const handoffDir = path.join(repoRoot, ".task-pool", "failure-handoffs");
+    try {
+        const entries = await readdir(handoffDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const match = /^(.+)-failure-closeout-draft\.md$/.exec(entry.name);
+            if (!match)
+                continue;
+            handoffs.push({
+                workerRunId: match[1],
+                closeoutDraftPath: path.join(handoffDir, entry.name),
+            });
+        }
+    }
+    catch {
+        // skip
+    }
+    return handoffs;
+}
+async function loadDagRuns(repoRoot) {
+    const byId = new Map();
+    const statePaths = await findStateJsonFiles(path.join(repoRoot, ".harness", "dag-runs"));
+    for (const statePath of statePaths) {
+        const summary = parseDagStateFile(statePath);
+        if (summary)
+            byId.set(summary.dagRunId, mergeDagRun(byId.get(summary.dagRunId), summary));
+    }
+    const dagEventRuns = await loadDagEventFiles(repoRoot);
+    for (const eventRun of dagEventRuns) {
+        const existing = byId.get(eventRun.dagRunId);
+        byId.set(eventRun.dagRunId, mergeDagRun(existing, eventRun));
+    }
+    return [...byId.values()].sort((a, b) => a.dagRunId.localeCompare(b.dagRunId));
+}
+function mergeDagRun(existing, incoming) {
+    if (!existing)
+        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 durationMs = incoming.durationMs ??
+        existing.durationMs ??
+        computeDurationMs(startedAt, finishedAt);
+    return {
+        dagRunId: incoming.dagRunId,
+        status: incoming.status ?? existing.status,
+        title: incoming.title ?? existing.title,
+        startedAt,
+        finishedAt,
+        ...(durationMs !== undefined ? { durationMs } : {}),
+        ...(ranks && ranks.length > 0 ? { ranks } : {}),
+        nodes: mergeDagNodes(existing.nodes, incoming.nodes),
+        ...(incoming.dagPath ?? existing.dagPath ? { dagPath: incoming.dagPath ?? existing.dagPath } : {}),
+    };
+}
+function mergeDagNodes(existing, incoming) {
+    const byId = new Map();
+    for (const node of existing) {
+        byId.set(node.nodeId, node);
+    }
+    for (const node of incoming) {
+        const prev = byId.get(node.nodeId);
+        byId.set(node.nodeId, mergeDagNode(prev, node));
+    }
+    return [...byId.values()].sort((a, b) => a.nodeId.localeCompare(b.nodeId));
+}
+function mergeDagNode(existing, incoming) {
+    if (!existing)
+        return incoming;
+    return {
+        nodeId: incoming.nodeId,
+        rank: incoming.rank ?? existing.rank,
+        executor: incoming.executor ?? existing.executor,
+        model: incoming.model ?? existing.model,
+        status: incoming.status ?? existing.status,
+        label: incoming.label ?? existing.label,
+        durationMs: incoming.durationMs ?? existing.durationMs,
+        startedAt: incoming.startedAt ?? existing.startedAt,
+        finishedAt: incoming.finishedAt ?? existing.finishedAt,
+        outputPreview: incoming.outputPreview ?? existing.outputPreview,
+        errorPreview: incoming.errorPreview ?? existing.errorPreview,
+    };
+}
+function computeDurationMs(startedAt, finishedAt) {
+    if (!startedAt || !finishedAt)
+        return undefined;
+    const startMs = Date.parse(startedAt);
+    const endMs = Date.parse(finishedAt);
+    if (Number.isNaN(startMs) || Number.isNaN(endMs))
+        return undefined;
+    return Math.max(0, endMs - startMs);
+}
+function isFailedNodeStatus(status) {
+    if (!status)
+        return false;
+    const normalized = status.toLowerCase();
+    return normalized === "error" || normalized === "failed" || normalized === "partial_failed";
+}
+function nodeOutputPreview(node) {
+    const stdout = readString(node, "stdout") ?? readString(node, "assistantText");
+    if (!stdout)
+        return undefined;
+    return truncateUtf8Preview(stdout);
+}
+function nodeErrorPreview(node, status) {
+    if (!isFailedNodeStatus(status))
+        return undefined;
+    const stderr = readString(node, "stderr");
+    if (!stderr)
+        return undefined;
+    return truncateUtf8Preview(stderr);
+}
+async function loadDagEventFiles(repoRoot) {
+    const runsDir = path.join(repoRoot, ".task-pool", "observability", "runs");
+    let entries;
+    try {
+        entries = await readdir(runsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const byId = new Map();
+    const runStatus = new Map();
+    const runTitle = new Map();
+    const runStartedAt = new Map();
+    const runFinishedAt = new Map();
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const eventsPath = path.join(runsDir, entry.name, "dag-events.jsonl");
+        const raw = await safeReadText(eventsPath);
+        if (!raw)
+            continue;
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parsed = safeParseJson(trimmed);
+            if (!parsed)
+                continue;
+            const type = readString(parsed, "type");
+            if (!type || !type.startsWith("dag."))
+                continue;
+            const dagRunId = readString(parsed, "dagRunId") ?? entry.name;
+            const nodeId = readString(parsed, "nodeId");
+            if (type === "dag.run.started") {
+                runStatus.set(dagRunId, "running");
+                const label = readString(parsed, "label");
+                if (label)
+                    runTitle.set(dagRunId, label);
+                const at = readString(parsed, "at");
+                if (at)
+                    runStartedAt.set(dagRunId, at);
+            }
+            else if (type === "dag.run.finished") {
+                runStatus.set(dagRunId, readString(parsed, "status") ?? "completed");
+                const at = readString(parsed, "at");
+                if (at)
+                    runFinishedAt.set(dagRunId, at);
+            }
+            else if (type.startsWith("dag.node.") && nodeId) {
+                const nodeMap = byId.get(dagRunId) ?? new Map();
+                const prev = nodeMap.get(nodeId) ?? { nodeId };
+                const rank = readString(parsed, "rank");
+                const executor = readString(parsed, "executor");
+                const model = readString(parsed, "model");
+                const label = readString(parsed, "label");
+                const status = readString(parsed, "status");
+                const durationMs = readNumber(parsed, "durationMs");
+                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 } : {}),
+                });
+                byId.set(dagRunId, nodeMap);
+            }
+        }
+    }
+    const result = [];
+    for (const [dagRunId, nodeMap] of byId) {
+        const startedAt = runStartedAt.get(dagRunId);
+        const finishedAt = runFinishedAt.get(dagRunId);
+        const durationMs = computeDurationMs(startedAt, finishedAt);
+        result.push({
+            dagRunId,
+            ...(runStatus.get(dagRunId) ? { status: runStatus.get(dagRunId) } : {}),
+            ...(runTitle.get(dagRunId) ? { title: runTitle.get(dagRunId) } : {}),
+            ...(startedAt ? { startedAt } : {}),
+            ...(finishedAt ? { finishedAt } : {}),
+            ...(durationMs !== undefined ? { durationMs } : {}),
+            nodes: [...nodeMap.values()].sort((a, b) => a.nodeId.localeCompare(b.nodeId)),
+        });
+    }
+    return result;
+}
+async function findStateJsonFiles(root) {
+    const results = [];
+    await walkForStateJson(root, results);
+    return results;
+}
+async function walkForStateJson(dir, results) {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walkForStateJson(fullPath, results);
+            }
+            else if (entry.isFile() && entry.name === "state.json") {
+                results.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // skip
+    }
+}
+function parseDagStateFile(statePath) {
+    try {
+        if (!existsSync(statePath))
+            return undefined;
+        const raw = readFileSync(statePath, "utf-8");
+        const parsed = safeParseJson(raw);
+        if (!parsed)
+            return undefined;
+        const runDir = path.dirname(statePath);
+        const dagRunId = readString(parsed, "runId") ?? path.basename(runDir);
+        const status = readString(parsed, "status");
+        const title = readString(parsed, "title");
+        const startedAt = readString(parsed, "startedAt");
+        const finishedAt = readString(parsed, "finishedAt");
+        const durationMs = computeDurationMs(startedAt, finishedAt);
+        const ranks = readStringMatrix(parsed, "ranks");
+        const rankByNode = buildRankIndex(ranks);
+        const nodes = parseDagNodes(parsed, rankByNode);
+        return {
+            dagRunId,
+            status,
+            ...(title ? { title } : {}),
+            ...(startedAt ? { startedAt } : {}),
+            ...(finishedAt ? { finishedAt } : {}),
+            ...(durationMs !== undefined ? { durationMs } : {}),
+            ...(ranks.length > 0 ? { ranks } : {}),
+            nodes,
+            dagPath: runDir,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildRankIndex(ranks) {
+    const index = new Map();
+    for (let i = 0; i < ranks.length; i++) {
+        const rank = ranks[i];
+        if (!Array.isArray(rank))
+            continue;
+        const rankLabel = String(i);
+        for (const nodeId of rank) {
+            if (typeof nodeId === "string") {
+                index.set(nodeId, rankLabel);
+            }
+        }
+    }
+    return index;
+}
+function parseDagNodes(parsed, rankByNode) {
+    const nodes = [];
+    const nodesValue = parsed.nodes;
+    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;
+            const node = nodeVal;
+            const resolvedId = readString(node, "id") ?? nodeId;
+            const nodeStatus = readString(node, "status");
+            const outputPreview = nodeOutputPreview(node);
+            const errorPreview = nodeErrorPreview(node, nodeStatus);
+            nodes.push({
+                nodeId: resolvedId,
+                rank: rankByNode.get(nodeId) ?? rankByNode.get(resolvedId),
+                executor: readString(node, "executor"),
+                model: readString(node, "model"),
+                status: nodeStatus,
+                label: readString(node, "label") ?? readString(node, "title") ?? nodeId,
+                durationMs: readNumber(node, "durationMs"),
+                startedAt: readString(node, "startedAt"),
+                finishedAt: readString(node, "finishedAt"),
+                ...(outputPreview ? { outputPreview } : {}),
+                ...(errorPreview ? { errorPreview } : {}),
+            });
+        }
+        return nodes.sort((a, b) => a.nodeId.localeCompare(b.nodeId));
+    }
+    const nodeArray = readObjectArray(parsed, "nodes");
+    for (const node of nodeArray) {
+        const nodeId = readString(node, "id") ?? readString(node, "nodeId") ?? "unknown";
+        const nodeStatus = readString(node, "status");
+        const outputPreview = nodeOutputPreview(node);
+        const errorPreview = nodeErrorPreview(node, nodeStatus);
+        nodes.push({
+            nodeId,
+            rank: rankByNode.get(nodeId),
+            executor: readString(node, "executor"),
+            model: readString(node, "model"),
+            status: nodeStatus,
+            label: readString(node, "label") ?? readString(node, "title") ?? nodeId,
+            durationMs: readNumber(node, "durationMs"),
+            startedAt: readString(node, "startedAt"),
+            finishedAt: readString(node, "finishedAt"),
+            ...(outputPreview ? { outputPreview } : {}),
+            ...(errorPreview ? { errorPreview } : {}),
+        });
+    }
+    return nodes.sort((a, b) => a.nodeId.localeCompare(b.nodeId));
+}
+async function safeReadText(filePath) {
+    try {
+        return await readFile(filePath, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function safeReadJson(filePath) {
+    const raw = await safeReadText(filePath);
+    if (!raw)
+        return undefined;
+    const parsed = safeParseJson(raw);
+    if (!parsed || Array.isArray(parsed))
+        return undefined;
+    return parsed;
+}
+function safeParseJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readObject(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const child = value[key];
+    if (!child || typeof child !== "object" || Array.isArray(child))
+        return undefined;
+    return child;
+}
+function readObjectArray(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
+}
+function readString(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}
+function readNumber(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const child = value[key];
+    return typeof child === "number" && Number.isFinite(child) ? child : undefined;
+}
+function readStringMatrix(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child
+        .filter((rank) => Array.isArray(rank))
+        .map((rank) => rank.filter((id) => typeof id === "string"));
+}