@tea-agent/loop-agent 0.24.5 → 0.24.7

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: "当前没有正在执行的命令。",

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

@@ -34,6 +34,13 @@ export const uiState = {
 	// previous node can never mutate the current node's event cache.
 	sessionEventIdentity: null,
 	sessionEventIdentitySeq: 0,
+	/** Node-input request identity ("<dagRunId>:<nodeId>#<seq>"). */
+	dagNodeInputIdentity: null,
+	dagNodeInputRequestSeq: 0,
+	/** Last successful / in-flight node-input payload for the active identity. */
+	dagNodeInputData: null,
+	dagNodeInputError: null,
+	dagNodeInputLoading: false,
 	/** When true,「执行过程」展开 message_start/end 原始协议事件。 */
 	sessionTimelineShowProtocol: false,
 	/** Open <details> keys restored across timeline re-renders. */
@@ -45,6 +52,7 @@ export const uiState = {
 	dagGraphViewportState: null,
 	dagTimelineViewportState: null,
 	dagNodeOutputViewportState: null,
+	dagNodeInputViewportState: null,
 	runOutputViewportState: null,
 	/**
 	 * Spec-evidence file preview drill-down. null = list view; otherwise
@@ -65,6 +73,12 @@ export function makeSessionEventIdentity(dagRunId, nodeId) {
 	return `${dagRunId}:${nodeId}#${uiState.sessionEventIdentitySeq}`;
 }
 
+/** Build a fresh node-input identity token and bump its sequence. */
+export function makeDagNodeInputIdentity(dagRunId, nodeId) {
+	uiState.dagNodeInputRequestSeq += 1;
+	return `${dagRunId}:${nodeId}#${uiState.dagNodeInputRequestSeq}`;
+}
+
 export function isPageVisible() {
 	return (
 		typeof document === "undefined" || document.visibilityState !== "hidden"

package/dist/worker/observe/static/styles.css

@@ -2010,6 +2010,80 @@ body.is-resizing-dag-graph {
 .spec-evidence-section { padding-bottom: var(--space-4); border-bottom: 1px solid var(--hairline); }
 .spec-evidence-section + .spec-evidence-section { margin-top: var(--space-4); }
 .spec-evidence-section h4 { margin: 0 0 var(--space-2); color: var(--ink); font-size: 12px; font-weight: 700; }
+
+.node-input-root { display: flex; flex-direction: column; gap: var(--space-3); }
+.node-input-semantics {
+	margin: 0;
+	font-size: 12px;
+	font-weight: 600;
+	color: var(--muted);
+}
+.node-input-section {
+	padding-bottom: var(--space-3);
+	border-bottom: 1px solid var(--hairline);
+}
+.node-input-section h4 {
+	margin: 0 0 var(--space-2);
+	color: var(--ink);
+	font-size: 12px;
+	font-weight: 700;
+}
+.node-input-section h5 {
+	margin: var(--space-2) 0;
+	font-size: 12px;
+	font-weight: 600;
+}
+.node-input-summary {
+	display: grid;
+	grid-template-columns: max-content 1fr;
+	gap: 4px 12px;
+	margin: 0;
+	font-size: 12px;
+}
+.node-input-summary dt {
+	margin: 0;
+	color: var(--muted);
+	font-weight: 600;
+}
+.node-input-summary dd {
+	margin: 0;
+	color: var(--ink);
+	word-break: break-word;
+}
+.node-input-inherited {
+	display: inline-block;
+	margin-left: 4px;
+	padding: 0 6px;
+	border-radius: 999px;
+	background: var(--surface-2, #f3f1ec);
+	color: var(--muted);
+	font-size: 11px;
+	font-weight: 600;
+}
+.node-input-code-list,
+.node-input-command-list {
+	margin: var(--space-2) 0 0;
+	padding-left: 1.2rem;
+}
+.node-input-command-list pre {
+	margin: 4px 0;
+	padding: 8px;
+	overflow: auto;
+	background: var(--surface-2, #f3f1ec);
+	border-radius: 6px;
+	font-size: 12px;
+}
+.node-input-truncated,
+.node-input-warning {
+	margin: var(--space-2) 0 0;
+	font-size: 12px;
+	color: var(--muted);
+}
+.node-input-error {
+	margin: 0;
+	color: var(--danger, #b42318);
+	font-size: 13px;
+}
 .spec-evidence-summary { margin: var(--space-2) 0 0; color: var(--body); font-size: 12px; line-height: 1.6; }
 .spec-evidence-list { display: grid; gap: 6px; margin: var(--space-2) 0 0; padding: 0; list-style: none; }
 .spec-evidence-list li { display: flex; align-items: flex-start; gap: 6px; color: var(--body); font-size: 12px; line-height: 1.5; overflow-wrap: anywhere; }