@tea-agent/loop-agent 0.24.5 → 0.24.6

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+### 新增
+
+- Observe / Inspect 节点检查器在「节点输出」左侧新增「节点输入」页签：只读投影冻结 `run.json` 顶层节点定义（任务正文、依赖、执行器摘要、边界）与可选 assembled prompt 指纹；完整 assembled prompt 与动态展开子节点仍不在本轮范围
+
+## [0.24.6] - 2026-07-29
+
+### 重点更新
+
+- 修复后端测试 Markdown-first 成功路径未投影 `backend-test-result` 的问题，Ready Planner 可再次放行 FE-TEST
+
+### 修复
+
+- Markdown-first `markdown-execute-html` 在解析原生 pytest-html 后立即物化 `contracts/backend-test-result.json`（Result v1），避免 styled HTML 覆盖后丢失 JSON island
+- `node-execution` 对 `markdown-execute-html` 绑定 `structuredArtifact*`，Outcome 适配器可投影 `kind: backend-test-result`
+
 ## [0.24.5] - 2026-07-28
 
 ### 重点更新

package/dist/executors/shell-executor.js

@@ -17,7 +17,7 @@ import { formatFrontendReviewContextStdout, runFrontendReviewContextGate, } from
 import { materializeFrontendLintAssessment, materializeFrontendLintBaseline, } from "../workflows/dag/frontend-lint-baseline.js";
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
-import { materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.js";
+import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -414,6 +414,14 @@ async function executeBackendTestPipeline(input, meta) {
             if (![0, 1].includes(pytestExitCode))
                 throw new Error(`pytest did not complete with a reportable exit code: ${pytestExitCode}`);
             const parsed = parsePytestHtmlReport(pytestHtmlContent);
+            // Bind Result v1 from the native pytest-html report BEFORE overwriting with the
+            // styled renderer (which drops the data-jsonblob island).
+            const resultArtifact = await materializeBackendTestResultFromPytestHtml({
+                runDir: meta.runDir,
+                htmlRelativePath: "reports/backend-test.html",
+                htmlContent: pytestHtmlContent,
+                pytestExitCode,
+            });
             const cases = await collectBackendTestHumanCaseCatalog(input.cwd);
             const caseValidationSummary = await readRequiredRunReport(reportsDir, "backend-md-case-validation.md");
             const traceabilitySummary = await readRequiredRunReport(reportsDir, "backend-test-traceability.md");
@@ -430,7 +438,7 @@ async function executeBackendTestPipeline(input, meta) {
             const markdownPath = await writeRunReport(meta.runDir, "backend-test.md", facts);
             const factsPath = await writeRunReport(meta.runDir, "backend-test-facts.md", facts);
             const sanitizedOutputs = results.map((result) => redactBackendTestOutput(result.stdout));
-            outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `markdown=${markdownPath}`, `facts=${factsPath}`, facts);
+            outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `markdown=${markdownPath}`, `facts=${factsPath}`, `result=${resultArtifact.path}`, facts);
         }
         else if (pipeline === "contracts") {
             const wrapperPath = path.join(meta.runDir, "analyze-and-discover-backend-test-pi.json");

package/dist/worker/observe/dag-run-artifacts.js

@@ -0,0 +1,90 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+export const DAG_RUN_LIFECYCLES = ["active", "completed", "paused"];
+function isPathInside(root, target) {
+    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    const normalizedTarget = path.normalize(target);
+    return (normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot));
+}
+function normalizeRelativeSegments(relativeSegments) {
+    if (!Array.isArray(relativeSegments) || relativeSegments.length === 0) {
+        return null;
+    }
+    const segments = [];
+    for (const segment of relativeSegments) {
+        if (typeof segment !== "string" || !segment)
+            return null;
+        if (segment === "." || segment === "..")
+            return null;
+        if (segment.includes("/") || segment.includes("\\") || segment.includes("\0")) {
+            return null;
+        }
+        segments.push(segment);
+    }
+    return segments;
+}
+/**
+ * Resolve a path under `.harness/dag-runs/{lifecycle}/{dagRunId}/...`.
+ * Fail closed on invalid ids, path escape, or the same runId appearing in
+ * multiple lifecycle directories.
+ */
+export function resolveDagRunArtifact(repoRoot, dagRunId, relativeSegments) {
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return { ok: false, reason: "invalid-id" };
+    }
+    const segments = normalizeRelativeSegments(relativeSegments);
+    if (!segments) {
+        return { ok: false, reason: "unsafe-path" };
+    }
+    for (const segment of segments) {
+        if (segment !== "run.json" &&
+            segment !== "state.json" &&
+            !isSafeObservabilityIdentifier(segment) &&
+            !/^[a-zA-Z0-9._-]+$/.test(segment)) {
+            // Allow known artifact filenames under a validated node id prefix.
+            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(segment)) {
+                return { ok: false, reason: "unsafe-path" };
+            }
+        }
+    }
+    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
+    const matches = [];
+    for (const lifecycle of DAG_RUN_LIFECYCLES) {
+        const runDir = path.join(dagRunsRoot, lifecycle, dagRunId);
+        const absolutePath = path.resolve(runDir, ...segments);
+        if (!isPathInside(dagRunsRoot, absolutePath))
+            continue;
+        const relative = path.relative(dagRunsRoot, absolutePath);
+        const parts = relative.split(path.sep).filter(Boolean);
+        if (parts[0] !== lifecycle || parts[1] !== dagRunId)
+            continue;
+        if (!existsSync(absolutePath))
+            continue;
+        matches.push({
+            lifecycle,
+            runDir,
+            absolutePath,
+            relativePath: path.join(lifecycle, dagRunId, ...segments),
+        });
+    }
+    if (matches.length === 0) {
+        return { ok: false, reason: "not-found" };
+    }
+    if (matches.length > 1) {
+        return { ok: false, reason: "ambiguous" };
+    }
+    return { ok: true, result: matches[0] };
+}
+export function resolveDagRunJson(repoRoot, dagRunId) {
+    return resolveDagRunArtifact(repoRoot, dagRunId, ["run.json"]);
+}
+export function resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId) {
+    if (!isSafeObservabilityIdentifier(nodeId)) {
+        return { ok: false, reason: "invalid-id" };
+    }
+    return resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "prompt.redacted.md",
+    ]);
+}

