@tea-agent/loop-agent 0.39.0-beta.8 → 0.39.0-beta.9

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

@@ -31,6 +31,7 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         summary: null,
         dependency: null,
         prompt: null,
+        promptCandidates: [],
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
@@ -139,7 +140,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -267,6 +268,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
             maxBytes: promptBody.maxBytes,
             source: promptSource,
         },
+        promptCandidates,
         executorInput: {
             kind,
             skills,
@@ -292,6 +294,89 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
         warnings,
     };
 }
+async function loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings) {
+    const stateResolved = resolveDagRunArtifact(repoRoot, dagRunId, ["state.json"]);
+    if (!stateResolved.ok)
+        return [];
+    let state;
+    try {
+        state = JSON.parse(await readFile(stateResolved.result.absolutePath, "utf-8"));
+    }
+    catch {
+        warnings.push("state.json could not be read for failed prompt candidates.");
+        return [];
+    }
+    const nodes = state.nodes && typeof state.nodes === "object" && !Array.isArray(state.nodes)
+        ? state.nodes
+        : null;
+    const node = nodes?.[nodeId] &&
+        typeof nodes[nodeId] === "object" &&
+        !Array.isArray(nodes[nodeId])
+        ? nodes[nodeId]
+        : null;
+    if (!node)
+        return [];
+    const failedAttempts = new Set();
+    if (Array.isArray(node.attempts)) {
+        for (const entry of node.attempts) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const record = entry;
+            if (record.ok === false &&
+                typeof record.attempt === "number" &&
+                Number.isSafeInteger(record.attempt) &&
+                record.attempt > 0) {
+                failedAttempts.add(record.attempt);
+            }
+        }
+    }
+    if (node.status === "ERROR" &&
+        typeof node.currentAttempt === "number" &&
+        Number.isSafeInteger(node.currentAttempt) &&
+        node.currentAttempt > 0) {
+        failedAttempts.add(node.currentAttempt);
+    }
+    const candidates = [];
+    for (const attempt of [...failedAttempts].sort((a, b) => a - b)) {
+        const fileName = `prompt-candidate-attempt-${attempt}.json`;
+        const artifact = path.posix.join(nodeId, fileName);
+        const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, fileName]);
+        if (!resolved.ok) {
+            warnings.push(`Failed prompt candidate missing for attempt ${attempt}.`);
+            continue;
+        }
+        try {
+            const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+            if (raw.schemaVersion !== 1 ||
+                raw.attempt !== attempt ||
+                typeof raw.failureCategory !== "string" ||
+                typeof raw.prompt !== "string" ||
+                typeof raw.truncated !== "boolean" ||
+                typeof raw.maxBytes !== "number" ||
+                !Number.isSafeInteger(raw.maxBytes) ||
+                raw.maxBytes < 1 ||
+                raw.maxBytes > NODE_INPUT_PREVIEW_MAX_BYTES ||
+                typeof raw.sha256 !== "string" ||
+                !/^([a-f0-9]{64})$/.test(raw.sha256)) {
+                throw new Error("invalid candidate schema");
+            }
+            const prompt = truncatedField(raw.prompt, raw.maxBytes);
+            candidates.push({
+                attempt,
+                failureCategory: redactSecrets(raw.failureCategory),
+                prompt: prompt.text,
+                truncated: raw.truncated || prompt.truncated,
+                maxBytes: raw.maxBytes,
+                sha256Prefix: raw.sha256.slice(0, 12),
+                artifact,
+            });
+        }
+        catch {
+            warnings.push(`Failed prompt candidate is invalid for attempt ${attempt}.`);
+        }
+    }
+    return candidates;
+}
 /**
  * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
  * 2026-08-22 R2). Returns null when the node declares no piExtensions
@@ -486,8 +571,9 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
         ? task.piExtensions.filter((item) => typeof item === "string")
         : [];
     const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
+    const promptCandidates = await loadFailedPromptCandidates(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, piExtensionRunFacts, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {

package/dist/worker/observe/routes.js

@@ -11,7 +11,11 @@ import { buildGlobalSnapshot, clampDagRunHistoryPageSize, clampTaskRunHistoryLim
 import { loadDagRunExecutionTrajectory } from "../observability/dag-execution-trajectory.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 import { dagSourceBindingSchema } from "../../workflows/dag/types.js";
+import { getTaskPaths } from "../../task/runtime.js";
+import { classifyLedgerGate, computeLedgerInputDigest, LedgerParseError, parseLedgerJson, recoverLedgerInputContract, summarizeLedger, } from "../../task/source-prepare/ledger.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
+import { resolveDagRunArtifact, } from "./dag-run-artifacts.js";
+import { frontendPrewriteResultV1Schema } from "../../workflows/dag/frontend-prewrite-gate.js";
 import { isAllowedArtifactTextPath, resolveArtifactPath, resolveRepoFilePreview, toRepoRelativeArtifactPath, } from "./paths.js";
 import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js";
 import { buildDagNodeInput } from "./node-input.js";
@@ -70,6 +74,15 @@ export const ROUTES = [
         pattern: /^\/api\/tasks\/([^/]+)\/runs$/,
         handler: handleTaskRuns,
     },
+    /**
+     * Read-only source fidelity ledger safe summary (AC-009 / AC-FIDELITY-009):
+     * 只返回计数/状态/failure code，不泄漏敏感原文。
+     */
+    {
+        method: "GET",
+        pattern: /^\/api\/tasks\/([^/]+)\/ledger$/,
+        handler: handleTaskLedger,
+    },
     {
         method: "GET",
         pattern: /^\/api\/tasks\/([^/]+)$/,
@@ -116,6 +129,16 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence\/file$/,
         handler: handleDagNodeSpecEvidenceFile,
     },
