@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

package/dist/workflows/dag/rerun-feedback.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseJsonReviewVerdict } from "./output-protocol.js";
+import { FRONTEND_DESIGN_REVIEW_NODE_ID, FRONTEND_REVIEW_NODE_ID, readCommittedDesignRequestFact, readCommittedReviewRequestFact, } from "./frontend-review-findings.js";
+import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 export const MAX_RERUN_FEEDBACK_CHARS = 12_000;
 const RERUN_FEEDBACK_TRUNCATION_MARKER = "\n\n...[上一轮反馈已按长度上限截断]...\n\n";
 const MAX_EVIDENCE_REFS = 8;
@@ -35,6 +37,44 @@ function requestRevision(text) {
         return (emphasized?.[1] ?? trimmed).trim() === "VERDICT: request-revision";
     });
 }
+/**
+ * Deterministically render a typed `request_review_changes` fact into feedback
+ * text. Unlike the legacy text channel (VERDICT: request-revision), the
+ * frontend review terminal is a committed typed fact; the findings are the
+ * actionable body the next round must consume.
+ */
+export function formatTypedReviewRequestFeedback(fact) {
+    const lines = [];
+    lines.push(`frontend review committed request_review_changes (issueCategory=${typeof fact.issueCategory === "string" ? fact.issueCategory : "unknown"})`);
+    if (Array.isArray(fact.findings) && fact.findings.length > 0) {
+        lines.push("review findings:");
+        for (const finding of fact.findings) {
+            if (!finding || typeof finding !== "object")
+                continue;
+            const record = finding;
+            const severity = typeof record.severity === "string" ? record.severity : "";
+            const issue = typeof record.issue === "string" ? record.issue : "";
+            const location = [
+                typeof record.file === "string" ? record.file : "",
+                typeof record.line === "number" ? String(record.line) : "",
+            ]
+                .filter(Boolean)
+                .join(":");
+            const prefix = location ? `[${location}] ` : "";
+            const requiredChange = typeof record.requiredChange === "string" &&
+                record.requiredChange.length > 0
+                ? ` (requiredChange: ${record.requiredChange})`
+                : "";
+            lines.push(`- ${prefix}${severity}: ${issue}${requiredChange}`);
+        }
+    }
+    if (Array.isArray(fact.evidenceRefs) && fact.evidenceRefs.length > 0) {
+        lines.push(`evidenceRefs: ${fact.evidenceRefs
+            .filter((ref) => typeof ref === "string")
+            .join(", ")}`);
+    }
+    return lines.join("\n");
+}
 function pathInside(root, candidate) {
     const relative = path.relative(root, candidate);
     return (relative === "" ||
@@ -127,6 +167,162 @@ function evidenceRefs(repoRoot, runDir, pass, sourceNodeId) {
     }
     return result;
 }
+/**
+ * Read the committed frontend review request fact (typed terminal channel).
+ * Returns { nodeId, fact } when the review node committed `request_review_changes`.
+ */
+async function readTypedReviewRequestFact(runDir) {
+    const fact = await readCommittedReviewRequestFact({ runDir });
+    if (!fact)
+        return undefined;
+    return {
+        nodeId: FRONTEND_REVIEW_NODE_ID,
+        fact: {
+            issueCategory: fact.issueCategory,
+            evidenceRefs: fact.evidenceRefs,
+            findings: fact.findings,
+        },
+    };
+}
+/**
+ * Read the committed frontend design request fact (typed terminal channel).
+ * Returns { nodeId, fact } when the design review node committed
+ * `request_design_changes` — the design analog of request_review_changes.
+ */
+async function readTypedDesignRequestFact(runDir) {
+    const fact = await readCommittedDesignRequestFact({ runDir });
+    if (!fact)
+        return undefined;
+    return {
+        nodeId: FRONTEND_DESIGN_REVIEW_NODE_ID,
+        fact: {
+            issueCategory: fact.issueCategory,
+            evidenceRefs: fact.evidenceRefs,
+            findings: fact.findings,
+        },
+    };
+}
+const RERUN_FEEDBACK_LINEAGE_MAX_DEPTH = 5;
+const RERUN_FEEDBACK_LINEAGE_LIFECYCLES = [
+    "active",
+    "paused",
+    "completed",
+];
+function safeLineageRunId(value) {
+    if (typeof value !== "string" || !value || value !== value.trim())
+        return undefined;
+    if (value === "." ||
+        value === ".." ||
+        value.includes("/") ||
+        value.includes("\\") ||
+        value.includes("\0"))
+        return undefined;
+    return value;
+}
+async function readCommittedTerminalKind(input) {
+    try {
+        const records = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.nodeId, input.factsFile));
+        for (const record of records) {
+            if (record.phase !== "committed")
+                continue;
+            const kind = record.fact.kind;
+            if (typeof kind === "string" && input.kinds.includes(kind))
+                return kind;
+        }
+    }
+    catch {
+        // A missing/unreadable terminal store means this run did not establish a
+        // usable resolution barrier; lineage lookup may continue.
+    }
+    return undefined;
+}
+async function readReviewTerminalKind(runDir) {
+    return readCommittedTerminalKind({
+        runDir,
+        nodeId: FRONTEND_REVIEW_NODE_ID,
+        factsFile: "review-typed-facts.jsonl",
+        kinds: ["request_review_changes", "approve_review"],
+    });
+}
+async function readDesignTerminalKind(runDir) {
+    return readCommittedTerminalKind({
+        runDir,
+        nodeId: FRONTEND_DESIGN_REVIEW_NODE_ID,
+        factsFile: "design-typed-facts.jsonl",
+        kinds: ["request_design_changes", "approve_design"],
+    });
+}
+/**
+ * Walk the rerun-task lineage chain (`<runDir>/.runtime/rerun-task-lineage.json`
+ * → parentRunId) looking for the nearest ancestor run with a committed review
+ * or design request fact. A nearer final-review approval resolves all older
+ * findings; a nearer design approval resolves older design findings while
+ * still allowing an older final-review request to survive. Bounded depth;
+ * unsafe ids, mismatched state identities, cycles, and unreadable lineage
+ * files terminate the walk with undefined.
+ */
+async function readAncestorTypedRequestFact(runDir) {
+    let currentRunDir = runDir;
+    let currentRunId;
+    let designResolved = false;
+    const dagRunsRoot = path.resolve(runDir, "..", "..");
+    const visitedRunDirs = new Set([path.resolve(runDir)]);
+    for (let depth = 0; depth <= RERUN_FEEDBACK_LINEAGE_MAX_DEPTH; depth += 1) {
+        const reviewTerminalKind = await readReviewTerminalKind(currentRunDir);
+        if (currentRunId && reviewTerminalKind === "request_review_changes") {
+            const fact = await readTypedReviewRequestFact(currentRunDir);
+            if (fact)
+                return { ...fact, parentRunId: currentRunId };
+        }
+        if (reviewTerminalKind === "approve_review")
+            return undefined;
+        const designTerminalKind = await readDesignTerminalKind(currentRunDir);
+        if (currentRunId &&
+            !designResolved &&
+            designTerminalKind === "request_design_changes") {
+            const fact = await readTypedDesignRequestFact(currentRunDir);
+            if (fact)
+                return { ...fact, parentRunId: currentRunId };
+        }
+        if (designTerminalKind === "approve_design")
+            designResolved = true;
+        if (depth === RERUN_FEEDBACK_LINEAGE_MAX_DEPTH)
+            return undefined;
+        let parentRunId;
+        try {
+            const lineage = JSON.parse(await readFile(path.join(currentRunDir, ".runtime", "rerun-task-lineage.json"), "utf8"));
+            parentRunId = safeLineageRunId(lineage.parentRunId);
+        }
+        catch {
+            return undefined;
+        }
+        if (!parentRunId)
+            return undefined;
+        let ancestorRunDir;
+        for (const lifecycle of RERUN_FEEDBACK_LINEAGE_LIFECYCLES) {
+            const candidate = path.join(dagRunsRoot, lifecycle, parentRunId);
+            try {
+                const ancestorState = JSON.parse(await readFile(path.join(candidate, "state.json"), "utf8"));
+                if (ancestorState.runId === parentRunId) {
+                    ancestorRunDir = candidate;
+                    break;
+                }
+            }
+            catch {
+                // try next lifecycle
+            }
+        }
+        if (!ancestorRunDir)
+            return undefined;
+        const resolvedAncestorRunDir = path.resolve(ancestorRunDir);
+        if (visitedRunDirs.has(resolvedAncestorRunDir))
+            return undefined;
+        visitedRunDirs.add(resolvedAncestorRunDir);
+        currentRunDir = ancestorRunDir;
+        currentRunId = parentRunId;
+    }
+    return undefined;
+}
 /**
  * Derive only the latest unresolved verify/review feedback from canonical
  * parent-run facts. Provider-only failures intentionally return undefined.
@@ -144,8 +340,126 @@ export async function deriveDagRerunFeedback(input) {
             break;
         }
     }
-    if (!sourceNodeId || !sourceNode)
+    if (!sourceNodeId || !sourceNode) {
+        // Typed terminal channel: the frontend review/design review commit their
+        // verdicts as typed facts (request_review_changes / request_design_changes)
+        // instead of VERDICT text, and the frontend DAG has no convergence
+        // passHistory. Fall back to reading the typed event stores so findings
+        // still flow into the next round as unresolved feedback. Prefer review;
+        // if absent, fall through to the design review (a design rejection also
+        // carries actionable findings the next plan round must consume). When
+        // the direct parent has neither because it failed before review, walk the
+        // rerun-task lineage chain — chained
+        // reruns otherwise lose the grandparent's code-review findings and the
+        // reviewer re-flags them as "unresolved previous-round feedback" (r18).
+        // A committed approval is a resolution barrier and prevents older
+        // findings from being resurrected.
+        const typedFact = (await readTypedReviewRequestFact(input.runDir)) ??
+            (await readTypedDesignRequestFact(input.runDir)) ??
+            (await readAncestorTypedRequestFact(input.runDir));
+        if (typedFact) {
+            const parentSourceBindingHash = sourceBindingHash(input.spec);
+            return withDigest({
+                schemaVersion: 1,
+                kind: "unresolved-terminal-feedback",
+                parentRunId: "parentRunId" in typedFact &&
+                    typeof typedFact.parentRunId === "string"
+                    ? typedFact.parentRunId
+                    : input.parentRunId,
+                taskId: input.taskId,
+                sourceNodeId: typedFact.nodeId,
+                verdict: "request-revision",
+                failureCategory: typedFact.nodeId === FRONTEND_REVIEW_NODE_ID
+                    ? "review-request-changes"
+                    : "design-request-changes",
+                feedbackText: scrubAndBoundFeedbackText(formatTypedReviewRequestFeedback(typedFact.fact), input.runDir, input.state.cwd),
+                evidenceRefs: [
+                    {
+                        nodeId: typedFact.nodeId,
+                        preservedNodeRecordPath: `${typedFact.nodeId}.json`,
+                    },
+                ],
+                attemptSummary: {
+                    completedPasses: 1,
+                    maxPasses: 1,
+                    ...(input.state.terminalReason
+                        ? { terminalReason: input.state.terminalReason }
+                        : {}),
+                },
+                binding: {
+                    ...(parentSourceBindingHash
+                        ? { sourceCanonicalHash: parentSourceBindingHash }
+                        : {}),
+                    ...(input.spec.taskContractBinding?.canonicalHash
+                        ? {
+                            taskContractCanonicalHash: input.spec.taskContractBinding.canonicalHash,
+                        }
+                        : {}),
+                    status: "unknown",
+                },
+            });
+        }
+        // Preserve actionable writer failures even when the run stopped before a
+        // final review node could commit typed findings. This is especially
+        // important for provider length exhaustion: the next run must see the
+        // stop reason/tool statistics instead of repeating the same prompt.
+        const writerNodeId = ["frontend-implement-pi", "implement-pi"].find((nodeId) => {
+            const node = input.state.nodes[nodeId];
+            return (node?.status === "ERROR" &&
+                [
+                    "empty-output",
+                    "invalid-output",
+                    "writer-thinking-exhausted",
+                    "writer-budget-exhausted",
+                    "incomplete-write-set",
+                    "partial-success-with-context-overflow",
+                ].includes(node.failureCategory ?? ""));
+        });
+        if (writerNodeId) {
+            const writerNode = await readNodeRecord(input.runDir, pass, undefined, writerNodeId, input.state.nodes[writerNodeId]);
+            if (writerNode) {
+                const writerFeedback = [
+                    `writer failure category: ${writerNode.failureCategory ?? "unknown"}`,
+                    writerNode.stopReason ? `provider stopReason: ${writerNode.stopReason}` : "",
+                    typeof writerNode.writeToolCallCount === "number"
+                        ? `write tool calls: ${writerNode.writeToolCallCount}`
+                        : "",
+                    writerNode.stderr?.trim() ?? "",
+                    canonicalNodeOutput(writerNode),
+                ]
+                    .filter(Boolean)
+                    .join("\n\n");
+                const parentSourceBindingHash = sourceBindingHash(input.spec);
+                return withDigest({
+                    schemaVersion: 1,
+                    kind: "unresolved-terminal-feedback",
+                    parentRunId: input.parentRunId,
+                    taskId: input.taskId,
+                    sourceNodeId: writerNodeId,
+                    verdict: "request-revision",
+                    failureCategory: writerNode.failureCategory,
+                    feedbackText: scrubAndBoundFeedbackText(writerFeedback, input.runDir, input.state.cwd),
+                    evidenceRefs: [
+                        {
+                            nodeId: writerNodeId,
+                            preservedNodeRecordPath: `${writerNodeId}.json`,
+                        },
+                    ],
+                    attemptSummary: { completedPasses: 1, maxPasses: 1 },
+                    binding: {
+                        ...(parentSourceBindingHash
+                            ? { sourceCanonicalHash: parentSourceBindingHash }
+                            : {}),
+                        ...(input.spec.taskContractBinding?.canonicalHash
+                            ? { taskContractCanonicalHash: input.spec.taskContractBinding.canonicalHash }
+                            : {}),
+                        status: "unknown",
+                    },
+                });
+            }
+        }
         return undefined;
+    }
     const completedPasses = pass?.pass ?? Math.max(1, input.state.convergence?.currentPass ?? 1);
     const maxPasses = Math.max(completedPasses, input.state.convergence?.maxPasses ?? 1);
     const parentSourceBindingHash = sourceBindingHash(input.spec);