@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,2499 @@
+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";
+import { readBoundedJsonlTail } from "./event-history.js";
+import { getTaskPoolRoot, listLegacyStateFiles, listTaskPoolStates, } from "../pool/run-store.js";
+import { listRunOwners } from "../pool/run-owner-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";
+import { frontendLintAssessmentArtifactSchema } from "../../workflows/dag/frontend-lint-baseline.js";
+/** Internal map key: featureId + NUL + taskId (stable, non-printable delimiter). */
+export function taskIdentityKey(featureId, taskId) {
+    return `${featureId}\0${taskId}`;
+}
+export function compareTaskIdentity(a, b) {
+    const fa = a.featureId ?? "";
+    const fb = b.featureId ?? "";
+    const byFeature = fa.localeCompare(fb);
+    if (byFeature !== 0)
+        return byFeature;
+    return a.taskId.localeCompare(b.taskId);
+}
+export function findTasksByTaskId(tasks, taskId) {
+    return tasks.filter((task) => task.taskId === taskId);
+}
+export function resolveLegacyTask(tasks, taskId) {
+    const matches = findTasksByTaskId(tasks, taskId);
+    const candidates = matches.map((task) => ({
+        featureId: task.featureId,
+        taskId: task.taskId,
+        status: task.status,
+        workerRunId: task.workerRunId,
+    }));
+    if (matches.length === 0) {
+        return { kind: "missing", candidates: [] };
+    }
+    if (matches.length === 1) {
+        return { kind: "unique", task: matches[0], candidates };
+    }
+    return { kind: "ambiguous", candidates };
+}
+export const TASK_RUN_HISTORY_DEFAULT_LIMIT = 20;
+export const TASK_RUN_HISTORY_MAX_LIMIT = 100;
+/** Default / allowed page sizes for GET /api/dag-runs history list. */
+export const DAG_RUN_HISTORY_DEFAULT_PAGE = 1;
+export const DAG_RUN_HISTORY_DEFAULT_PAGE_SIZE = 20;
+export const DAG_RUN_HISTORY_MAX_PAGE_SIZE = 100;
+export const DAG_RUN_HISTORY_ALLOWED_PAGE_SIZES = [20, 50, 100];
+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 taskPoolPresent = existsSync(getTaskPoolRoot(repoRoot));
+        const [eventsLoad, ledgerLoad, ledgerBatches, statesLoad, handoffs, dagRuns, owners,] = await Promise.all([
+            loadObservabilityEvents(repoRoot),
+            loadLedgerRuns(repoRoot),
+            loadLedgerBatches(repoRoot),
+            loadStateRecords(repoRoot),
+            loadFailureHandoffs(repoRoot),
+            loadDagRuns(repoRoot, now()),
+            listRunOwners(repoRoot).catch(() => []),
+        ]);
+        const events = eventsLoad.events;
+        const ledgerRuns = ledgerLoad.runs;
+        const identityWarnings = [];
+        const taskMap = new Map();
+        // Ledger first so featureId-bearing rows seed composite identity before states/events.
+        for (const run of ledgerRuns) {
+            mergeLedgerRun(taskMap, run, identityWarnings);
+        }
+        for (const state of statesLoad.states) {
+            mergeStateRecord(taskMap, state, identityWarnings);
+        }
+        // Attach uniquely-resolvable legacy flat states after owned rows exist.
+        for (const state of statesLoad.legacyCandidates) {
+            mergeLegacyStateRecord(taskMap, state, identityWarnings);
+        }
+        const workerRunFeatureIndex = buildWorkerRunFeatureIndex(ledgerRuns, taskMap, owners);
+        mergeEvents(taskMap, events, workerRunFeatureIndex, identityWarnings);
+        mergeHandoffs(taskMap, handoffs);
+        applyStaleDetection(taskMap, now(), staleThresholdMs, quietThresholdMs);
+        const historicalRunMap = buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex, identityWarnings);
+        mergeHandoffs(historicalRunMap, handoffs);
+        applyStaleDetection(historicalRunMap, now(), staleThresholdMs, quietThresholdMs);
+        const tasks = [...taskMap.values()]
+            .map(toPublicTaskSummary)
+            .map((task) => normalizeTaskArtifactRefs(task, repoRoot))
+            .sort(compareTaskIdentity);
+        const batches = buildBatches(ledgerBatches, events, historicalRunMap).map((batch) => ({
+            ...batch,
+            tasks: batch.tasks.map((task) => normalizeTaskArtifactRefs(task, repoRoot)),
+        }));
+        const health = computeHealth(batches, tasks, dagRuns);
+        const featureLoad = await loadFeatureDecisionModels(repoRoot);
+        const projectionWarnings = [
+            ...(eventsLoad.warnings ?? []),
+            ...(ledgerLoad.warnings ?? []),
+            ...(statesLoad.warnings ?? []),
+            ...identityWarnings,
+            ...(featureLoad.projectionWarnings ?? []),
+        ];
+        return {
+            schemaVersion: 1,
+            generatedAt: now().toISOString(),
+            repoRoot,
+            batches,
+            tasks,
+            dagRuns,
+            features: featureLoad.features,
+            taskPool: { present: taskPoolPresent },
+            projectionWarnings,
+            health,
+        };
+    }
+    catch (error) {
+        const now = options.now ?? (() => new Date());
+        const safeNow = () => {
+            try {
+                return now();
+            }
+            catch {
+                return new Date();
+            }
+        };
+        let repoRoot;
+        try {
+            repoRoot = path.resolve(options.repoRoot);
+        }
+        catch {
+            repoRoot = String(options.repoRoot ?? "");
+        }
+        const snapshot = emptySnapshot(repoRoot, safeNow);
+        snapshot.projectionError = sanitizeProjectionError(error);
+        return snapshot;
+    }
+}
+/**
+ * Bounded Task run history from Task Pool ledger facts (newest first).
+ * Filtered by composite `{featureId, taskId}`.
+ * `before` is an exclusive upper bound on the sort key (`recordedAt` or empty).
+ */
+export async function listTaskRunHistory(repoRoot, featureId, 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 workerRunFeatureIndex = buildWorkerRunFeatureIndex(ledgerRuns);
+    const historical = buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex);
+    const items = [];
+    for (const run of ledgerRuns) {
+        if (run.taskId !== taskId)
+            continue;
+        if ((run.featureId ?? "") !== featureId)
+            continue;
+        const enriched = historical.get(run.workerRunId);
+        items.push({
+            workerRunId: run.workerRunId,
+            taskId: run.taskId,
+            featureId: run.featureId ?? featureId,
+            workflow: enriched?.workflow ?? run.workflow,
+            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 {
+        featureId,
+        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);
+}
+export function clampDagRunHistoryPageSize(pageSize) {
+    if (pageSize === undefined || !Number.isFinite(pageSize) || pageSize <= 0) {
+        return DAG_RUN_HISTORY_DEFAULT_PAGE_SIZE;
+    }
+    const floored = Math.floor(pageSize);
+    if (DAG_RUN_HISTORY_ALLOWED_PAGE_SIZES.includes(floored)) {
+        return floored;
+    }
+    // Nearest allowed size, prefer smaller when equidistant, then clamp to max.
+    let best = DAG_RUN_HISTORY_DEFAULT_PAGE_SIZE;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (const allowed of DAG_RUN_HISTORY_ALLOWED_PAGE_SIZES) {
+        const dist = Math.abs(allowed - floored);
+        if (dist < bestDist || (dist === bestDist && allowed < best)) {
+            best = allowed;
+            bestDist = dist;
+        }
+    }
+    return Math.min(best, DAG_RUN_HISTORY_MAX_PAGE_SIZE);
+}
+export function clampDagRunHistoryPage(page, totalPages) {
+    const safeTotal = Math.max(1, Math.floor(totalPages) || 1);
+    if (page === undefined || !Number.isFinite(page) || page <= 0) {
+        return DAG_RUN_HISTORY_DEFAULT_PAGE;
+    }
+    return Math.min(Math.floor(page), safeTotal);
+}
+/**
+ * Formal DAG history membership (AC-004):
+ * exclude executionMode or lifecycle dry-run/init-only;
+ * keep missing executionMode when lifecycle is not a non-execution mode.
+ */
+export function isFormalDagRunHistoryCandidate(dag) {
+    const executionMode = (dag.executionMode ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(executionMode))
+        return false;
+    const lifecycle = (dag.lifecycle ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(lifecycle))
+        return false;
+    return true;
+}
+function dagRunHistorySortKey(dag) {
+    return `${dag.startedAt ?? dag.finishedAt ?? ""}\0${dag.dagRunId}`;
+}
+function projectDagRunHistoryProgress(dag) {
+    const nodes = dag.nodes ?? [];
+    let finished = 0;
+    for (const node of nodes) {
+        const status = (node.status ?? "").toLowerCase();
+        if (status === "finished" ||
+            status === "completed" ||
+            status === "succeeded" ||
+            status === "done" ||
+            status === "error" ||
+            status === "failed" ||
+            status === "skipped" ||
+            status === "partial_failed") {
+            finished += 1;
+        }
+    }
+    return { finished, total: nodes.length };
+}
+function toDagRunHistoryItem(dag) {
+    return {
+        dagRunId: dag.dagRunId,
+        ...(dag.title ? { title: dag.title } : {}),
+        ...(dag.status ? { status: dag.status } : {}),
+        ...(dag.effectiveStatus ? { effectiveStatus: dag.effectiveStatus } : {}),
+        ...(dag.lifecycle ? { lifecycle: dag.lifecycle } : {}),
+        ...(dag.executionMode ? { executionMode: dag.executionMode } : {}),
+        ...(dag.startedAt ? { startedAt: dag.startedAt } : {}),
+        ...(dag.finishedAt ? { finishedAt: dag.finishedAt } : {}),
+        ...(dag.durationMs !== undefined ? { durationMs: dag.durationMs } : {}),
+        progress: projectDagRunHistoryProgress(dag),
+    };
+}
+/**
+ * Paginated lightweight formal DAG run history from an in-memory GlobalSnapshot.
+ * Filters dry-run/init-only; sorts newest first; never embeds nodes/edges/previews.
+ */
+export function listDagRunHistoryFromSnapshot(snapshot, options = {}) {
+    const pageSize = clampDagRunHistoryPageSize(options.pageSize);
+    const formal = (snapshot.dagRuns ?? [])
+        .filter(isFormalDagRunHistoryCandidate)
+        .slice()
+        .sort((a, b) => dagRunHistorySortKey(b).localeCompare(dagRunHistorySortKey(a)));
+    const total = formal.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize) || 1);
+    const page = clampDagRunHistoryPage(options.page, totalPages);
+    const start = (page - 1) * pageSize;
+    const runs = formal.slice(start, start + pageSize).map(toDagRunHistoryItem);
+    return {
+        schemaVersion: 1,
+        generatedAt: snapshot.generatedAt,
+        page,
+        pageSize,
+        total,
+        totalPages,
+        runs,
+    };
+}
+function emptySnapshot(repoRoot, now) {
+    let taskPoolPresent = false;
+    try {
+        taskPoolPresent = existsSync(getTaskPoolRoot(repoRoot));
+    }
+    catch {
+        taskPoolPresent = false;
+    }
+    return {
+        schemaVersion: 1,
+        generatedAt: now().toISOString(),
+        repoRoot,
+        batches: [],
+        tasks: [],
+        dagRuns: [],
+        taskPool: { present: taskPoolPresent },
+        health: {
+            activeBatches: 0,
+            activeTasks: 0,
+            quietCount: 0,
+            staleCount: 0,
+            timeoutRiskCount: 0,
+            failuresCount: 0,
+            dag: {
+                activeRuns: 0,
+                runningNodes: 0,
+                pendingNodes: 0,
+                pausedRuns: 0,
+                failedRuns: 0,
+                staleRuns: 0,
+                interruptedRuns: 0,
+                inconsistentRuns: 0,
+                attentionRuns: 0,
+            },
+            worker: {
+                activeTasks: 0,
+                activeBatches: 0,
+                quietCount: 0,
+                staleCount: 0,
+                timeoutRiskCount: 0,
+                failuresCount: 0,
+            },
+        },
+    };
+}
+function toPublicTaskSummary(task) {
+    const { timeoutMs: _to, commandStartedAt: _cs, ...rest } = task;
+    return rest;
+}
+function isLivePoolStatus(status) {
+    return (status === "Running" ||
+        status === "Queued" ||
+        status === "AgentCompleted" ||
+        status === "VerificationRunning" ||
+        status === "HumanReview" ||
+        status === "Ready" ||
+        status === "Draft");
+}
+function mergeStateRecord(taskMap, state, warnings) {
+    const featureId = state.featureId?.trim();
+    if (!featureId) {
+        warnings?.push(`state for task ${state.taskId} missing featureId; excluded from composite projection`);
+        return;
+    }
+    const key = taskIdentityKey(featureId, state.taskId);
+    const existing = taskMap.get(key) ?? {
+        taskId: state.taskId,
+        featureId,
+        status: "unknown",
+    };
+    const live = isLivePoolStatus(state.status);
+    const mapped = mapStateStatus(state.status);
+    taskMap.set(key, {
+        ...existing,
+        featureId,
+        // Live Task Pool state is the current attempt truth; do not keep a stale
+        // terminal ledger workerRunId/status over an active Running attempt.
+        status: live
+            ? mapped
+            : existing.status !== "unknown"
+                ? existing.status
+                : mapped,
+        workerRunId: state.workerRunId ?? existing.workerRunId,
+        updatedAt: state.updatedAt ?? existing.updatedAt,
+        artifactRefs: mergeArtifactRefs(existing.artifactRefs, {
+            runRecordPath: state.lastRunRecordPath,
+        }),
+        failureCategory: existing.failureCategory ?? state.failureCategory,
+        recommendedFollowUp: existing.recommendedFollowUp ?? state.recommendedFollowUp,
+    });
+}
+/**
+ * Legacy flat states/<taskId>.json: only merge when the taskId already maps to
+ * exactly one composite row in the snapshot (unique ownership). Otherwise warn+exclude.
+ */
+function mergeLegacyStateRecord(taskMap, state, warnings) {
+    const owners = [...taskMap.values()].filter((task) => task.taskId === state.taskId && Boolean(task.featureId));
+    if (owners.length === 1) {
+        const owner = owners[0];
+        mergeStateRecord(taskMap, { ...state, featureId: owner.featureId }, warnings);
+        warnings.push(`legacy flat state for task ${state.taskId} attached to unique feature ${owner.featureId}`);
+        return;
+    }
+    if (owners.length === 0) {
+        // No owned composite row yet: still surface as a warning and do not invent featureId.
+        warnings.push(`legacy flat state for task ${state.taskId} has no unique feature ownership; excluded from composite projection`);
+        return;
+    }
+    warnings.push(`legacy flat state for task ${state.taskId} is ambiguous across features; excluded from composite projection`);
+}
+function mergeLedgerRun(taskMap, run, warnings) {
+    const featureId = run.featureId?.trim();
+    if (!featureId) {
+        warnings?.push(`ledger run ${run.workerRunId} for task ${run.taskId} missing featureId; excluded from composite projection`);
+        return;
+    }
+    const key = taskIdentityKey(featureId, run.taskId);
+    const existing = taskMap.get(key) ?? {
+        taskId: run.taskId,
+        featureId,
+        status: "unknown",
+    };
+    const sameRun = existing.workerRunId === run.workerRunId;
+    const runArtifactRefs = {
+        runRecordPath: run.runRecordPath,
+        dagPath: run.dagPath,
+        ...run.failureArtifacts,
+        ...(run.outcomePath ? { outcome: run.outcomePath } : {}),
+    };
+    taskMap.set(key, {
+        ...(sameRun
+            ? existing
+            : {
+                taskId: run.taskId,
+                featureId,
+                status: "unknown",
+                harnessTaskId: existing.harnessTaskId,
+            }),
+        batchRunId: run.batchRunId,
+        featureId,
+        workflow: run.workflow ?? existing.workflow,
+        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),
+    });
+}
+/**
+ * Build workerRunId → featureId unique index from ledger + already-owned task rows + run owners.
+ * Ambiguous (0 or N) mappings are omitted so callers treat them as unowned.
+ */
+function buildWorkerRunFeatureIndex(ledgerRuns, taskMap, owners) {
+    const candidates = new Map();
+    const add = (workerRunId, featureId) => {
+        const wr = workerRunId?.trim();
+        const fid = featureId?.trim();
+        if (!wr || !fid)
+            return;
+        let set = candidates.get(wr);
+        if (!set) {
+            set = new Set();
+            candidates.set(wr, set);
+        }
+        set.add(fid);
+    };
+    for (const run of ledgerRuns) {
+        add(run.workerRunId, run.featureId);
+    }
+    if (taskMap) {
+        for (const task of taskMap.values()) {
+            add(task.workerRunId, task.featureId);
+        }
+    }
+    if (owners) {
+        for (const owner of owners) {
+            add(owner.workerRunId, owner.featureId);
+        }
+    }
+    const unique = new Map();
+    for (const [workerRunId, features] of candidates) {
+        if (features.size === 1) {
+            unique.set(workerRunId, [...features][0]);
+        }
+    }
+    return unique;
+}
+function mergeEvents(taskMap, events, workerRunFeatureIndex, warnings) {
+    const sorted = [...events].sort((a, b) => a.at.localeCompare(b.at));
+    const unownedKeys = new Set();
+    for (const event of sorted) {
+        if (event.taskId) {
+            applyTaskEvent(taskMap, event, workerRunFeatureIndex, warnings, unownedKeys);
+        }
+    }
+}
+function applyTaskEvent(taskMap, event, workerRunFeatureIndex, warnings, unownedKeys) {
+    const taskId = event.taskId;
+    const featureId = resolveEventFeatureId(event, taskMap, workerRunFeatureIndex, warnings, unownedKeys);
+    if (!featureId)
+        return;
+    const key = taskIdentityKey(featureId, taskId);
+    const existing = taskMap.get(key) ?? {
+        taskId,
+        featureId,
+        status: "unknown",
+    };
+    taskMap.set(key, applyEventToSummary(existing, event));
+}
+function resolveEventFeatureId(event, taskMap, workerRunFeatureIndex, warnings, unownedKeys) {
+    const taskId = event.taskId;
+    if (!taskId)
+        return undefined;
+    const eventFeatureId = event.featureId?.trim();
+    if (event.workerRunId) {
+        const fromIndex = workerRunFeatureIndex.get(event.workerRunId);
+        if (eventFeatureId && fromIndex && eventFeatureId !== fromIndex) {
+            pushOwnershipWarning(warnings, unownedKeys, `ownership conflict for workerRunId ${event.workerRunId}: event featureId ${eventFeatureId} vs index ${fromIndex}`, event.workerRunId);
+            return undefined;
+        }
+        if (eventFeatureId)
+            return eventFeatureId;
+        if (fromIndex)
+            return fromIndex;
+        const byWorkerRun = [...taskMap.values()].filter((task) => task.workerRunId === event.workerRunId && Boolean(task.featureId));
+        if (byWorkerRun.length === 1)
+            return byWorkerRun[0].featureId;
+    }
+    else if (eventFeatureId) {
+        return eventFeatureId;
+    }
+    const byTaskId = [...taskMap.values()].filter((task) => task.taskId === taskId && Boolean(task.featureId));
+    if (byTaskId.length === 1)
+        return byTaskId[0].featureId;
+    pushOwnershipWarning(warnings, unownedKeys, `unowned event ${event.type} for task ${taskId}` +
+        (event.workerRunId ? ` workerRunId ${event.workerRunId}` : "") +
+        ` cannot uniquely resolve featureId; excluded from task projection`, event.workerRunId ?? `${taskId}:${event.type}`);
+    return undefined;
+}
+function pushOwnershipWarning(warnings, unownedKeys, message, key) {
+    if (!warnings)
+        return;
+    if (unownedKeys) {
+        if (unownedKeys.has(key))
+            return;
+        unownedKeys.add(key);
+    }
+    warnings.push(message);
+}
+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, workerRunFeatureIndex = new Map(), warnings) {
+    const runMap = new Map();
+    const unownedKeys = new Set();
+    for (const run of ledgerRuns) {
+        // History map is keyed by workerRunId (run-scoped); featureId still required when present.
+        runMap.set(run.workerRunId, {
+            taskId: run.taskId,
+            batchRunId: run.batchRunId,
+            featureId: run.featureId,
+            workflow: run.workflow,
+            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,
+                ...(run.outcomePath ? { outcome: run.outcomePath } : {}),
+            }),
+        });
+    }
+    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);
+        if (existing) {
+            if (event.featureId?.trim() &&
+                existing.featureId &&
+                event.featureId.trim() !== existing.featureId) {
+                pushOwnershipWarning(warnings, unownedKeys, `ownership conflict for workerRunId ${event.workerRunId}: event featureId ${event.featureId} vs historical ${existing.featureId}`, event.workerRunId);
+                continue;
+            }
+            runMap.set(event.workerRunId, applyEventToSummary(existing, event));
+            continue;
+        }
+        const featureId = event.featureId?.trim() || workerRunFeatureIndex.get(event.workerRunId);
+        if (!featureId) {
+            pushOwnershipWarning(warnings, unownedKeys, `unowned historical event ${event.type} for task ${event.taskId} workerRunId ${event.workerRunId} cannot uniquely resolve featureId; excluded from historical run map`, event.workerRunId);
+            continue;
+        }
+        runMap.set(event.workerRunId, applyEventToSummary({
+            taskId: event.taskId,
+            featureId,
+            workerRunId: event.workerRunId,
+            status: "unknown",
+        }, 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(compareTaskIdentity);
+        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, 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,
+        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,
+    };
+    const dag = computeDagHealth(dagRuns);
+    return {
+        // Flat aliases retained for back-compat; mirror worker.* plus activeBatches.
+        activeBatches: worker.activeBatches,
+        activeTasks: worker.activeTasks,
+        quietCount: worker.quietCount,
+        staleCount: worker.staleCount,
+        timeoutRiskCount: worker.timeoutRiskCount,
+        failuresCount: worker.failuresCount,
+        dag,
+        worker,
+    };
+}
+const ACTIVE_EFFECTIVE_STATUSES = new Set([
+    "running",
+    "running-quiet",
+    "running-suspected-stall",
+    "needs-attention",
+    "remote-unknown",
+    "pending",
+    "paused",
+]);
+const TERMINAL_RUN_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+    "superseded",
+    "abandoned",
+]);
+const NON_EXECUTION_MODES = new Set(["dry-run", "init-only"]);
+const SHELL_NODE_STATUSES = new Set(["pending", "queued"]);
+function hasDagExecutionEvidence(dag) {
+    const status = (dag.status ?? "").toLowerCase();
+    if (status === "running" || status === "started" || status === "paused") {
+        return true;
+    }
+    return (dag.nodes ?? []).some((node) => {
+        const nodeStatus = (node.status ?? "").toLowerCase();
+        return nodeStatus.length > 0 && !SHELL_NODE_STATUSES.has(nodeStatus);
+    });
+}
+/**
+ * Unified overview-active matrix (isOverviewActive). Shared contract with
+ * Observe UI `isDagRunActive` — default total view only shows real execution.
+ */
+function isDagRunActiveForHealth(dag) {
+    const executionMode = (dag.executionMode ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(executionMode))
+        return false;
+    const lifecycle = (dag.lifecycle ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(lifecycle))
+        return false;
+    if (lifecycle === "completed")
+        return false;
+    if (dag.effectiveStatus && TERMINAL_RUN_STATUSES.has(dag.effectiveStatus)) {
+        return false;
+    }
+    // Real execute pause remains overview-visible (AC-003).
+    if (lifecycle === "paused" || dag.effectiveStatus === "paused") {
+        return true;
+    }
+    if (["orphaned", "stale"].includes((dag.liveness ?? "").toLowerCase())) {
+        return false;
+    }
+    if (dag.effectiveStatus &&
+        ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)) {
+        // Legacy active+pending shells without execution evidence are not active.
+        if (!executionMode &&
+            dag.effectiveStatus === "pending" &&
+            !hasDagExecutionEvidence(dag)) {
+            return false;
+        }
+        // execute-mode pending (or any non-legacy execute) stays visible.
+        return true;
+    }
+    // Only "unknown" (and absent) means liveness evidence is insufficient;
+    // it must NOT override raw lifecycle/status/node facts. Every other concrete
+    // effectiveStatus is authoritative-non-active and short-circuits to false.
+    if (dag.effectiveStatus && dag.effectiveStatus !== "unknown")
+        return false;
+    const status = (dag.status ?? "").toLowerCase();
+    if (TERMINAL_RUN_STATUSES.has(status))
+        return false;
+    if (executionMode === "execute") {
+        if (["running", "pending", "started", "paused"].includes(status)) {
+            return true;
+        }
+        return (dag.nodes ?? []).some((node) => isNodeStatusActive(node.status));
+    }
+    // Historical runs without executionMode: require real execution evidence.
+    if (status === "running" || status === "started")
+        return true;
+    if (status === "pending" || status === "") {
+        return hasDagExecutionEvidence(dag);
+    }
+    return (dag.nodes ?? []).some((node) => isNodeStatusActive(node.status));
+}
+function isNodeStatusActive(status) {
+    const normalized = (status ?? "").toLowerCase();
+    if ([
+        "finished",
+        "completed",
+        "succeeded",
+        "done",
+        "error",
+        "failed",
+        "skipped",
+        "partial_failed",
+    ].includes(normalized)) {
+        return false;
+    }
+    // pending/queued alone are not enough for overview active without mode/evidence.
+    if (SHELL_NODE_STATUSES.has(normalized))
+        return false;
+    return true;
+}
+function computeDagHealth(dagRuns) {
+    let activeRuns = 0;
+    let runningNodes = 0;
+    let pendingNodes = 0;
+    let pausedRuns = 0;
+    let failedRuns = 0;
+    let staleRuns = 0;
+    let interruptedRuns = 0;
+    let inconsistentRuns = 0;
+    let attentionRuns = 0;
+    for (const dag of dagRuns) {
+        const active = isDagRunActiveForHealth(dag);
+        if (active) {
+            activeRuns++;
+            for (const node of dag.nodes ?? []) {
+                const status = (node.status ?? "").toLowerCase();
+                if (status === "running" || status === "started")
+                    runningNodes++;
+                if (status === "pending" || status === "queued")
+                    pendingNodes++;
+            }
+        }
+        const lifecycle = (dag.lifecycle ?? "").toLowerCase();
+        const liveness = (dag.liveness ?? "").toLowerCase();
+        if (lifecycle === "paused")
+            pausedRuns++;
+        if (dag.effectiveStatus === "failed")
+            failedRuns++;
+        if (liveness === "stale" ||
+            liveness === "orphaned" ||
+            liveness === "suspected-stall" ||
+            liveness === "needs-attention") {
+            staleRuns++;
+        }
+        if (dag.effectiveStatus === "interrupted")
+            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)) {
+            attentionRuns++;
+        }
+    }
+    return {
+        activeRuns,
+        runningNodes,
+        pendingNodes,
+        pausedRuns,
+        failedRuns,
+        staleRuns,
+        interruptedRuns,
+        inconsistentRuns,
+        attentionRuns,
+    };
+}
+/**
+ * Whitelist a short safe projection-failure message. Never expose stack frames,
+ * absolute paths, env values, or secrets. Mirrors the bare catch that previously
+ * silently returned a zero-shape snapshot.
+ */
+function sanitizeProjectionError(error) {
+    const fallback = "投影失败 (projection failed)";
+    const at = new Date().toISOString();
+    if (!error || typeof error !== "object") {
+        return { message: fallback, at };
+    }
+    let name;
+    let message;
+    try {
+        name =
+            typeof error.name === "string"
+                ? error.name
+                : undefined;
+        message =
+            typeof error.message === "string"
+                ? error.message
+                : undefined;
+    }
+    catch {
+        return { message: fallback, at };
+    }
+    const candidate = message ?? name;
+    if (!candidate) {
+        return { message: fallback, at };
+    }
+    // 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)) {
+        return { message: name ? `${name}: 投影失败` : fallback, at };
+    }
+    const trimmed = raw.trim().slice(0, 200);
+    return { message: trimmed || fallback, at };
+}
+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":
+        case "Ready":
+            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";
+    }
+}
+/** 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 appendJsonlEventsBounded(path.join(obsRoot, "events.jsonl"), events, warnings);
+    const batchesDir = path.join(obsRoot, "batches");
+    await forEachSubdirJsonl(batchesDir, "events.jsonl", events, warnings);
+    const runsDir = path.join(obsRoot, "runs");
+    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 };
+}
+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 appendJsonlEventsBounded(path.join(parentDir, entry.name, filename), events, warnings);
+        }
+    }
+    catch {
+        // skip missing dir
+    }
+}
+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) {
+            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 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);
+        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");
+        const retryOfWorkerRunId = readString(parsed, "retryOfWorkerRunId");
+        runs.push({
+            batchRunId,
+            workerRunId,
+            taskId,
+            featureId: readString(parsed, "featureId"),
+            workflow: readString(parsed, "workflow"),
+            outcomePath: readString(parsed, "outcomePath"),
+            status,
+            harnessTaskId: readString(parsed, "harnessTaskId"),
+            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,
+            failureArtifacts: failureArtifacts
+                ? {
+                    reportMarkdown: readString(failureArtifacts, "reportMarkdownArtifactPath"),
+                    doctorMarkdown: readString(failureArtifacts, "doctorMarkdownArtifactPath"),
+                    closeoutDraft: readString(failureArtifacts, "closeoutDraftPath"),
+                }
+                : undefined,
+        });
+    }
+    return { runs, warnings };
+}
+async function loadLedgerBatches(repoRoot) {
+    const batches = [];
+    const artifactsDir = path.join(getTaskPoolRoot(repoRoot), "artifacts");
+    try {
+        const entries = await readdir(artifactsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const batchRunId = entry.name;
+            const batchRunPath = path.join(artifactsDir, batchRunId, "batch-run.json");
+            const parsed = await safeReadJson(batchRunPath);
+            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,
+                tasks: [],
+                batchRunPath,
+            });
+        }
+    }
+    catch {
+        // skip
+    }
+    return batches;
+}
+async function loadStateRecords(repoRoot) {
+    const states = [];
+    const legacyCandidates = [];
+    const warnings = [];
+    // Primary path: v2 nested states via pool list API (read-only import).
+    try {
+        const v2 = await listTaskPoolStates(repoRoot);
+        for (const record of v2) {
+            if (!record.taskId || !record.status)
+                continue;
+            if (!record.featureId) {
+                warnings.push(`v2 state for task ${record.taskId} missing featureId; excluded from composite projection`);
+                continue;
+            }
+            states.push({
+                taskId: record.taskId,
+                featureId: record.featureId,
+                status: record.status,
+                workerRunId: record.workerRunId,
+                lastRunRecordPath: record.lastRunRecordPath,
+                updatedAt: record.updatedAt,
+                failureCategory: record.failure?.category,
+                recommendedFollowUp: record.failure?.recommendedFollowUpKind,
+            });
+        }
+    }
+    catch (error) {
+        warnings.push(`failed to load feature-scoped task pool states: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Compatibility: legacy flat states/<taskId>.json (warning + unique-only merge later).
+    try {
+        const legacyFiles = await listLegacyStateFiles(repoRoot);
+        for (const file of legacyFiles) {
+            const parsed = await safeReadJson(file.path);
+            if (!parsed) {
+                warnings.push(`legacy flat state file unreadable or corrupt: ${file.path}`);
+                continue;
+            }
+            const taskId = readString(parsed, "taskId") ?? file.taskId;
+            const status = readString(parsed, "status");
+            if (!taskId || !status) {
+                warnings.push(`legacy flat state missing taskId/status: ${file.path}`);
+                continue;
+            }
+            const failure = readObject(parsed, "failure");
+            const embeddedFeatureId = readString(parsed, "featureId");
+            if (embeddedFeatureId) {
+                // Rare: flat file already carries featureId — treat as owned state.
+                states.push({
+                    taskId,
+                    featureId: embeddedFeatureId,
+                    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,
+                    legacyFlat: true,
+                });
+                warnings.push(`legacy flat state for task ${taskId} carries featureId ${embeddedFeatureId}`);
+                continue;
+            }
+            legacyCandidates.push({
+                taskId,
+                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,
+                legacyFlat: true,
+            });
+        }
+    }
+    catch (error) {
+        warnings.push(`failed to scan legacy flat states: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { states, legacyCandidates, warnings };
+}
+async function loadFailureHandoffs(repoRoot) {
+    const handoffs = [];
+    const handoffDir = path.join(getTaskPoolRoot(repoRoot), "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, now) {
+    const byId = new Map();
+    const statePaths = await findStateJsonFiles(path.join(repoRoot, ".harness", "dag-runs"));
+    for (const statePath of statePaths) {
+        const summary = await parseDagStateFile(statePath, now);
+        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,
+        lifecycle: incoming.lifecycle ?? existing.lifecycle,
+        executionMode: incoming.executionMode ?? existing.executionMode,
+        liveness: incoming.liveness ?? existing.liveness,
+        effectiveStatus: incoming.effectiveStatus ?? existing.effectiveStatus,
+        failureCategory: incoming.failureCategory ?? existing.failureCategory,
+        stateConsistent: incoming.stateConsistent ?? existing.stateConsistent,
+        recoveryEligibility: incoming.recoveryEligibility ?? existing.recoveryEligibility,
+        frontendRecovery: incoming.frontendRecovery ?? existing.frontendRecovery,
+        title: incoming.title ?? existing.title,
+        startedAt,
+        finishedAt,
+        ...(durationMs !== undefined ? { durationMs } : {}),
+        ...(ranks && ranks.length > 0 ? { ranks } : {}),
+        nodes: mergeDagNodes(existing.nodes, incoming.nodes),
+        edges: incoming.edges.length > 0 ? incoming.edges : existing.edges,
+        ...((incoming.controlEdges ?? existing.controlEdges)
+            ? { controlEdges: incoming.controlEdges ?? existing.controlEdges }
+            : {}),
+        ...((incoming.convergence ?? existing.convergence)
+            ? { convergence: incoming.convergence ?? existing.convergence }
+            : {}),
+        ...((incoming.dagPath ?? existing.dagPath)
+            ? { dagPath: incoming.dagPath ?? existing.dagPath }
+            : {}),
+        ...((incoming.backendTest ?? existing.backendTest)
+            ? { backendTest: incoming.backendTest ?? existing.backendTest }
+            : {}),
+    };
+}
+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,
+        attemptCount: incoming.attemptCount ?? existing.attemptCount,
+        failureCategory: incoming.failureCategory ?? existing.failureCategory,
+        originKind: incoming.originKind ?? existing.originKind,
+        passes: incoming.passes ?? existing.passes,
+        executionSummary: incoming.executionSummary ?? existing.executionSummary,
+    };
+}
+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(getTaskPoolRoot(repoRoot), "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)),
+            edges: [],
+        });
+    }
+    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
+    }
+}
+async function loadBackendTestProjection(runDir, nodes) {
+    const contracts = path.join(runDir, "contracts");
+    const readContract = async (name) => {
+        const value = await safeReadJson(path.join(contracts, name));
+        return value ?? undefined;
+    };
+    const [initial, classification, eligibility, final, effective, manifest] = await Promise.all([
+        readContract("backend-test-result-initial.json"),
+        readContract("backend-test-classification.json"),
+        readContract("backend-test-repair-eligibility.json"),
+        readContract("backend-test-result-final.json"),
+        readContract("backend-test-result.json"),
+        readContract("backend-test-case-manifest.json"),
+    ]);
+    if (!initial &&
+        !classification &&
+        !eligibility &&
+        !final &&
+        !effective &&
+        !manifest)
+        return undefined;
+    const result = (value) => value
+        ? {
+            outcome: readString(value, "outcome"),
+            passed: readNumber(value, "passed"),
+            failed: readNumber(value, "failed"),
+            error: readNumber(value, "error"),
+        }
+        : undefined;
+    const repairNode = nodes.find((node) => node.nodeId === "repair-backend-pytest-pi");
+    const safetyNode = nodes.find((node) => node.nodeId === "validate-repair-safety-and-traceability-shell");
+    const eligible = eligibility ? eligibility.eligible === true : undefined;
+    const repairNodeStatus = repairNode?.status?.toLowerCase();
+    const repairAttempted = repairNodeStatus === "running" ||
+        repairNodeStatus === "finished" ||
+        repairNodeStatus === "error";
+    let repairStatus = "not-needed";
+    if (repairNodeStatus === "running")
+        repairStatus = "repairing";
+    else if (safetyNode && isFailedNodeStatus(safetyNode.status))
+        repairStatus = "rejected";
+    else if (final)
+        repairStatus = "completed";
+    else if (eligible)
+        repairStatus = "eligible";
+    const effectiveSource = final ? "final" : "initial";
+    const legacy = Boolean(eligibility || final || repairNode || safetyNode);
+    return {
+        ...(initial ? { initial: result(initial) } : {}),
+        ...(classification
+            ? {
+                classification: {
+                    category: readString(classification, "category"),
+                    confidence: readNumber(classification, "confidence"),
+                },
+            }
+            : {}),
+        ...(legacy
+            ? {
+                repair: {
+                    eligible,
+                    reason: eligibility ? readString(eligibility, "reason") : undefined,
+                    attempt: final || repairAttempted ? 1 : 0,
+                    status: repairStatus,
+                },
+                ...(final ? { final: result(final) } : {}),
+            }
+            : {}),
+        ...(effective
+            ? {
+                effective: {
+                    source: effectiveSource,
+                    outcome: readString(effective, "outcome"),
+                },
+            }
+            : {}),
+        ...(manifest && manifest.coverageSummary
+            ? { coverage: manifest.coverageSummary }
+            : {}),
+    };
+}
+async function loadFrontendLintProjection(runDir) {
+    const decoded = await safeReadJson(path.join(runDir, "contracts", "frontend-lint-assessment.json"));
+    if (!decoded)
+        return undefined;
+    const parsed = frontendLintAssessmentArtifactSchema.safeParse(decoded);
+    if (!parsed.success)
+        return undefined;
+    return {
+        status: parsed.data.status,
+        writerChangedFiles: parsed.data.writerChangedFiles,
+        toleratedDiagnosticCount: parsed.data.toleratedDiagnosticCount,
+        blockingDiagnosticCount: parsed.data.blockingDiagnostics.length,
+        blockingReasons: parsed.data.blockingReasons,
+    };
+}
+function projectFrontendRecovery(state) {
+    const s = state.frontendRecoveryState;
+    const r = state.frontendRecoveryResult;
+    if (!s && !r)
+        return undefined;
+    return {
+        ...(s?.recoveryRootRunId ? { recoveryRootRunId: s.recoveryRootRunId } : {}),
+        ...(s?.parentRunId ? { parentRunId: s.parentRunId } : {}),
+        ...(s?.childRunId ? { childRunId: s.childRunId } : {}),
+        ...(s?.attemptIndex !== undefined ? { attemptIndex: s.attemptIndex } : {}),
+        ...(s?.continuationCount !== undefined
+            ? { continuationCount: s.continuationCount }
+            : {}),
+        ...(s?.phase ? { phase: s.phase } : {}),
+        ...(r?.outcome ? { outcome: r.outcome } : {}),
+    };
+}
+async function parseDagStateFile(statePath, now) {
+    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 lifecycleName = path.basename(path.dirname(runDir));
+        const lifecycle = lifecycleName === "active" ||
+            lifecycleName === "paused" ||
+            lifecycleName === "completed" ||
+            lifecycleName === "dry-run" ||
+            lifecycleName === "init-only"
+            ? lifecycleName
+            : undefined;
+        const dagRunId = readString(parsed, "runId") ?? path.basename(runDir);
+        const status = readString(parsed, "status");
+        const executionModeRaw = readString(parsed, "executionMode");
+        const executionMode = executionModeRaw === "execute" ||
+            executionModeRaw === "dry-run" ||
+            executionModeRaw === "init-only"
+            ? executionModeRaw
+            : undefined;
+        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 runSpecPath = path.join(runDir, "run.json");
+        const modelByNode = await loadDagNodeModels(runSpecPath);
+        const nodes = parseDagNodes(parsed, rankByNode, modelByNode);
+        const edges = await parseDagEdges(runSpecPath, nodes);
+        const state = parsed;
+        const controlEdges = await deriveControlLoopEdges(runSpecPath, nodes, state);
+        const convergence = projectConvergenceSummary(state);
+        applyNodePasses(nodes, state);
+        applyNodeExecutionSummaries(nodes, state);
+        const liveness = assessDagRunLiveness({ state, now });
+        const effectiveStatus = lifecycle
+            ? 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)));
+        const recoveryEligibility = lifecycle
+            ? assessDagRunRecoveryEligibility({
+                lifecycle,
+                state,
+                liveness: liveness.status,
+            })
+            : undefined;
+        const [backendTest, frontendLint] = await Promise.all([
+            loadBackendTestProjection(runDir, nodes),
+            loadFrontendLintProjection(runDir),
+        ]);
+        const frontendRecovery = projectFrontendRecovery(state);
+        const continuationRecord = state.continuation &&
+            typeof state.continuation.parentRunId === "string" &&
+            typeof state.continuation.effectiveFromNodeId === "string" &&
+            typeof state.continuation.operatorSelectedNodeId === "string"
+            ? state.continuation
+            : undefined;
+        const rerunPlan = continuationRecord
+            ? await safeReadJson(path.join(runDir, ".runtime", "rerun-plan.json"))
+            : undefined;
+        const verification = rerunPlan && typeof rerunPlan.verificationPolicy === "object"
+            ? rerunPlan.verificationPolicy
+            : undefined;
+        const continuation = continuationRecord
+            ? {
+                parentRunId: continuationRecord.parentRunId,
+                effectiveFromNodeId: continuationRecord.effectiveFromNodeId,
+                operatorSelectedNodeId: continuationRecord.operatorSelectedNodeId,
+                ...(verification &&
+                    (verification.mode === "inherited" ||
+                        verification.mode === "rerun") &&
+                    Array.isArray(verification.nodeIds) &&
+                    verification.nodeIds.every((nodeId) => typeof nodeId === "string")
+                    ? {
+                        verificationPolicy: {
+                            mode: verification.mode,
+                            nodeIds: verification.nodeIds,
+                            ...(typeof verification.inheritedFromRunId === "string"
+                                ? { inheritedFromRunId: verification.inheritedFromRunId }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            }
+            : undefined;
+        const failureCategory = readString(parsed, "failureCategory");
+        return {
+            dagRunId,
+            status,
+            ...(lifecycle ? { lifecycle } : {}),
+            ...(executionMode ? { executionMode } : {}),
+            liveness: liveness.status,
+            effectiveStatus,
+            ...(failureCategory ? { failureCategory } : {}),
+            stateConsistent,
+            ...(recoveryEligibility ? { recoveryEligibility } : {}),
+            ...(title ? { title } : {}),
+            ...(startedAt ? { startedAt } : {}),
+            ...(finishedAt ? { finishedAt } : {}),
+            ...(durationMs !== undefined ? { durationMs } : {}),
+            ...(ranks.length > 0 ? { ranks } : {}),
+            nodes,
+            edges,
+            ...(controlEdges.length > 0 ? { controlEdges } : {}),
+            ...(convergence ? { convergence } : {}),
+            dagPath: runDir,
+            ...(continuation ? { continuation } : {}),
+            ...(backendTest ? { backendTest } : {}),
+            ...(frontendLint ? { frontendLint } : {}),
+            ...(frontendRecovery ? { frontendRecovery } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function parseDagEdges(runPath, nodes) {
+    const parsed = await safeReadJson(runPath);
+    if (!parsed)
+        return [];
+    const tasks = readObjectArray(parsed, "tasks");
+    if (tasks.length === 0)
+        return [];
+    const knownNodeIds = new Set(nodes.map((node) => node.nodeId));
+    const edges = new Map();
+    for (const task of tasks) {
+        const taskId = readString(task, "id") ?? readString(task, "nodeId");
+        if (!taskId || !knownNodeIds.has(taskId))
+            continue;
+        const dependencies = readStringArray(task, "depends_on");
+        const compatibleDependencies = dependencies.length > 0
+            ? dependencies
+            : readStringArray(task, "dependsOn");
+        for (const dependencyId of compatibleDependencies) {
+            if (dependencyId === taskId || !knownNodeIds.has(dependencyId))
+                continue;
+            const edge = { from: dependencyId, to: taskId };
+            edges.set(`${edge.from}\u0000${edge.to}`, edge);
+        }
+    }
+    return [...edges.values()].sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+}
+/**
+ * Derive presentation-only control-loop edges from the run spec's convergence
+ * chain. When the chain contains both `review-gate-shell` and `repair-pi`, the
+ * bounded repair-reverify-review loop exists at runtime and Observe renders it
+ * as a dashed feedback loop. The derived edge is never merged into `edges` or
+ * `ranks`, so DAG topological layout stays acyclic.
+ */
+async function deriveControlLoopEdges(runPath, nodes, state) {
+    const runtimeConvergence = state.convergence;
+    if (!runtimeConvergence?.enabled ||
+        runtimeConvergence.terminalReason === "feature-flag-off" ||
+        runtimeConvergence.terminalReason === "unsupported-dag-shape") {
+        return [];
+    }
+    const parsed = await safeReadJson(runPath);
+    if (!parsed)
+        return [];
+    const convergence = readObject(parsed, "convergence");
+    if (!convergence)
+        return [];
+    const chainNodeIds = readStringArray(convergence, "chainNodeIds");
+    if (chainNodeIds.length === 0)
+        return [];
+    if (!chainNodeIds.includes("review-gate-shell") ||
+        !chainNodeIds.includes("repair-pi")) {
+        return [];
+    }
+    const known = new Set(nodes.map((node) => node.nodeId));
+    if (!known.has("review-gate-shell") || !known.has("repair-pi")) {
+        return [];
+    }
+    return [{ from: "review-gate-shell", to: "repair-pi", kind: "control-loop" }];
+}
+/**
+ * Project `state.convergence` into the slim Observe summary. Keeps the budget
+ * envelope even when passHistory is empty.
+ */
+function projectConvergenceSummary(state) {
+    const convergence = state.convergence;
+    if (!convergence)
+        return undefined;
+    return {
+        enabled: convergence.enabled,
+        maxPasses: convergence.maxPasses,
+        currentPass: convergence.currentPass,
+        ...(convergence.terminalReason
+            ? { terminalReason: convergence.terminalReason }
+            : {}),
+        passHistory: convergence.passHistory.map((pass) => ({
+            pass: pass.pass,
+            ...(pass.reason ? { reason: pass.reason } : {}),
+            ...(pass.status ? { status: pass.status } : {}),
+            ...(pass.hardVerifyStatus
+                ? { hardVerifyStatus: pass.hardVerifyStatus }
+                : {}),
+            ...(pass.reviewVerdict ? { reviewVerdict: pass.reviewVerdict } : {}),
+            ...(pass.reviewGateStatus
+                ? { reviewGateStatus: pass.reviewGateStatus }
+                : {}),
+        })),
+    };
+}
+/**
+ * Record convergence participation from archived pass artifacts plus the live
+ * current pass. The controller archives only retry/terminal failures, so an
+ * active pass or a successful final pass must be derived from current node
+ * state to avoid dropping its pass marker from Observe.
+ */
+function applyNodePasses(nodes, state) {
+    const passesByNode = new Map();
+    const addPass = (nodeId, pass) => {
+        const passes = passesByNode.get(nodeId) ?? new Set();
+        passes.add(pass);
+        passesByNode.set(nodeId, passes);
+    };
+    for (const pass of state.convergence?.passHistory ?? []) {
+        for (const ref of pass.artifactRefs)
+            addPass(ref.nodeId, pass.pass);
+    }
+    const initialPassNodeIds = new Set([
+        "initial-review-pi",
+        "initial-review-gate-shell",
+        "initial-review-pass-shell",
+    ]);
+    for (const node of nodes) {
+        if (!initialPassNodeIds.has(node.nodeId))
+            continue;
+        const status = (node.status ?? "").toUpperCase();
+        if (["RUNNING", "FINISHED", "ERROR"].includes(status)) {
+            addPass(node.nodeId, 1);
+        }
+    }
+    const currentPass = state.convergence?.currentPass;
+    if (currentPass && currentPass > 0) {
+        const convergenceNodeIds = new Set([
+            "process-supervisor-pi",
+            "process-gate-shell",
+            "repair-pi",
+            "hard-verify-shell",
+            "review-pi",
+            "review-verdict-recovery-pi",
+            "review-gate-shell",
+        ]);
+        for (const node of nodes) {
+            if (!convergenceNodeIds.has(node.nodeId))
+                continue;
+            const status = (node.status ?? "").toUpperCase();
+            if (["RUNNING", "FINISHED", "ERROR"].includes(status)) {
+                addPass(node.nodeId, currentPass);
+            }
+        }
+    }
+    for (const node of nodes) {
+        const passes = passesByNode.get(node.nodeId);
+        if (passes && passes.size > 0) {
+            node.passes = [...passes].sort((left, right) => left - right);
+        }
+    }
+}
+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;
+}
+async function loadDagNodeModels(runPath) {
+    const models = new Map();
+    const raw = await safeReadJson(runPath);
+    if (!raw)
+        return models;
+    try {
+        const spec = parseDagSpec(raw);
+        for (const task of spec.tasks) {
+            const model = resolveModelForTask(task, spec.executorModels);
+            if (model)
+                models.set(task.id, model);
+        }
+    }
+    catch {
+        // Historical specs may predate the current schema (including the removed
+        // Cursor executor). Preserve their recorded model labels for observation
+        // without allowing those specs back into the executable DAG path.
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+            return models;
+        const legacy = raw;
+        const tasks = legacy.tasks;
+        const executorModels = legacy.executorModels;
+        if (!Array.isArray(tasks) ||
+            typeof executorModels !== "object" ||
+            executorModels === null ||
+            Array.isArray(executorModels)) {
+            return models;
+        }
+        for (const task of tasks) {
+            if (!task || typeof task !== "object" || Array.isArray(task))
+                continue;
+            const taskRecord = task;
+            const taskId = readString(taskRecord, "id");
+            const executor = readString(taskRecord, "executor") ?? "pi";
+            const complexity = readString(taskRecord, "complexity");
+            if (!taskId || !complexity)
+                continue;
+            const matrix = executorModels[executor];
+            if (!matrix || typeof matrix !== "object" || Array.isArray(matrix))
+                continue;
+            const model = readString(matrix, complexity);
+            if (model)
+                models.set(taskId, model);
+        }
+    }
+    return models;
+}
+const EXECUTED_NODE_STATUSES = new Set([
+    "finished",
+    "completed",
+    "succeeded",
+    "done",
+    "error",
+    "failed",
+    "partial_failed",
+    "running",
+    "started",
+    "paused",
+]);
+function isExecutedNodeStatus(status) {
+    if (!status)
+        return false;
+    return EXECUTED_NODE_STATUSES.has(status.toLowerCase());
+}
+const PASS_SUCCESS_STATUSES = new Set([
+    "finished",
+    "completed",
+    "succeeded",
+    "done",
+]);
+const PASS_FAILURE_STATUSES = new Set([
+    "error",
+    "failed",
+    "partial_failed",
+    "interrupted",
+]);
+/**
+ * Project the lightweight execution history summary for one DAG node.
+ * Precedence: recorded attempts > convergence passes > implicit single
+ * execution > no summary (legacy). Pure and deterministic; never throws on
+ * legacy shapes (missing attempts/passes/ok flags).
+ */
+export function projectExecutionSummary(options) {
+    const rawAttempts = Array.isArray(options.attempts)
+        ? options.attempts
+        : undefined;
+    if (rawAttempts && rawAttempts.length > 0) {
+        const attempts = rawAttempts.map((raw, index) => {
+            const record = raw && typeof raw === "object" && !Array.isArray(raw)
+                ? raw
+                : {};
+            const ok = record.ok === true;
+            const failureCategory = readString(record, "failureCategory");
+            const durationMs = readNumber(record, "durationMs");
+            const artifactPath = readString(record, "artifactPath");
+            return {
+                attempt: index + 1,
+                status: ok ? "success" : "failure",
+                ...(failureCategory ? { failureCategory } : {}),
+                ...(durationMs !== undefined ? { durationMs } : {}),
+                ...(artifactPath ? { artifactPath } : {}),
+            };
+        });
+        const totalAttemptCount = attempts.length;
+        const firstOutcome = attempts[0].status;
+        const finalOutcome = attempts[totalAttemptCount - 1].status;
+        const recovered = totalAttemptCount > 1 &&
+            firstOutcome === "failure" &&
+            finalOutcome === "success";
+        // 一次就成功/失败：卡片不展示 historyLabel；Inspector 仍可拿 attempts 元数据。
+        const historyLabel = totalAttemptCount <= 1
+            ? undefined
+            : recovered
+                ? `${totalAttemptCount} 次 · 先失败后成功`
+                : `${totalAttemptCount} 次 · 最终${finalOutcome === "success" ? "成功" : "失败"}`;
+        return {
+            totalAttemptCount,
+            ...(recovered ? { recovered: true } : {}),
+            firstOutcome,
+            finalOutcome,
+            ...(historyLabel ? { historyLabel } : {}),
+            attempts,
+        };
+    }
+    const passes = (options.passes ?? []).filter((pass) => Number.isFinite(pass) && pass >= 1);
+    if (passes.length > 0) {
+        const byPass = new Map((options.passRecords ?? [])
+            .filter((record) => passes.includes(record.pass))
+            .map((record) => [record.pass, record]));
+        const previews = passes.map((pass) => {
+            const record = byPass.get(pass);
+            return {
+                pass,
+                ...(record?.status ? { status: record.status } : {}),
+                ...(record?.failureCategory
+                    ? { failureCategory: record.failureCategory }
+                    : {}),
+                ...(record?.nodeRecordPath
+                    ? { nodeRecordPath: record.nodeRecordPath }
+                    : {}),
+            };
+        });
+        const finalRecord = byPass.get(passes[passes.length - 1]);
+        const finalStatus = finalRecord?.status;
+        let finalOutcome;
+        if (finalStatus) {
+            const normalized = finalStatus.toLowerCase();
+            if (PASS_SUCCESS_STATUSES.has(normalized))
+                finalOutcome = "success";
+            else if (PASS_FAILURE_STATUSES.has(normalized))
+                finalOutcome = "failure";
+        }
+        // 仅一轮 pass 时不在卡片展示（无叙事价值）；多轮才展示中文「修复轮次 N」
+        // 主文案，裸 P1/P2 编号不再作为主标题（原始编号仅 hover/title/诊断）。
+        const historyLabel = passes.length <= 1
+            ? undefined
+            : `修复轮次 ${passes.join(",")}${finalOutcome === "success"
+                ? " · 最终成功"
+                : finalOutcome === "failure"
+                    ? " · 最终失败"
+                    : ""}`;
+        return {
+            totalAttemptCount: passes.length,
+            ...(finalOutcome ? { finalOutcome } : {}),
+            ...(historyLabel ? { historyLabel } : {}),
+            passes: previews,
+        };
+    }
+    // 一次执行成功/失败不需要卡片历史行；不投影无叙事的 "1 次"。
+    if (isExecutedNodeStatus(options.status)) {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Fill executionSummary for nodes without attempt records: passes-driven
+ * summaries from convergence passHistory statuses, then implicit single
+ * execution for executed legacy nodes. Attempt-driven summaries projected in
+ * parseDagNodes take precedence and are never overwritten.
+ */
+function applyNodeExecutionSummaries(nodes, state) {
+    const passStatusByNode = buildNodePassStatusIndex(state);
+    for (const node of nodes) {
+        if (node.executionSummary)
+            continue;
+        const summary = projectExecutionSummary({
+            passes: node.passes,
+            status: node.status,
+            passRecords: passStatusByNode.get(node.nodeId),
+        });
+        if (summary)
+            node.executionSummary = summary;
+    }
+}
+function buildNodePassStatusIndex(state) {
+    const index = new Map();
+    for (const pass of state.convergence?.passHistory ?? []) {
+        for (const ref of pass.artifactRefs) {
+            if (!ref.nodeId)
+                continue;
+            // Copy before push: passHistory artifactRefs are readonly in the run
+            // state shape, so the accumulator must not alias the source array.
+            const records = [...(index.get(ref.nodeId) ?? [])];
+            records.push({
+                pass: pass.pass,
+                ...(ref.status ? { status: ref.status } : {}),
+                ...(ref.failureCategory
+                    ? { failureCategory: ref.failureCategory }
+                    : {}),
+                ...(ref.nodeRecordPath ? { nodeRecordPath: ref.nodeRecordPath } : {}),
+            });
+            index.set(ref.nodeId, records);
+        }
+    }
+    return index;
+}
+function parseDagNodes(parsed, rankByNode, modelByNode) {
+    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);
+            const attempts = Array.isArray(node.attempts) ? node.attempts : undefined;
+            // Only attempt-driven summaries are projected here; pass-driven and
+            // implicit single-execution summaries are filled afterwards by
+            // applyNodeExecutionSummaries so they are never shadowed by the
+            // implicit-single fallback.
+            const executionSummary = attempts && attempts.length > 0
+                ? projectExecutionSummary({ attempts, status: nodeStatus })
+                : undefined;
+            const origin = node.origin &&
+                typeof node.origin === "object" &&
+                !Array.isArray(node.origin)
+                ? node.origin
+                : undefined;
+            nodes.push({
+                nodeId: resolvedId,
+                rank: rankByNode.get(nodeId) ?? rankByNode.get(resolvedId),
+                executor: readString(node, "executor"),
+                model: readString(node, "model") ?? modelByNode.get(resolvedId),
+                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 } : {}),
+                ...(attempts && attempts.length > 0
+                    ? { attemptCount: attempts.length }
+                    : {}),
+                ...(executionSummary ? { executionSummary } : {}),
+                ...(readString(node, "failureCategory")
+                    ? { failureCategory: readString(node, "failureCategory") }
+                    : {}),
+                ...(origin?.kind === "imported" || origin?.kind === "executed"
+                    ? { originKind: origin.kind }
+                    : {}),
+            });
+        }
+        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);
+        const attempts = Array.isArray(node.attempts) ? node.attempts : undefined;
+        // Only attempt-driven summaries are projected here; pass-driven and
+        // implicit single-execution summaries are filled afterwards by
+        // applyNodeExecutionSummaries so they are never shadowed by the
+        // implicit-single fallback.
+        const executionSummary = attempts && attempts.length > 0
+            ? projectExecutionSummary({ attempts, status: nodeStatus })
+            : undefined;
+        const origin = node.origin &&
+            typeof node.origin === "object" &&
+            !Array.isArray(node.origin)
+            ? node.origin
+            : undefined;
+        nodes.push({
+            nodeId,
+            rank: rankByNode.get(nodeId),
+            executor: readString(node, "executor"),
+            model: readString(node, "model") ?? modelByNode.get(nodeId),
+            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 } : {}),
+            ...(attempts && attempts.length > 0
+                ? { attemptCount: attempts.length }
+                : {}),
+            ...(executionSummary ? { executionSummary } : {}),
+            ...(readString(node, "failureCategory")
+                ? { failureCategory: readString(node, "failureCategory") }
+                : {}),
+            ...(origin?.kind === "imported" || origin?.kind === "executed"
+                ? { originKind: origin.kind }
+                : {}),
+        });
+    }
+    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 readStringArray(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child.filter((item) => typeof item === "string");
+}
+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"));
+}