package/dist/worker/observe/node-input.js

@@ -0,0 +1,444 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { redactSecrets, truncateUtf8Preview, } from "../../shared/preview.js";
+import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
+import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
+export const NODE_INPUT_SCHEMA_VERSION = 1;
+export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
+const SHELL_GATE_KEYS = [
+    "verdictGate",
+    "projectGovernanceGate",
+    "requirementCoverageGate",
+    "jsonArtifactGate",
+    "frontendPrewriteGate",
+    "frontendLintBaseline",
+    "frontendVerificationBundle",
+    "frontendReviewContext",
+    "backendTestPipeline",
+    "verifyEvidence",
+    "repairArtifactGate",
+];
+const PROMPT_FINGERPRINT_RE = /<prompt\s+sha256=([a-f0-9]{12})\s+len=(\d+)\s*>/i;
+function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
+    return {
+        schemaVersion: NODE_INPUT_SCHEMA_VERSION,
+        dagRunId,
+        nodeId,
+        available: false,
+        availabilityReason: reason,
+        source: null,
+        summary: null,
+        dependency: null,
+        prompt: null,
+        executorInput: null,
+        boundaries: null,
+        promptFingerprint: null,
+        warnings,
+    };
+}
+function redactString(value) {
+    if (typeof value !== "string")
+        return null;
+    return redactSecrets(value);
+}
+function redactStringList(values) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .filter((item) => typeof item === "string")
+        .map((item) => redactSecrets(item));
+}
+function truncatedField(text, maxBytes = NODE_INPUT_PREVIEW_MAX_BYTES) {
+    const redacted = redactSecrets(text);
+    const truncated = truncateUtf8Preview(redacted, maxBytes);
+    return {
+        text: truncated,
+        truncated: truncated !== redacted,
+        maxBytes,
+    };
+}
+export function parsePromptRedactedFingerprint(markdown) {
+    const match = PROMPT_FINGERPRINT_RE.exec(markdown);
+    if (!match) {
+        return { ok: false, error: "fingerprint-format-mismatch" };
+    }
+    const sha256Prefix = match[1];
+    const lengthChars = Number(match[2]);
+    if (!Number.isSafeInteger(lengthChars) || lengthChars < 0) {
+        return { ok: false, error: "fingerprint-length-invalid" };
+    }
+    return { ok: true, sha256Prefix, lengthChars };
+}
+function isLikelyDynamicExpandedNode(nodeId, tasks) {
+    for (const parent of tasks) {
+        const parentId = typeof parent.id === "string" ? parent.id : "";
+        const expansion = parent.dynamicExpansion;
+        if (expansion && typeof expansion === "object") {
+            const childIdPrefix = typeof expansion.childIdPrefix ===
+                "string"
+                ? expansion.childIdPrefix
+                : "";
+            if (childIdPrefix) {
+                const prefix = `${childIdPrefix}-`;
+                if (nodeId.startsWith(prefix)) {
+                    const suffix = nodeId.slice(prefix.length);
+                    if (/^\d{4}$/.test(suffix) && Number(suffix) >= 1) {
+                        return true;
+                    }
+                }
+            }
+        }
+        const loop = parent.dynamicLoopUntil;
+        if (loop && typeof loop === "object" && parentId) {
+            const prefix = `${parentId}-r`;
+            if (nodeId.startsWith(prefix)) {
+                const rest = nodeId.slice(prefix.length);
+                const dash = rest.indexOf("-");
+                if (dash > 0) {
+                    const iterationText = rest.slice(0, dash);
+                    if (/^\d+$/.test(iterationText) && Number(iterationText) >= 1) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+function shellGateNames(shell) {
+    const gates = [];
+    for (const key of SHELL_GATE_KEYS) {
+        if (shell[key] != null)
+            gates.push(key);
+    }
+    return gates;
+}
+function resolveModelHint(spec, task) {
+    const complexity = typeof task.complexity === "string" ? task.complexity : null;
+    const executorModels = spec.executorModels;
+    if (complexity &&
+        executorModels &&
+        typeof executorModels === "object" &&
+        !Array.isArray(executorModels)) {
+        const pi = executorModels.pi;
+        if (pi && typeof pi === "object" && !Array.isArray(pi)) {
+            const model = pi[complexity];
+            if (typeof model === "string" && model.trim()) {
+                return redactSecrets(model);
+            }
+        }
+    }
+    const defaults = spec.defaults;
+    if (defaults && typeof defaults === "object" && !Array.isArray(defaults)) {
+        const model = defaults.model;
+        if (typeof model === "string" && model.trim()) {
+            return redactSecrets(model);
+        }
+    }
+    return null;
+}
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
+    const defaults = spec.defaults && typeof spec.defaults === "object"
+        ? spec.defaults
+        : undefined;
+    const executorDeclared = typeof task.executor === "string";
+    const executor = executorDeclared
+        ? String(task.executor)
+        : "pi";
+    const executorSource = executorDeclared
+        ? "task"
+        : "schema-default";
+    const writePolicyDeclared = typeof task.writePolicy === "string";
+    let writePolicy = null;
+    let writePolicySource = null;
+    if (writePolicyDeclared) {
+        writePolicy = String(task.writePolicy);
+        writePolicySource = "task";
+    }
+    else if (typeof defaults?.writePolicy === "string") {
+        writePolicy = defaults.writePolicy;
+        writePolicySource = "defaults";
+    }
+    const skillSpec = {
+        defaults,
+        skillsByRole: spec.skillsByRole && typeof spec.skillsByRole === "object"
+            ? spec.skillsByRole
+            : undefined,
+    };
+    const skills = resolveDagNodeSkills(skillSpec, {
+        role: typeof task.role === "string" ? task.role : undefined,
+        skills: Array.isArray(task.skills)
+            ? task.skills.filter((s) => typeof s === "string")
+            : undefined,
+    }).map((skill) => redactSecrets(skill));
+    const promptRaw = typeof task.subtask_prompt === "string" ? task.subtask_prompt : "";
+    const promptBody = truncatedField(promptRaw);
+    const promptSourceRaw = task.subtask_prompt_source;
+    let promptSource = null;
+    if (promptSourceRaw && typeof promptSourceRaw === "object") {
+        const src = promptSourceRaw;
+        if (src.type === "markdown" && typeof src.path === "string") {
+            promptSource = {
+                type: "markdown",
+                path: redactSecrets(src.path),
+                sha256Prefix: typeof src.sha256 === "string" && src.sha256.length >= 12
+                    ? src.sha256.slice(0, 12)
+                    : null,
+            };
+        }
+    }
+    const shellRaw = task.shell && typeof task.shell === "object" && !Array.isArray(task.shell)
+        ? task.shell
+        : null;
+    const staticRaw = task.static && typeof task.static === "object" && !Array.isArray(task.static)
+        ? task.static
+        : null;
+    let kind = "unknown";
+    if (executor === "shell" || shellRaw)
+        kind = "shell";
+    else if (executor === "static" || staticRaw)
+        kind = "static";
+    else if (executor === "pi")
+        kind = "pi";
+    const shell = shellRaw
+        ? {
+            commands: redactStringList(shellRaw.commands),
+            preset: typeof shellRaw.preset === "string"
+                ? redactSecrets(shellRaw.preset)
+                : null,
+            cwd: typeof shellRaw.cwd === "string"
+                ? redactSecrets(shellRaw.cwd)
+                : null,
+            timeoutMs: typeof shellRaw.timeoutMs === "number" &&
+                Number.isFinite(shellRaw.timeoutMs)
+                ? shellRaw.timeoutMs
+                : null,
+            nonZeroExitPolicy: typeof shellRaw.nonZeroExitPolicy === "string"
+                ? shellRaw.nonZeroExitPolicy
+                : null,
+            gates: shellGateNames(shellRaw),
+        }
+        : null;
+    const staticPreview = staticRaw && typeof staticRaw.resultMarkdown === "string"
+        ? truncatedField(staticRaw.resultMarkdown)
+        : null;
+    const staticBlock = staticRaw
+        ? {
+            status: typeof staticRaw.status === "string" ? staticRaw.status : null,
+            resultPreview: staticPreview?.text ?? "",
+            truncated: staticPreview?.truncated ?? false,
+            maxBytes: staticPreview?.maxBytes ?? NODE_INPUT_PREVIEW_MAX_BYTES,
+        }
+        : null;
+    return {
+        schemaVersion: NODE_INPUT_SCHEMA_VERSION,
+        dagRunId,
+        nodeId,
+        available: true,
+        availabilityReason: "available",
+        source: {
+            kind: "frozen-run-spec",
+            artifact: "run.json#tasks",
+            lifecycle,
+        },
+        summary: {
+            executor: redactString(executor),
+            executorSource,
+            role: typeof task.role === "string" ? redactSecrets(task.role) : null,
+            complexity: typeof task.complexity === "string"
+                ? task.complexity
+                : null,
+            writePolicy: writePolicy ? redactSecrets(writePolicy) : null,
+            writePolicySource,
+            toolProfile: typeof task.toolProfile === "string"
+                ? redactSecrets(task.toolProfile)
+                : null,
+        },
+        dependency: {
+            dependsOn: redactStringList(task.depends_on),
+            dependsPolicy: typeof task.dependsPolicy === "string" ? task.dependsPolicy : null,
+            failureAwareDependsOn: redactStringList(task.failureAwareDependsOn),
+            runIf: typeof task.runIf === "string" ? redactSecrets(task.runIf) : null,
+        },
+        prompt: {
+            format: "markdown",
+            text: promptBody.text,
+            truncated: promptBody.truncated,
+            maxBytes: promptBody.maxBytes,
+            source: promptSource,
+        },
+        executorInput: {
+            kind,
+            skills,
+            modelHint: resolveModelHint(spec, task),
+            shell,
+            static: staticBlock,
+        },
+        boundaries: {
+            allowedPaths: redactStringList(task.allowedPaths),
+            forbiddenPaths: redactStringList(task.forbiddenPaths),
+            writeSet: redactStringList(task.writeSet),
+            outputContract: typeof task.outputContract === "string"
+                ? truncatedField(task.outputContract).text
+                : null,
+            outputMode: typeof task.outputMode === "string" ? task.outputMode : null,
+            firstProtocolLine: typeof task.firstProtocolLine === "string"
+                ? redactSecrets(task.firstProtocolLine)
+                : null,
+        },
+        promptFingerprint: fingerprint,
+        warnings,
+    };
+}
+async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
+    const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
+    if (!resolved.ok) {
+        if (resolved.reason === "ambiguous") {
+            warnings.push("Ambiguous prompt.redacted.md lifecycle copies.");
+        }
+        return {
+            exists: false,
+            sha256Prefix: null,
+            lengthChars: null,
+            artifact: null,
+        };
+    }
+    const artifact = path.posix.join(nodeId, "prompt.redacted.md");
+    try {
+        const markdown = await readFile(resolved.result.absolutePath, "utf-8");
+        const parsed = parsePromptRedactedFingerprint(markdown);
+        if (!parsed.ok) {
+            warnings.push(`prompt.redacted.md parse failed: ${parsed.error}`);
+            return {
+                exists: true,
+                sha256Prefix: null,
+                lengthChars: null,
+                artifact,
+                parseError: parsed.error,
+            };
+        }
+        return {
+            exists: true,
+            sha256Prefix: parsed.sha256Prefix,
+            lengthChars: parsed.lengthChars,
+            artifact,
+        };
+    }
+    catch {
+        warnings.push("prompt.redacted.md could not be read.");
+        return {
+            exists: true,
+            sha256Prefix: null,
+            lengthChars: null,
+            artifact,
+            parseError: "read-failed",
+        };
+    }
+}
+/**
+ * Build schemaVersion 1 node-input projection for Observe / Inspect.
+ * Never returns the raw task object.
+ */
+export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
+    const runResolved = resolveDagRunJson(repoRoot, dagRunId);
+    if (!runResolved.ok) {
+        if (runResolved.reason === "invalid-id") {
+            return {
+                ok: false,
+                status: 400,
+                body: { error: "Invalid dag run or node identifier" },
+            };
+        }
+        if (runResolved.reason === "ambiguous") {
+            return {
+                ok: false,
+                status: 409,
+                body: { error: "Ambiguous dag run lifecycle" },
+            };
+        }
+        if (runResolved.reason === "not-found") {
+            return {
+                ok: false,
+                status: 404,
+                body: { error: "DAG run not found" },
+            };
+        }
+        return {
+            ok: false,
+            status: 400,
+            body: { error: "Invalid or unsafe path" },
+        };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(runResolved.result.absolutePath, "utf-8"));
+    }
+    catch {
+        return {
+            ok: false,
+            status: 422,
+            body: { error: "run.json is unreadable or invalid JSON" },
+        };
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            ok: false,
+            status: 422,
+            body: { error: "run.json is not a DAG spec object" },
+        };
+    }
+    const spec = raw;
+    const tasks = Array.isArray(spec.tasks) ? spec.tasks : null;
+    if (!tasks) {
+        return {
+            ok: true,
+            status: 200,
+            body: unavailableBody(dagRunId, nodeId, "run-spec-unavailable", [
+                "run.json has no tasks[] array.",
+            ]),
+        };
+    }
+    const taskRecords = tasks.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
+    const task = taskRecords.find((item) => typeof item.id === "string" && item.id === nodeId);
+    if (!task) {
+        if (isLikelyDynamicExpandedNode(nodeId, taskRecords)) {
+            return {
+                ok: true,
+                status: 200,
+                body: unavailableBody(dagRunId, nodeId, "unsupported-dynamic-node", [
+                    "Runtime-expanded node input is not projected in schemaVersion 1.",
+                ]),
+            };
+        }
+        return {
+            ok: true,
+            status: 200,
+            body: unavailableBody(dagRunId, nodeId, "task-not-found"),
+        };
+    }
+    const warnings = [];
+    const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
+    // Reject unknown nested leakage by projecting only through allowlist helpers.
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
+    // Defense-in-depth: ensure raw task never sneaks in.
+    if ("task" in body) {
+        return {
+            ok: false,
+            status: 422,
+            body: { error: "projection leaked raw task" },
+        };
+    }
+    return { ok: true, status: 200, body };
+}
+/** Test helper: ensure response JSON never contains raw task keys. */
+export function assertNoRawTaskLeak(body) {
+    if (!body || typeof body !== "object")
+        return true;
+    const record = body;
+    if ("task" in record)
+        return false;
+    if ("subtask_prompt" in record)
+        return false;
+    const serialized = JSON.stringify(body);
+    return !serialized.includes('"subtask_prompt":');
+}