+    // DAG run 专属只读 prewrite 结果（AC-006 / AC-BLOCK-006）：唯一读路径为
+    // run-owned contracts/frontend-prewrite-result.json（resolveDagRunArtifact 四类
+    // fail-closed），不扩大 isAllowedArtifactTextPath 通用 allowlist；响应以
+    // frontendPrewriteResultV1Schema（.strict()）解析，Inspector 不再做
+    // /api/artifacts 预览 → JSON.stringify → JSON.parse 双编码。
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/prewrite-result$/,
+        handler: handleDagRunPrewriteResult,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)$/,
@@ -448,6 +471,117 @@ async function handleTaskRuns(_req, res, match, ctx) {
     });
     sendJson(res, 200, page);
 }
+/**
+ * GET /api/tasks/:id/ledger — 只读 ledger 安全摘要。任务存在但无 ledger 时返回
+ * `{ present: false }`（空态，不伪造计数）；任务不存在返回 404；ledger 解析失败
+ * 返回带稳定 SOURCE_FIDELITY_* 错误码的 `{ present: false }`（AC-HARD-003：与
+ * parseLedgerJson 同一稳定码，不泄漏原文）。binding v2 标记 + ledgerSha256 +
+ * inputDigest 仅在真实 v2 绑定（非空 canonical requirement 集）时展示（AC-HARD-004：
+ * v1+optional 冒充 v2 不标记）；inputDigest 与当前权威源输入不一致时置 stale。
+ */
+async function handleTaskLedger(_req, res, match, ctx) {
+    const taskId = match.params.id;
+    if (!isSafeObservabilityIdentifier(taskId)) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
+    const taskPaths = getTaskPaths(ctx.repoRoot, taskId);
+    try {
+        await stat(taskPaths.taskDir);
+    }
+    catch {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+    }
+    const ledgerPath = path.join(taskPaths.sourceDir, "requirement-ledger.json");
+    let raw;
+    try {
+        raw = await readFile(ledgerPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            sendJson(res, 200, { present: false, taskId });
+            return;
+        }
+        sendJson(res, 200, {
+            present: false,
+            taskId,
+            error: "ledger-unreadable",
+        });
+        return;
+    }
+    let ledger;
+    try {
+        ledger = parseLedgerJson(raw);
+    }
+    catch (error) {
+        // AC-HARD-003：解析失败分支使用与 parseLedgerJson 相同的稳定 SOURCE_FIDELITY_*
+        // 错误码（结构化可消费），而非裸字符串/裸 Error。
+        const code = error instanceof LedgerParseError
+            ? error.code
+            : "SOURCE_FIDELITY_LEDGER_STALE";
+        sendJson(res, 200, {
+            present: false,
+            taskId,
+            error: code,
+        });
+        return;
+    }
+    const classification = classifyLedgerGate(ledger);
+    const summary = summarizeLedger(ledger, {
+        gateStatus: classification.ok ? "pass" : "fail",
+        failureCode: classification.ok ? null : classification.code,
+    });
+    // v2 binding 语义（AC-HARD-004）：仅在真实 v2 绑定（canonical requirement 非空，
+    // 具备 requirement→fragment 映射证据）时标记 bindingSchemaVersion=2 并透传
+    // ledgerSha256/inputDigest；空 canonical 的 ledger 是退化/伪造 v2，不标记。
+    const contract = recoverLedgerInputContract(ledger);
+    const realV2Binding = contract.canonicalRequirements.length > 0;
+    let stale = false;
+    if (realV2Binding) {
+        // 当前权威源输入：ledger.sourcePaths（repo-root relative POSIX）→ 当前字节；
+        // 缺失/清空的权威源视为 stale（fail-closed，与 init-hybrid 语义一致）。
+        const currentByPath = new Map();
+        for (const sourcePath of contract.sourcePaths) {
+            try {
+                currentByPath.set(sourcePath, await readFile(path.resolve(ctx.repoRoot, sourcePath), "utf8"));
+            }
+            catch {
+                // 权威源缺失：保持缺失，expectedInputDigest 不一致 → stale。
+            }
+        }
+        const expectedDigest = computeLedgerInputDigest({
+            sourceDocuments: contract.sourcePaths.map((sourcePath) => ({
+                path: sourcePath,
+                content: currentByPath.get(sourcePath) ?? "",
+            })),
+            canonicalRequirements: contract.canonicalRequirements,
+        });
+        stale = ledger.inputDigest !== expectedDigest;
+    }
+    const ledgerSha256 = createHash("sha256").update(raw).digest("hex");
+    sendJson(res, 200, {
+        present: true,
+        taskId,
+        ...(realV2Binding
+            ? {
+                bindingSchemaVersion: 2,
+                ledgerSha256,
+                inputDigest: ledger.inputDigest,
+                stale,
+            }
+            : {}),
+        fragmentCount: summary.fragmentCount,
+        canonicalRequirementCount: summary.canonicalRequirementCount,
+        contextOnlyCount: summary.contextOnlyCount,
+        duplicateCount: summary.duplicateCount,
+        unresolvedCount: summary.unresolvedCount,
+        conflictCount: summary.conflictCount,
+        gateStatus: summary.gateStatus,
+        failureCode: summary.failureCode,
+        exclusions: summary.exclusions,
+    });
+}
 function ambiguousTaskBody(taskId, candidates) {
     return {
         error: "Task identity ambiguous",
@@ -535,6 +669,60 @@ async function handleDagRuns(_req, res, match, ctx) {
     const body = listDagRunHistoryFromSnapshot(snapshot, { page, pageSize });
     sendJson(res, 200, body);
 }
+/**
+ * GET /api/dag-runs/:dagRunId/prewrite-result（AC-006 / AC-BLOCK-006）
+ * 只读 run-owned contracts/frontend-prewrite-result.json：resolveDagRunArtifact 是
+ * 唯一读路径（active/paused/completed 生命周期；invalid-id / unsafe-path /
+ * not-found / ambiguous 四类 fail-closed）。响应以 frontendPrewriteResultV1Schema
+ * （.strict()）解析，拒绝 envelope 之外的字段；不扩大通用 artifact allowlist。
+ */
+async function handleDagRunPrewriteResult(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const resolved = resolveDagRunArtifact(ctx.repoRoot, dagRunId, [
+        "contracts",
+        "frontend-prewrite-result.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "invalid-id") {
+            sendJson(res, 400, { error: "Invalid dag run identifier" });
+            return;
+        }
+        if (resolved.reason === "ambiguous") {
+            sendJson(res, 409, { error: "DAG run identity ambiguous" });
+            return;
+        }
+        sendJson(res, 404, { error: "Prewrite result not found" });
+        return;
+    }
+    let raw;
+    try {
+        raw = await readFile(resolved.result.absolutePath, "utf8");
+    }
+    catch {
+        sendJson(res, 404, { error: "Prewrite result not found" });
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        sendJson(res, 500, {
+            error: "Prewrite result is not valid JSON",
+            reason: "prewrite-result-unparseable",
+        });
+        return;
+    }
+    const envelope = frontendPrewriteResultV1Schema.safeParse(parsed);
+    if (!envelope.success) {
+        sendJson(res, 500, {
+            error: "Prewrite result is not a valid frontend-prewrite-result-v1 envelope",
+            reason: "prewrite-result-schema-invalid",
+        });
+        return;
+    }
+    sendJson(res, 200, envelope.data);
+}
 export async function handleDagRunById(_req, res, match, ctx) {
     const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);

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

@@ -116,8 +116,9 @@ export function artifactUrl(artifactPath) {
  * Experimental (prompt-override rerun only): POST one allowlisted operator
  * action through the Console mutation gate using the SCOPED inspect token
  * (window.__INSPECT_MUTATION_TOKEN__). The server injects it into /inspect
- * HTML only when HARNESS_DAG_RERUN_PROMPT_OVERRIDE is enabled, and it only
- * authorizes dagRerunPlan / dagRerun — never general Console mutations.
+ * HTML by default; HARNESS_DAG_RERUN_PROMPT_OVERRIDE=0|false|off disables
+ * injection. The token only authorizes dagRerunPlan / dagRerun — never general
+ * Console mutations.
  * Absent token → the call is not attempted.
  */
 export async function postOperatorAction(action, actionParams = {}) {
@@ -180,4 +181,3 @@ export function parseArtifactPreviewResponse(text) {
 		truncated: parsed.truncated === true,
 	};
 }
-

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

@@ -368,3 +368,40 @@ export function prettyJsonBlock(text) {
 		return null;
 	}
 }
+
+/**
+ * Source fidelity ledger 安全摘要渲染（AC-009/AC-010/AC-HARD-004）：计数/状态/
+ * failure code + v2 binding 语义（binding=v2 + ledger sha256/inputDigest，仅真实
+ * DagSourceBindingV2 时展示；inputDigest ≠ 当前 expectedInputDigest 时标记 stale）+
+ * 有界排除理由（fragmentId + 截断 reason），绝不渲染未截断原文。输入即安全摘要对象。
+ */
+export function formatLedgerSummary(summary) {
+	if (!summary || summary.present !== true) {
+		return "无 source fidelity ledger（任务无引用或 ledger 缺失，不伪造计数）";
+	}
+	const lines = [
+		`fragments=${summary.fragmentCount ?? 0}`,
+		`canonical requirements=${summary.canonicalRequirementCount ?? 0}`,
+		`context-only=${summary.contextOnlyCount ?? 0}`,
+		`duplicate=${summary.duplicateCount ?? 0}`,
+		`unresolved=${summary.unresolvedCount ?? 0}`,
+		`conflict=${summary.conflictCount ?? 0}`,
+		`gate=${summary.gateStatus ?? "unknown"}`,
+	];
+	if (summary.bindingSchemaVersion === 2) {
+		lines.push(
+			`binding=v2（受管 ledger 绑定）${summary.stale ? " · STALE（输入漂移）" : ""}`,
+		);
+		if (summary.ledgerSha256) lines.push(`ledgerSha256=${summary.ledgerSha256}`);
+		if (summary.inputDigest) lines.push(`inputDigest=${summary.inputDigest}`);
+	}
+	if (summary.failureCode) lines.push(`failureCode=${summary.failureCode}`);
+	const exclusions = Array.isArray(summary.exclusions) ? summary.exclusions : [];
+	if (exclusions.length > 0) {
+		lines.push("排除理由（有界摘要）：");
+		for (const entry of exclusions.slice(0, 20)) {
+			lines.push(`- ${entry.fragmentId}: ${truncateText(entry.reason ?? "", 120)}`);
+		}
+	}
+	return lines.join("\n");
+}

package/dist/worker/observe/static/index.html

@@ -352,6 +352,11 @@
             class="panel panel-table"
             aria-label="运行历史"
           ></section>
+          <section
+            id="task-ledger"
+            class="panel panel-table"
+            aria-label="Source fidelity ledger"
+          ></section>
         </section>
 
         <section data-view="feature" id="view-feature" class="view" hidden>

package/dist/worker/observe/static/prompt-restart-candidates.d.ts

@@ -0,0 +1,18 @@
+export type PromptRestartFailedCandidate = {
+	attempt?: number;
+	failureCategory?: string;
+	prompt?: string;
+	truncated?: boolean;
+};
+
+export type PromptRestartCandidateOption = {
+	key: string;
+	label: string;
+	prompt: string;
+	truncated: boolean;
+};
+
+export function buildPromptRestartCandidateOptions(
+	frozenPrompt: string | null | undefined,
+	failedCandidates: PromptRestartFailedCandidate[] | null | undefined,
+): PromptRestartCandidateOption[];

package/dist/worker/observe/static/prompt-restart-candidates.js

@@ -0,0 +1,36 @@
+export function buildPromptRestartCandidateOptions(
+	frozenPrompt,
+	failedCandidates,
+) {
+	const options = [
+		{
+			key: "frozen",
+			label: "冻结原始提示词",
+			prompt: String(frozenPrompt ?? ""),
+			truncated: false,
+		},
+	];
+	const seen = new Set();
+	for (const candidate of [...(failedCandidates ?? [])].sort(
+		(a, b) => Number(a?.attempt ?? 0) - Number(b?.attempt ?? 0),
+	)) {
+		const attempt = Number(candidate?.attempt);
+		if (!Number.isSafeInteger(attempt) || attempt < 1 || seen.has(attempt)) {
+			continue;
+		}
+		if (typeof candidate?.prompt !== "string") continue;
+		seen.add(attempt);
+		const failureCategory =
+			typeof candidate.failureCategory === "string" &&
+			candidate.failureCategory.trim()
+				? candidate.failureCategory.trim()
+				: "unknown";
+		options.push({
+			key: `attempt-${attempt}`,
+			label: `第 ${attempt} 次失败 · ${failureCategory}`,
+			prompt: candidate.prompt,
+			truncated: candidate.truncated === true,
+		});
+	}
+	return options;
+}

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

@@ -82,8 +82,8 @@ export const uiState = {
 	dagNodeExecutionOutputLoading: false,
 	dagNodeExecutionOutputError: null,
 	dagNodeExecutionOutputKey: null,
-	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认展开，用户可点选隐藏。 */
-	sessionTimelineShowProtocol: true,
+	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认隐藏，用户可点选展开。 */
+	sessionTimelineShowProtocol: false,
 	/** Open <details> keys restored across timeline re-renders. */
 	sessionTimelineOpenDetails: null,
 	lastSnapshot: null,