@tea-agent/loop-agent 0.30.0 → 0.31.1

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

@@ -756,8 +756,7 @@ function isDagRunActiveForHealth(dag) {
         return false;
     if (lifecycle === "completed")
         return false;
-    if (dag.effectiveStatus &&
-        TERMINAL_RUN_STATUSES.has(dag.effectiveStatus)) {
+    if (dag.effectiveStatus && TERMINAL_RUN_STATUSES.has(dag.effectiveStatus)) {
         return false;
     }
     // Real execute pause remains overview-visible (AC-003).
@@ -847,10 +846,10 @@ function computeDagHealth(dagRuns) {
             pausedRuns++;
         if (dag.effectiveStatus === "failed")
             failedRuns++;
-        if (liveness === "stale"
-            || liveness === "orphaned"
-            || liveness === "suspected-stall"
-            || liveness === "needs-attention") {
+        if (liveness === "stale" ||
+            liveness === "orphaned" ||
+            liveness === "suspected-stall" ||
+            liveness === "needs-attention") {
             staleRuns++;
         }
         if (dag.effectiveStatus === "interrupted")
@@ -1085,13 +1084,22 @@ async function appendJsonlEventsBounded(filePath, events, warnings) {
         }
     }
     if (tail.truncated) {
-        warnings.push("truncated event tail for " + path.basename(path.dirname(filePath)) + "/" + path.basename(filePath) + " to newest " + accepted + " valid events");
+        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 });
+    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 +
@@ -1380,6 +1388,7 @@ function mergeDagNode(existing, incoming) {
         failureCategory: incoming.failureCategory ?? existing.failureCategory,
         originKind: incoming.originKind ?? existing.originKind,
         passes: incoming.passes ?? existing.passes,
+        executionSummary: incoming.executionSummary ?? existing.executionSummary,
     };
 }
 function computeDurationMs(startedAt, finishedAt) {
@@ -1545,19 +1554,28 @@ async function loadBackendTestProjection(runDir, nodes) {
         readContract("backend-test-result.json"),
         readContract("backend-test-case-manifest.json"),
     ]);
-    if (!initial && !classification && !eligibility && !final && !effective && !manifest)
+    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 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";
+    const repairAttempted = repairNodeStatus === "running" ||
+        repairNodeStatus === "finished" ||
+        repairNodeStatus === "error";
     let repairStatus = "not-needed";
     if (repairNodeStatus === "running")
         repairStatus = "repairing";
@@ -1571,18 +1589,36 @@ async function loadBackendTestProjection(runDir, nodes) {
     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 } : {}),