package/dist/worker/observe/routes.js

@@ -13,6 +13,7 @@ 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 { buildObserveHealthV1 } from "./health.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
 export function createObserveSnapshotCache() {
@@ -86,6 +87,11 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/session-events$/,
         handler: handleDagNodeSessionEvents,
     },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/input$/,
+        handler: handleDagNodeInput,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence$/,
@@ -455,6 +461,17 @@ async function handleDagRunById(_req, res, match, ctx) {
     }
     sendJson(res, 200, dagRun);
 }
+async function handleDagNodeInput(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const nodeId = match.params.sub;
+    if (!isSafeObservabilityIdentifier(dagRunId) ||
+        !isSafeObservabilityIdentifier(nodeId)) {
+        sendJson(res, 400, { error: "Invalid dag run or node identifier" });
+        return;
+    }
+    const result = await buildDagNodeInput(ctx.repoRoot, dagRunId, nodeId);
+    sendJson(res, result.status, result.body);
+}
 async function handleDagNodeSessionEvents(_req, res, match, ctx) {
     const dagRunId = match.params.id;
     const nodeId = match.params.sub;

package/dist/worker/observe/static/api.js

@@ -29,6 +29,15 @@ export async function fetchJsonResult(url) {
 	}
 }
 
+/**
+ * Fetch a dag node input projection. Preserves HTTP status so callers can
+ * distinguish missing runs, unavailable nodes, and transport errors.
+ */
+export async function fetchDagNodeInput(runId, nodeId) {
+	const url = `/api/dag-runs/${encodeURIComponent(runId)}/nodes/${encodeURIComponent(nodeId)}/input`;
+	return fetchJsonResult(url);
+}
+
 /**
  * Fetch a spec-evidence file preview (binding source or successful read).
  * Resolves to the parsed JSON body, or throws an Error carrying the HTTP

package/dist/worker/observe/static/constants.js

@@ -33,6 +33,15 @@ export const UI_TEXT = {
 	noBatches: "暂无 Worker 批次，运行后将出现在这里。",
 	noNodes: "暂无节点。",
 	noOutput: "暂无节点输出。",
+	noInput: "暂无节点输入。",
+	inputLoading: "正在加载节点输入…",
+	inputUnavailable: "未在冻结 DAG tasks[] 中找到该节点输入。",
+	inputDynamicUnsupported:
+		"该节点为运行时动态展开节点，Phase A 暂不提供完整输入。",
+	inputRunSpecUnavailable: "无法读取冻结 DAG 规格（run.json）。",
+	inputError: "加载节点输入失败。",
+	inputFrozenLabel: "冻结 DAG 节点定义",
+	inputFingerprintNote: "仅保存 assembled prompt 指纹，全文未持久化",
 	noSessionEvents: "该节点暂无过程日志",
 	noArtifacts: "暂无产物记录。",
 	noActiveCommand: "当前没有正在执行的命令。",