@tea-agent/loop-agent 0.8.0 → 0.10.0

package/dist/worker/metrics/projector.js

@@ -0,0 +1,139 @@
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { loadFeatureDecisionModels } from "../feature/decision-loader.js";
+import { readFollowUpIndex } from "../follow-up/store.js";
+import { getTaskPoolRoot } from "../pool/run-store.js";
+import { readValidTaskPoolRuns } from "../pool/validation.js";
+export async function projectMonthlyMetrics(input) {
+    if (!/^\d{4}-\d{2}$/.test(input.month))
+        throw new Error("metrics month must be YYYY-MM");
+    const repoRoot = path.resolve(input.repoRoot);
+    const start = new Date(`${input.month}-01T00:00:00.000Z`);
+    const end = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 1));
+    if (!Number.isFinite(start.getTime()) || start.toISOString().slice(0, 7) !== input.month)
+        throw new Error("metrics month must be a valid YYYY-MM");
+    const { features, projectionWarnings } = await loadFeatureDecisionModels(repoRoot);
+    const validRuns = await readValidTaskPoolRuns(repoRoot);
+    const allRuns = validRuns.records;
+    projectionWarnings.push(...validRuns.warnings);
+    const runs = dedupeRuns(allRuns).filter((run) => inWindow(run.recordedAt, start, end));
+    const featureById = new Map(features.map((feature) => [feature.featureId, feature]));
+    const entered = new Set(runs.map((run) => run.featureId));
+    let closed = 0;
+    for (const id of entered) {
+        const feature = featureById.get(id);
+        if (feature?.status === "closed" && feature.evidence.closeout)
+            try {
+                const raw = (await import("yaml")).default.parse(await readFile(feature.evidence.closeout, "utf-8"));
+                if (raw.appliedAt && inWindow(raw.appliedAt, start, end))
+                    closed += 1;
+            }
+            catch { }
+    }
+    const metricWarnings = [];
+    const followUps = new Map();
+    for (const id of new Set(allRuns.map((run) => run.featureId)))
+        try {
+            followUps.set(id, await readFollowUpIndex(repoRoot, id));
+        }
+        catch {
+            metricWarnings.push(`follow-up index unavailable for ${id}`);
+        }
+    const failed = runs.filter((run) => run.status !== "succeeded");
+    const handled = failed.filter((run) => followUps.get(run.featureId)?.entries.some((entry) => entry.workerRunId === run.workerRunId)).length;
+    const approved = [...followUps.entries()].flatMap(([featureId, index]) => index.entries.map((entry) => ({ ...entry, featureId }))).filter((entry) => entry.status === "Approved" && entry.approvedAt && inWindow(entry.approvedAt, start, end));
+    const executedApproved = approved.filter((entry) => allRuns.some((run) => run.featureId === entry.featureId && run.taskId === entry.proposedTaskId && Boolean(entry.approvedAt) && run.recordedAt >= entry.approvedAt));
+    const approvedSuccess = executedApproved.filter((entry) => allRuns.some((run) => run.featureId === entry.featureId && run.taskId === entry.proposedTaskId && run.status === "succeeded" && run.recordedAt >= entry.approvedAt)).length;
+    const taskTypes = new Map(features.flatMap((feature) => feature.tasks.map((task) => [`${feature.featureId}:${task.taskId}`, task.type])));
+    const successfulDev = new Set(runs.filter((run) => run.status === "succeeded" && isDevelopmentType(taskTypes.get(`${run.featureId}:${run.taskId}`))).map((run) => `${run.featureId}:${run.taskId}`));
+    const deliveryTasks = new Set();
+    for (const feature of features)
+        if (feature.evidence.delivery)
+            try {
+                const manifest = JSON.parse(await readFile(feature.evidence.delivery, "utf-8"));
+                if (manifest.createdAt && inWindow(manifest.createdAt, start, end))
+                    for (const task of manifest.tasks ?? [])
+                        if (task.taskId)
+                            deliveryTasks.add(`${feature.featureId}:${task.taskId}`);
+            }
+            catch { }
+    const required = features.filter((feature) => entered.has(feature.featureId)).flatMap((feature) => feature.acceptanceCoverage.filter((item) => item.required));
+    const acComplete = required.filter((item) => item.status === "covered" || item.status === "waived").length;
+    const decisionLatencies = approved.flatMap((entry) => entry.approvedAt ? [new Date(entry.approvedAt).getTime() - new Date(entry.createdAt).getTime()] : []).filter((value) => value >= 0).sort((a, b) => a - b);
+    const recoveryRounds = [];
+    const recoveredTasks = new Set();
+    for (const taskId of new Set(runs.filter((run) => run.status !== "succeeded").map((run) => `${run.featureId}:${run.taskId}`))) {
+        const [featureId, id] = taskId.split(":");
+        const history = runs.filter((run) => run.featureId === featureId && run.taskId === id).sort((a, b) => a.recordedAt.localeCompare(b.recordedAt));
+        const firstFail = history.findIndex((run) => run.status !== "succeeded");
+        const success = history.findIndex((run, index) => index > firstFail && run.status === "succeeded");
+        if (firstFail >= 0 && success > firstFail) {
+            recoveryRounds.push(success - firstFail);
+            recoveredTasks.add(taskId);
+        }
+    }
+    for (const entry of executedApproved) {
+        const parentKey = `${entry.featureId}:${entry.parentTaskId}`;
+        if (recoveredTasks.has(parentKey))
+            continue;
+        const sourceRun = allRuns.find((run) => run.featureId === entry.featureId && run.workerRunId === entry.workerRunId);
+        const replacementSucceeded = runs.some((run) => run.featureId === entry.featureId && run.taskId === entry.proposedTaskId && run.status === "succeeded" && run.recordedAt >= entry.approvedAt);
+        if (!sourceRun || !replacementSucceeded)
+            continue;
+        const failedAttempts = runs.filter((run) => run.featureId === entry.featureId && run.taskId === entry.parentTaskId && run.status !== "succeeded" && run.recordedAt <= sourceRun.recordedAt).length;
+        if (failedAttempts > 0) {
+            recoveryRounds.push(failedAttempts);
+            recoveredTasks.add(parentKey);
+        }
+    }
+    const boundary = await countBoundaryInterceptions(path.join(getTaskPoolRoot(repoRoot), "artifacts", "features"), start, end);
+    const latencySum = decisionLatencies.reduce((a, b) => a + b, 0);
+    const recoverySum = recoveryRounds.reduce((a, b) => a + b, 0);
+    const metrics = { schemaVersion: 1, month: input.month, window: { start: start.toISOString(), end: end.toISOString() }, generatedAt: (input.now ?? new Date()).toISOString(), metrics: {
+            featureClosureRate: ratio(closed, entered.size, [...(entered.size ? [] : ["no Feature entered execution in window"]), ...projectionWarnings]),
+            orphanFreeFailureRate: ratio(handled, failed.length, [...(failed.length ? [] : ["no failed runs in window"]), ...metricWarnings, ...projectionWarnings]),
+            approvedFollowUpSuccessRate: ratio(approvedSuccess, executedApproved.length, [...(executedApproved.length ? [] : approved.length ? ["approved Follow-up exists but has not executed"] : ["no approved Follow-up in window"]), ...metricWarnings, ...projectionWarnings]),
+            deliverableOutputRate: ratio([...successfulDev].filter((id) => deliveryTasks.has(id)).length, successfulDev.size, [...(successfulDev.size ? [] : ["no successful development task in window"]), ...projectionWarnings]),
+            requiredAcEvidenceRate: ratio(acComplete, required.length, [...(required.length ? ["formal Blocked decisions are not yet a distinct persisted fact"] : ["no required AC discovered"]), ...projectionWarnings]),
+            humanDecisionLatency: { numerator: latencySum, denominator: decisionLatencies.length, value: decisionLatencies.length ? latencySum / decisionLatencies.length : null, sampleSize: decisionLatencies.length, valuesMs: decisionLatencies, medianMs: median(decisionLatencies), missingData: [...(decisionLatencies.length ? [] : ["no completed approval decision in window"]), ...projectionWarnings] },
+            failureRecoveryRounds: { numerator: recoverySum, denominator: recoveryRounds.length, value: recoveryRounds.length ? recoverySum / recoveryRounds.length : null, sampleSize: recoveryRounds.length, values: recoveryRounds, average: recoveryRounds.length ? recoverySum / recoveryRounds.length : null, missingData: [...(recoveryRounds.length ? [] : ["no failed task recovered inside the requested window"]), ...projectionWarnings] },
+            writeBoundaryInterceptions: { numerator: boundary.interceptions, denominator: boundary.audited, value: boundary.audited ? boundary.interceptions / boundary.audited : null, count: boundary.interceptions, sampleSize: boundary.audited, missingData: [...(boundary.audited ? [] : ["no boundary audit artifacts in window"]), ...projectionWarnings] },
+        } };
+    const outputDir = path.join(getTaskPoolRoot(repoRoot), "artifacts", "metrics");
+    const jsonPath = path.join(outputDir, `monthly-${input.month}.json`);
+    const markdownPath = path.join(outputDir, `monthly-${input.month}.md`);
+    await mkdir(outputDir, { recursive: true });
+    await atomicWrite(jsonPath, `${JSON.stringify(metrics, null, 2)}\n`);
+    await atomicWrite(markdownPath, renderMetrics(metrics));
+    return { metrics, jsonPath, markdownPath };
+}
+function ratio(numerator, denominator, missingData) { return { numerator, denominator, value: denominator ? numerator / denominator : null, sampleSize: denominator, missingData }; }
+function median(values) { if (!values.length)
+    return null; const middle = Math.floor(values.length / 2); return values.length % 2 ? values[middle] : (values[middle - 1] + values[middle]) / 2; }
+function inWindow(value, start, end) { const time = new Date(value).getTime(); return time >= start.getTime() && time < end.getTime(); }
+function dedupeRuns(runs) { return [...new Map(runs.map((run) => [run.workerRunId, run])).values()]; }
+async function countBoundaryInterceptions(root, start, end) { let interceptions = 0; let audited = 0; try {
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        const target = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            const child = await countBoundaryInterceptions(target, start, end);
+            interceptions += child.interceptions;
+            audited += child.audited;
+        }
+        else if (entry.name === "failure.json")
+            try {
+                const raw = JSON.parse(await readFile(target, "utf-8"));
+                if (typeof raw.writeBoundaryAudit?.ok === "boolean" && raw.capturedAt && inWindow(raw.capturedAt, start, end)) {
+                    audited += 1;
+                    if (!raw.writeBoundaryAudit.ok)
+                        interceptions += 1;
+                }
+            }
+            catch { }
+    }
+}
+catch { } return { interceptions, audited }; }
+async function atomicWrite(filePath, content) { const temp = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${randomUUID()}.tmp`); await writeFile(temp, content); await rename(temp, filePath); }
+function renderMetrics(metrics) { const rows = Object.entries(metrics.metrics).map(([name, value]) => `| ${name} | ${value.numerator} | ${value.denominator} | ${value.value ?? "n/a"} | ${value.sampleSize} | ${value.missingData.join("; ") || "none"} |`); return `# Monthly Metrics ${metrics.month}\n\nWindow: ${metrics.window.start} — ${metrics.window.end}\n\n| Metric | Numerator | Denominator | Value | Sample | Missing data |\n|---|---:|---:|---:|---:|---|\n${rows.join("\n")}\n`; }
+function isDevelopmentType(type) { return Boolean(type && !type.startsWith("qa-") && !["architecture", "review"].includes(type)); }

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

@@ -4,6 +4,9 @@ import path from "node:path";
 import { truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "./events.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
+import { assessDagRunLiveness, assessDagRunRecoveryEligibility, deriveDagRunEffectiveStatus, } from "../../workflows/dag/lifecycle.js";
+import { parseDagSpec, resolveModelForTask, } from "../../workflows/dag/types.js";
+import { loadFeatureDecisionModels } from "../feature/decision-loader.js";
 const ACTIVE_TASK_STATUSES = new Set(["running", "pending"]);
 const ACTIVE_BATCH_STATUSES = new Set(["running", "pending"]);
 export async function buildGlobalSnapshot(options) {
@@ -18,7 +21,7 @@ export async function buildGlobalSnapshot(options) {
             loadLedgerBatches(repoRoot),
             loadStateRecords(repoRoot),
             loadFailureHandoffs(repoRoot),
-            loadDagRuns(repoRoot),
+            loadDagRuns(repoRoot, now()),
         ]);
         const taskMap = new Map();
         for (const state of states) {
@@ -41,7 +44,8 @@ export async function buildGlobalSnapshot(options) {
             ...batch,
             tasks: batch.tasks.map((task) => normalizeTaskArtifactRefs(task, repoRoot)),
         }));
-        const health = computeHealth(batches, tasks);
+        const health = computeHealth(batches, tasks, dagRuns);
+        const { features, projectionWarnings } = await loadFeatureDecisionModels(repoRoot);
         return {
             schemaVersion: 1,
             generatedAt: now().toISOString(),
@@ -49,12 +53,31 @@ export async function buildGlobalSnapshot(options) {
             batches,
             tasks,
             dagRuns,
+            features,
+            projectionWarnings,
             health,
         };
     }
-    catch {
+    catch (error) {
         const now = options.now ?? (() => new Date());
-        return emptySnapshot(path.resolve(options.repoRoot), now);
+        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;
     }
 }
 function emptySnapshot(repoRoot, now) {
@@ -72,6 +95,25 @@ function emptySnapshot(repoRoot, now) {
             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,
+            },
         },
     };
 }