+        ...(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) {
@@ -1639,6 +1675,7 @@ async function parseDagStateFile(statePath, now) {
         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({
@@ -1687,7 +1724,8 @@ async function parseDagStateFile(statePath, now) {
                 effectiveFromNodeId: continuationRecord.effectiveFromNodeId,
                 operatorSelectedNodeId: continuationRecord.operatorSelectedNodeId,
                 ...(verification &&
-                    (verification.mode === "inherited" || verification.mode === "rerun") &&
+                    (verification.mode === "inherited" ||
+                        verification.mode === "rerun") &&
                     Array.isArray(verification.nodeIds) &&
                     verification.nodeIds.every((nodeId) => typeof nodeId === "string")
                     ? {
@@ -1937,6 +1975,175 @@ async function loadDagNodeModels(runPath) {
     }
     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;
@@ -1952,7 +2159,16 @@ function parseDagNodes(parsed, rankByNode, modelByNode) {
             const outputPreview = nodeOutputPreview(node);
             const errorPreview = nodeErrorPreview(node, nodeStatus);
             const attempts = Array.isArray(node.attempts) ? node.attempts : undefined;
-            const origin = node.origin && typeof node.origin === "object" && !Array.isArray(node.origin)
+            // 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({
@@ -1970,6 +2186,7 @@ function parseDagNodes(parsed, rankByNode, modelByNode) {
                 ...(attempts && attempts.length > 0
                     ? { attemptCount: attempts.length }
                     : {}),
+                ...(executionSummary ? { executionSummary } : {}),
                 ...(readString(node, "failureCategory")
                     ? { failureCategory: readString(node, "failureCategory") }
                     : {}),
@@ -1987,7 +2204,16 @@ function parseDagNodes(parsed, rankByNode, modelByNode) {
         const outputPreview = nodeOutputPreview(node);
         const errorPreview = nodeErrorPreview(node, nodeStatus);
         const attempts = Array.isArray(node.attempts) ? node.attempts : undefined;
-        const origin = node.origin && typeof node.origin === "object" && !Array.isArray(node.origin)
+        // 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({
@@ -2005,6 +2231,7 @@ function parseDagNodes(parsed, rankByNode, modelByNode) {
             ...(attempts && attempts.length > 0
                 ? { attemptCount: attempts.length }
                 : {}),
+            ...(executionSummary ? { executionSummary } : {}),
             ...(readString(node, "failureCategory")
                 ? { failureCategory: readString(node, "failureCategory") }
                 : {}),

package/dist/worker/observe/dag-node-execution-output.js

@@ -0,0 +1,180 @@
+import { readFile } from "node:fs/promises";
+import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+import { resolveDagRunArtifact } from "./dag-run-artifacts.js";
+/** Align with Observe artifact preview bound (routes.ts ARTIFACT_PREVIEW_MAX_BYTES). */
+export const EXECUTION_OUTPUT_MAX_BYTES = 64 * 1024;
+const ATTEMPT_KEY = /^attempt-(\d+)$/;
+const PASS_KEY = /^pass-(\d+)$/;
+/**
+ * Parse an Inspector execution key. Clients may only send attempt-N or pass-N;
+ * arbitrary artifact paths are never accepted.
+ */
+export function parseExecutionOutputKey(raw) {
+    if (raw == null || String(raw).trim() === "") {
+        return { ok: false, reason: "missing" };
+    }
+    const key = String(raw).trim();
+    const attempt = ATTEMPT_KEY.exec(key);
+    if (attempt) {
+        const index = Number(attempt[1]);
+        if (!Number.isInteger(index) || index < 1) {
+            return { ok: false, reason: "invalid" };
+        }
+        return { ok: true, kind: "attempt", index, key: `attempt-${index}` };
+    }
+    const pass = PASS_KEY.exec(key);
+    if (pass) {
+        const index = Number(pass[1]);
+        if (!Number.isInteger(index) || index < 1) {
+            return { ok: false, reason: "invalid" };
+        }
+        return { ok: true, kind: "pass", index, key: `pass-${index}` };
+    }
+    return { ok: false, reason: "invalid" };
+}
+/**
+ * Map a validated execution key to relative segments under the target run dir.
+ * attempt-N → <nodeId>/attempt-N.json
+ * pass-N    → convergence/pass-N/<nodeId>.json
+ */
+export function executionOutputRelativeSegments(nodeId, parsed) {
+    if (parsed.kind === "attempt") {
+        return [nodeId, `attempt-${parsed.index}.json`];
+    }
+    return ["convergence", `pass-${parsed.index}`, `${nodeId}.json`];
+}
+function asOptionalString(value) {
+    return typeof value === "string" ? value : null;
+}
+function firstTimestamp(record) {
+    for (const field of [
+        "finishedAt",
+        "completedAt",
+        "endedAt",
+        "startedAt",
+        "timestamp",
+        "updatedAt",
+    ]) {
+        const value = record[field];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    return null;
+}
+function boundField(value) {
+    if (value == null)
+        return { text: null, truncated: false };
+    const redacted = redactSecrets(value);
+    const truncated = truncateUtf8Preview(redacted, EXECUTION_OUTPUT_MAX_BYTES);
+    return {
+        text: truncated,
+        truncated: truncated !== redacted,
+    };
+}
+/**
+ * Load redacted, bounded assistantText/stdout/stderr for a node execution key.
+ * Fail-closed on invalid ids, invalid keys, path escape, missing or ambiguous runs.
+ * Never accepts a client-supplied artifact path.
+ */
+export async function loadDagNodeExecutionOutput(repoRoot, dagRunId, nodeId, rawKey) {
+    if (!isSafeObservabilityIdentifier(dagRunId) ||
+        !isSafeObservabilityIdentifier(nodeId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid dag run or node identifier", reason: "invalid-id" },
+        };
+    }
+    const parsed = parseExecutionOutputKey(rawKey);
+    if (!parsed.ok) {
+        return {
+            status: 400,
+            body: {
+                error: parsed.reason === "missing"
+                    ? "Missing execution key (expected attempt-N or pass-N)"
+                    : "Invalid execution key (expected attempt-N or pass-N)",
+                reason: parsed.reason === "missing" ? "missing-key" : "invalid-key",
+            },
+        };
+    }
+    const segments = executionOutputRelativeSegments(nodeId, parsed);
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, segments);
+    if (!resolved.ok) {
+        if (resolved.reason === "invalid-id") {
+            return {
+                status: 400,
+                body: {
+                    error: "Invalid dag run or node identifier",
+                    reason: "invalid-id",
+                },
+            };
+        }
+        if (resolved.reason === "unsafe-path") {
+            return {
+                status: 400,
+                body: { error: "Unsafe execution artifact path", reason: "unsafe-path" },
+            };
+        }
+        if (resolved.reason === "ambiguous") {
+            return {
+                status: 409,
+                body: {
+                    error: "Ambiguous dag run lifecycle for execution artifact",
+                    reason: "ambiguous",
+                },
+            };
+        }
+        return {
+            status: 404,
+            body: {
+                error: "Execution output artifact not found",
+                reason: "not-found",
+            },
+        };
+    }
+    let raw;
+    try {
+        raw = await readFile(resolved.result.absolutePath, "utf8");
+    }
+    catch {
+        return {
+            status: 404,
+            body: {
+                error: "Execution output artifact not found",
+                reason: "not-found",
+            },
+        };
+    }
+    let record = {};
+    try {
+        const parsedJson = JSON.parse(raw);
+        if (parsedJson && typeof parsedJson === "object" && !Array.isArray(parsedJson)) {
+            record = parsedJson;
+        }
+    }
+    catch {
+        // Tolerant reader: non-JSON artifacts still return empty body fields.
+        record = {};
+    }
+    const assistant = boundField(asOptionalString(record.assistantText));
+    const stdout = boundField(asOptionalString(record.stdout));
+    const stderr = boundField(asOptionalString(record.stderr));
+    const truncated = assistant.truncated || stdout.truncated || stderr.truncated;
+    return {
+        status: 200,
+        body: {
+            dagRunId,
+            nodeId,
+            key: parsed.key,
+            kind: parsed.kind,
+            index: parsed.index,
+            source: resolved.result.relativePath.replace(/\\/g, "/"),
+            timestamp: firstTimestamp(record),
+            assistantText: assistant.text,
+            stdout: stdout.text,
+            stderr: stderr.text,
+            truncated,
+            maxBytes: EXECUTION_OUTPUT_MAX_BYTES,
+        },
+    };
+}

package/dist/worker/observe/routes.js

@@ -8,12 +8,14 @@ import { parseWorkerEventLine } from "../observability/events.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
 import { clampEventHistoryLimit, listBatchEventHistory, listPoolEventHistory, } from "../observability/event-history.js";
 import { buildGlobalSnapshot, clampTaskRunHistoryLimit, listTaskRunHistory, resolveLegacyTask, } from "../observability/read-model.js";
+import { loadDagRunExecutionTrajectory } from "../observability/dag-execution-trajectory.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 import { dagSourceBindingSchema } from "../../workflows/dag/types.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
 import { isAllowedArtifactTextPath, resolveArtifactPath, resolveRepoFilePreview, toRepoRelativeArtifactPath, } from "./paths.js";
 import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js";
 import { buildDagNodeInput } from "./node-input.js";
+import { loadDagNodeExecutionOutput } from "./dag-node-execution-output.js";
 import { buildObserveHealthV1 } from "./health.js";
 import { buildNightJobDetail, buildNightJobsDoctor, buildNightJobsList, buildNightJobsMorning, } from "./night-jobs.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
@@ -93,6 +95,11 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/input$/,
         handler: handleDagNodeInput,
     },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/execution-output$/,
+        handler: handleDagNodeExecutionOutput,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence$/,
@@ -500,14 +507,25 @@ async function handleRunArtifacts(_req, res, match, ctx) {
     }
     sendJson(res, 200, { artifacts });
 }
-async function handleDagRunById(_req, res, match, ctx) {
+export async function handleDagRunById(_req, res, match, ctx) {
     const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);
     if (!dagRun) {
         sendJson(res, 404, { error: "DAG run not found" });
         return;
     }
-    sendJson(res, 200, dagRun);
+    const payload = { ...dagRun };
+    // P1 契约：在 detail 响应中内嵌有界 executionTrajectory（不新增端点、
+    // 不接收客户端 artifact path）。仅当存在真实执行证据/警告/投影异常时附加；
+    // legacy 或纯事件 run 省略该字段，前端据此显示「本次运行没有可展开的执行轨迹」。
+    const trajectory = await loadDagRunExecutionTrajectory(ctx.repoRoot, dagRun.dagRunId);
+    if (trajectory &&
+        (trajectory.occurrences.length > 0 ||
+            trajectory.projectionError === true ||
+            trajectory.warnings.length > 0)) {
+        payload.executionTrajectory = trajectory;
+    }
+    sendJson(res, 200, payload);
 }
 async function handleDagNodeInput(_req, res, match, ctx) {
     const dagRunId = match.params.id;
@@ -520,6 +538,25 @@ async function handleDagNodeInput(_req, res, match, ctx) {
     const result = await buildDagNodeInput(ctx.repoRoot, dagRunId, nodeId);
     sendJson(res, result.status, result.body);
 }
+/**
+ * Read-only execution body by attempt-N / pass-N key only.
+ * Clients must never submit artifact paths; server maps key → run-dir segments.
+ */
+async function handleDagNodeExecutionOutput(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const nodeId = match.params.sub;
+    const key = match.query.get("key");
+    // Reject path-shaped inputs even if smuggled via key/query aliases.
+    if (match.query.has("path") || match.query.has("artifactPath")) {
+        sendJson(res, 400, {
+            error: "Artifact path is not accepted; use key=attempt-N|pass-N",
+            reason: "path-not-allowed",
+        });
+        return;
+    }
+    const result = await loadDagNodeExecutionOutput(ctx.repoRoot, dagRunId, nodeId, key);
+    sendJson(res, result.status, result.body);
+}
 async function handleDagNodeSessionEvents(_req, res, match, ctx) {
     const dagRunId = match.params.id;
     const nodeId = match.params.sub;
@@ -1005,13 +1042,23 @@ async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
     sendJson(res, 200, evidence);
 }
 function contentTypeFor(pathname) {
-    if (pathname.endsWith(".html"))
+    const lower = pathname.toLowerCase();
+    if (lower.endsWith(".html"))
         return "text/html; charset=utf-8";
-    if (pathname.endsWith(".js"))
+    if (lower.endsWith(".js") || lower.endsWith(".mjs")) {
         return "text/javascript; charset=utf-8";
-    if (pathname.endsWith(".css"))
+    }
+    if (lower.endsWith(".css"))
         return "text/css; charset=utf-8";
-    if (pathname.endsWith(".json"))
+    if (lower.endsWith(".json"))
         return "application/json; charset=utf-8";
+    if (lower.endsWith(".svg"))
+        return "image/svg+xml";
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".ico"))
+        return "image/x-icon";
+    if (lower.endsWith(".woff2"))
+        return "font/woff2";
     return "application/octet-stream";
 }