@@ -369,15 +411,168 @@ function summarizeTasks(tasks) {
     }
     return { total: tasks.length, succeeded, failed, reused };
 }
-function computeHealth(batches, tasks) {
-    return {
-        activeBatches: batches.filter((b) => ACTIVE_BATCH_STATUSES.has(b.status)).length,
+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",
+    "remote-unknown",
+    "pending",
+]);
+const TERMINAL_RUN_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+    "superseded",
+    "abandoned",
+]);
+/**
+ * Server-side mirror of app.js isDagRunActive. Derives DAG-run activeness from
+ * already-loaded DagRunSummary facts without touching app.js or new files.
+ */
+function isDagRunActiveForHealth(dag) {
+    if (dag.effectiveStatus && ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)) {
+        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 ((dag.lifecycle ?? "").toLowerCase() === "paused")
+        return false;
+    if (["orphaned", "stale"].includes((dag.liveness ?? "").toLowerCase()))
+        return false;
+    if (TERMINAL_RUN_STATUSES.has(status))
+        return false;
+    if (["running", "pending", "started"].includes(status))
+        return true;
+    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;
+    }
+    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")
+            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)
@@ -643,11 +838,11 @@ async function loadFailureHandoffs(repoRoot) {
     }
     return handoffs;
 }
-async function loadDagRuns(repoRoot) {
+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);
+        const summary = await parseDagStateFile(statePath, now);
         if (summary)
             byId.set(summary.dagRunId, mergeDagRun(byId.get(summary.dagRunId), summary));
     }
@@ -670,6 +865,11 @@ function mergeDagRun(existing, incoming) {
     return {
         dagRunId: incoming.dagRunId,
         status: incoming.status ?? existing.status,
+        lifecycle: incoming.lifecycle ?? existing.lifecycle,
+        liveness: incoming.liveness ?? existing.liveness,
+        effectiveStatus: incoming.effectiveStatus ?? existing.effectiveStatus,
+        stateConsistent: incoming.stateConsistent ?? existing.stateConsistent,
+        recoveryEligibility: incoming.recoveryEligibility ?? existing.recoveryEligibility,
         title: incoming.title ?? existing.title,
         startedAt,
         finishedAt,
@@ -849,7 +1049,7 @@ async function walkForStateJson(dir, results) {
         // skip
     }
 }
-async function parseDagStateFile(statePath) {
+async function parseDagStateFile(statePath, now) {
     try {
         if (!existsSync(statePath))
             return undefined;
@@ -858,6 +1058,10 @@ async function parseDagStateFile(statePath) {
         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
+            : undefined;
         const dagRunId = readString(parsed, "runId") ?? path.basename(runDir);
         const status = readString(parsed, "status");
         const title = readString(parsed, "title");
@@ -866,11 +1070,30 @@ async function parseDagStateFile(statePath) {
         const durationMs = computeDurationMs(startedAt, finishedAt);
         const ranks = readStringMatrix(parsed, "ranks");
         const rankByNode = buildRankIndex(ranks);
-        const nodes = parseDagNodes(parsed, rankByNode);
-        const edges = await parseDagEdges(path.join(runDir, "run.json"), nodes);
+        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 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;
         return {
             dagRunId,
             status,
+            ...(lifecycle ? { lifecycle } : {}),
+            liveness: liveness.status,
+            effectiveStatus,
+            stateConsistent,
+            ...(recoveryEligibility ? { recoveryEligibility } : {}),
             ...(title ? { title } : {}),
             ...(startedAt ? { startedAt } : {}),
             ...(finishedAt ? { finishedAt } : {}),
@@ -924,7 +1147,25 @@ function buildRankIndex(ranks) {
     }
     return index;
 }
-function parseDagNodes(parsed, rankByNode) {
+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; state facts remain readable.
+    }
+    return models;
+}
+function parseDagNodes(parsed, rankByNode, modelByNode) {
     const nodes = [];
     const nodesValue = parsed.nodes;
     if (nodesValue && typeof nodesValue === "object" && !Array.isArray(nodesValue)) {
@@ -940,7 +1181,7 @@ function parseDagNodes(parsed, rankByNode) {
                 nodeId: resolvedId,
                 rank: rankByNode.get(nodeId) ?? rankByNode.get(resolvedId),
                 executor: readString(node, "executor"),
-                model: readString(node, "model"),
+                model: readString(node, "model") ?? modelByNode.get(resolvedId),
                 status: nodeStatus,
                 label: readString(node, "label") ?? readString(node, "title") ?? nodeId,
                 durationMs: readNumber(node, "durationMs"),
@@ -962,7 +1203,7 @@ function parseDagNodes(parsed, rankByNode) {
             nodeId,
             rank: rankByNode.get(nodeId),
             executor: readString(node, "executor"),
-            model: readString(node, "model"),
+            model: readString(node, "model") ?? modelByNode.get(nodeId),
             status: nodeStatus,
             label: readString(node, "label") ?? readString(node, "title") ?? nodeId,
             durationMs: readNumber(node, "durationMs"),

package/dist/worker/observe/paths.js

@@ -1,10 +1,7 @@
 import { existsSync, realpathSync } from "node:fs";
 import path from "node:path";
-export function resolveArtifactPath(repoRoot, relative) {
-    if (!relative || path.isAbsolute(relative)) {
-        return null;
-    }
-    if (!isAllowedArtifactRelativePath(relative)) {
+export function resolveArtifactPath(repoRoot, artifactPath) {
+    if (!artifactPath) {
         return null;
     }
     const resolvedRepoRoot = path.resolve(repoRoot);
@@ -15,6 +12,21 @@ export function resolveArtifactPath(repoRoot, relative) {
     catch {
         realRepoRoot = resolvedRepoRoot;
     }
+    let absoluteArtifact = path.resolve(artifactPath);
+    if (path.isAbsolute(artifactPath) && existsSync(absoluteArtifact)) {
+        try {
+            absoluteArtifact = realpathSync(absoluteArtifact);
+        }
+        catch {
+            return null;
+        }
+    }
+    const relative = path.isAbsolute(artifactPath)
+        ? path.relative(realRepoRoot, absoluteArtifact)
+        : artifactPath;
+    if (!relative || path.isAbsolute(relative) || !isAllowedArtifactRelativePath(relative)) {
+        return null;
+    }
     const candidate = path.resolve(realRepoRoot, relative);
     if (!isPathInside(realRepoRoot, candidate)) {
         return null;