@tea-agent/loop-agent 0.26.1 → 0.26.2

package/dist/worker/observe/static/views/dag.js

@@ -271,7 +271,9 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		ranksEl.appendChild(el("h3", null, "DAG 依赖图"));
 		ranksEl.appendChild(el("p", "empty", UI_TEXT.noNodes));
 	} else if (reuseShell && existingGraphWrap?.parentNode === ranksEl) {
-		// reuse-dag-graph-wrap: keep wrap identity across polls when possible.
+		// reuse-dag-graph-wrap + viewport identity: keep wrap/viewport alive.
+		// Defer content rebuild only while the graph resize gesture is active;
+		// even without defer, renderDagGraph reuses the same viewport node.
 		if (!graphGestureActive) {
 			renderDagGraph(dag, dagRunId, existingGraphWrap);
 		}
@@ -328,16 +330,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 			};
 		});
 		const nodeTable = buildTable(
-			[
-				"序号",
-				"节点 ID",
-				"依赖层",
-				"执行方式",
-				"模型",
-				"状态",
-				"耗时",
-				"备注",
-			],
+			["序号", "节点 ID", "依赖层", "执行方式", "模型", "状态", "耗时", "备注"],
 			rows,
 		);
 		nodeTable.classList.add("dag-node-table");

package/dist/workflows/dag/backend-test-pytest-collection.js

@@ -0,0 +1,277 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const SHA256 = /^[a-f0-9]{64}$/;
+const MAX_DIAGNOSTIC_CHARS = 12_000;
+export const backendPytestCollectionFindingSchema = z.object({
+    kind: z.string().min(1),
+    classification: z.literal("test-asset-defect"),
+    repairability: z.enum(["repairable", "blocked"]),
+    detail: z.string().min(1),
+}).strict();
+export const backendPytestCollectionFactsSchema = z.object({
+    schemaId: z.literal("backend-test-pytest-collection-v1"),
+    phase: z.enum(["initial", "final", "effective"]),
+    status: z.enum(["PASS", "REPAIRABLE", "BLOCKED"]),
+    repairEligible: z.boolean(),
+    repairAttempt: z.number().int().min(0).max(1),
+    mappedScripts: z.array(z.string()).min(1),
+    assetFiles: z.array(z.string()).min(1),
+    inputHashes: z.record(z.string(), z.string().regex(SHA256)),
+    pytestExitCode: z.number().int(),
+    collectedItemCount: z.number().int().min(0),
+    collectedItemIds: z.array(z.string()),
+    findings: z.array(backendPytestCollectionFindingSchema),
+    stdoutExcerpt: z.string(),
+    stderrExcerpt: z.string(),
+    collectionSource: z.enum(["initial", "final"]).optional(),
+}).strict();
+function repoRef(workspaceRoot, absolutePath) {
+    return path.relative(workspaceRoot, absolutePath).replaceAll(path.sep, "/");
+}
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+async function walkPythonFiles(root) {
+    const results = [];
+    const visit = async (current) => {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name === "__pycache__" || entry.name === ".pytest_cache")
+                continue;
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory())
+                await visit(absolute);
+            else if (entry.isFile() && entry.name.endsWith(".py"))
+                results.push(absolute);
+        }
+    };
+    await visit(root);
+    return results;
+}
+export async function buildBackendPytestAssetInventory(workspaceRoot, mappedScripts) {
+    const normalizedScripts = [...new Set(mappedScripts.map((value) => value.replaceAll("\\", "/")))].sort();
+    if (normalizedScripts.length === 0)
+        throw new Error("backend pytest collection requires mapped scripts");
+    for (const script of normalizedScripts) {
+        if (!/^testcase(?:\/[A-Za-z0-9_.-]+)*\/test_[A-Za-z0-9_.-]+\.py$/.test(script) && !/^testcase\/test_[A-Za-z0-9_.-]+\.py$/.test(script)) {
+            throw new Error(`unsafe backend pytest mapped script: ${script}`);
+        }
+        const absolute = path.resolve(workspaceRoot, script);
+        const testcaseRoot = path.resolve(workspaceRoot, "testcase");
+        if (absolute !== testcaseRoot && !absolute.startsWith(`${testcaseRoot}${path.sep}`)) {
+            throw new Error(`backend pytest mapped script escapes testcase: ${script}`);
+        }
+        await readFile(absolute);
+    }
+    const pythonFiles = await walkPythonFiles(path.resolve(workspaceRoot, "testcase"));
+    const assetFiles = [...new Set(pythonFiles.map((file) => repoRef(workspaceRoot, file)))].sort();
+    const inputHashes = {};
+    for (const file of assetFiles)
+        inputHashes[file] = sha256(await readFile(path.resolve(workspaceRoot, file)));
+    return { mappedScripts: normalizedScripts, assetFiles, inputHashes };
+}
+function bounded(value) {
+    const normalized = value.replaceAll(/(Bearer|Basic)\s+[A-Za-z0-9._~+\/-]+/gi, "$1 [REDACTED]");
+    return normalized.length <= MAX_DIAGNOSTIC_CHARS
+        ? normalized
+        : `${normalized.slice(0, MAX_DIAGNOSTIC_CHARS)}\n...[truncated]`;
+}
+function collectionItems(stdout) {
+    return [...new Set(stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => {
+            if (!line.includes("::"))
+                return false;
+            if (/^(ERROR|FAILED|E\s+)/.test(line))
+                return false;
+            return /^testcase\//.test(line.replaceAll("\\", "/"));
+        }).map((line) => line.replaceAll("\\", "/")))];
+}
+function classifyCollectionFailure(output) {
+    const normalized = output.replaceAll("\\", "/");
+    const blockedPatterns = [
+        [/No module named ['\"](?!testcase(?:\.|['\"]))/i, "missing-third-party-module"],
+        [/pytest(?:_|-)plugin|pluggy|unknown hook|unrecognized arguments/i, "pytest-plugin-or-config"],
+        [/(?:apps|src|server|api)\/[A-Za-z0-9_./-]+\.py/i, "production-module-import"],
+        [/permission denied|access is denied|timed? out|not recognized as an internal|no such file or directory.*python/i, "environment-or-spawn"],
+    ];
+    for (const [pattern, kind] of blockedPatterns) {
+        if (pattern.test(normalized))
+            return { status: "BLOCKED", kind, detail: "collection failure is outside generated testcase asset repair scope" };
+    }
+    if (/ImportError:\s*cannot import name/i.test(normalized) && /(?:from ['\"]testcase\.|\/testcase\/)/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "missing-local-import-symbol", detail: "generated testcase asset imports a missing local symbol" };
+    }
+    if (/ModuleNotFoundError:\s*No module named ['\"]testcase(?:\.|['\"])/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "missing-local-testcase-module", detail: "generated testcase asset imports a missing local testcase module" };
+    }
+    if (/partially initialized module ['\"]testcase\.|circular import/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "local-circular-import", detail: "generated testcase assets contain a local circular import" };
+    }
+    if (/SyntaxError|IndentationError|TabError/i.test(normalized) && /testcase\/[A-Za-z0-9_./-]+\.py/i.test(normalized)) {
+        return { status: "REPAIRABLE", kind: "generated-python-syntax", detail: "generated testcase Python source is not syntactically collectable" };
+    }
+    return { status: "BLOCKED", kind: "unclassified-collection-error", detail: "collection failure cannot be safely attributed to generated testcase assets" };
+}
+export function assessBackendPytestCollection(input) {
+    const items = collectionItems(input.stdout);
+    if (input.exitCode === 0) {
+        return backendPytestCollectionFactsSchema.parse({
+            schemaId: "backend-test-pytest-collection-v1",
+            phase: input.phase,
+            status: "PASS",
+            repairEligible: false,
+            repairAttempt: input.phase === "final" ? 1 : 0,
+            mappedScripts: input.inventory.mappedScripts,
+            assetFiles: input.inventory.assetFiles,
+            inputHashes: input.inventory.inputHashes,
+            pytestExitCode: input.exitCode,
+            collectedItemCount: items.length,
+            collectedItemIds: items,
+            findings: [],
+            stdoutExcerpt: bounded(input.stdout),
+            stderrExcerpt: bounded(input.stderr),
+        });
+    }
+    const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`);
+    return backendPytestCollectionFactsSchema.parse({
+        schemaId: "backend-test-pytest-collection-v1",
+        phase: input.phase,
+        status: classification.status,
+        repairEligible: input.phase === "initial" && classification.status === "REPAIRABLE",
+        repairAttempt: input.phase === "final" ? 1 : 0,
+        mappedScripts: input.inventory.mappedScripts,
+        assetFiles: input.inventory.assetFiles,
+        inputHashes: input.inventory.inputHashes,
+        pytestExitCode: input.exitCode,
+        collectedItemCount: items.length,
+        collectedItemIds: items,
+        findings: [{
+                kind: classification.kind,
+                classification: "test-asset-defect",
+                repairability: classification.status === "REPAIRABLE" ? "repairable" : "blocked",
+                detail: classification.detail,
+            }],
+        stdoutExcerpt: bounded(input.stdout),
+        stderrExcerpt: bounded(input.stderr),
+    });
+}
+export function renderBackendPytestCollectionReport(facts) {
+    return [
+        `# Backend pytest Collection ${facts.phase}`,
+        "",
+        "## Status",
+        "",
+        facts.status,
+        "",
+        `- Repair eligible: ${facts.repairEligible}`,
+        `- Repair attempt: ${facts.repairAttempt}`,
+        `- Pytest exit code: ${facts.pytestExitCode}`,
+        `- Mapped scripts: ${facts.mappedScripts.length}`,
+        `- Bound Python assets: ${facts.assetFiles.length}`,
+        `- Collected items: ${facts.collectedItemCount}`,
+        "",
+        "## Findings",
+        "",
+        ...(facts.findings.length ? facts.findings.map((finding) => `- ${finding.kind}: ${finding.detail}`) : ["- None"]),
+        "",
+        "## Collected Items",
+        "",
+        ...(facts.collectedItemIds.length ? facts.collectedItemIds.map((item) => `- ${item}`) : ["- None"]),
+        "",
+        "## Bounded stdout",
+        "",
+        "```text",
+        facts.stdoutExcerpt,
+        "```",
+        "",
+        "## Bounded stderr",
+        "",
+        "```text",
+        facts.stderrExcerpt,
+        "```",
+        "",
+    ].join("\n");
+}
+export async function writeBackendPytestCollectionArtifacts(input) {
+    const contractsDir = path.join(input.runDir, "contracts");
+    const reportsDir = path.join(input.runDir, "reports");
+    await mkdir(contractsDir, { recursive: true });
+    await mkdir(reportsDir, { recursive: true });
+    const factsPath = path.join(contractsDir, `backend-test-pytest-collection-${input.stem}.json`);
+    const reportPath = path.join(reportsDir, `backend-test-pytest-collection-${input.stem}.md`);
+    await writeFile(factsPath, `${JSON.stringify(input.facts, null, 2)}\n`, "utf8");
+    await writeFile(reportPath, renderBackendPytestCollectionReport(input.facts), "utf8");
+    return { factsPath, reportPath };
+}
+export async function readBackendPytestCollectionFacts(filePath) {
+    return backendPytestCollectionFactsSchema.parse(JSON.parse(await readFile(filePath, "utf8")));
+}
+async function assertBackendPytestRepairSafety(workspaceRoot, initial, final) {
+    if (JSON.stringify(initial.mappedScripts) !== JSON.stringify(final.mappedScripts)) {
+        throw new Error("backend pytest repair changed mapped script scope");
+    }
+    const forbidden = [
+        [/pytest\.mark\.(?:skip|skipif|xfail)\b|pytest\.(?:skip|xfail)\s*\(/, "skip/xfail"],
+        [/sys\.path\s*\.|PYTHONPATH/, "sys.path/PYTHONPATH mutation"],
+        [/except\s+ImportError\b/, "ImportError fallback"],
+        [/except\s+(?:Exception|BaseException)\b[\s\S]{0,160}?\bpass\b/, "broad exception swallowing"],
+    ];
+    for (const file of final.assetFiles) {
+        const source = await readFile(path.resolve(workspaceRoot, file), "utf8");
+        for (const [pattern, label] of forbidden) {
+            if (pattern.test(source))
+                throw new Error(`backend pytest repair safety blocked ${label}: ${file}`);
+        }
+    }
+}
+function assertSameInventory(expected, actual) {
+    const expectedFiles = Object.keys(expected.inputHashes).sort();
+    const actualFiles = Object.keys(actual.inputHashes).sort();
+    if (JSON.stringify(expectedFiles) !== JSON.stringify(actualFiles))
+        throw new Error("backend pytest collection asset inventory drift");
+    for (const file of expectedFiles) {
+        if (expected.inputHashes[file] !== actual.inputHashes[file])
+            throw new Error(`backend pytest collection hash drift: ${file}`);
+    }
+}
+export async function assertBackendPytestCollectionFresh(workspaceRoot, effective) {
+    if (effective.phase !== "effective" || effective.status !== "PASS") {
+        throw new Error("backend pytest execution requires effective collection PASS facts");
+    }
+    const current = await buildBackendPytestAssetInventory(workspaceRoot, effective.mappedScripts);
+    assertSameInventory(effective, current);
+}
+export async function materializeEffectiveBackendPytestCollection(input) {
+    if (input.initial.status === "PASS") {
+        const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.initial.mappedScripts);
+        assertSameInventory(input.initial, current);
+        return backendPytestCollectionFactsSchema.parse({
+            ...input.initial,
+            phase: "effective",
+            collectionSource: "initial",
+        });
+    }
+    if (input.initial.status === "BLOCKED")
+        throw new Error("backend pytest collection is blocked and not repairable");
+    if (!input.final)
+        throw new Error("backend pytest collection repair requires final collection facts");
+    if (input.final.status !== "PASS")
+        throw new Error("backend pytest collection still fails after bounded repair");
+    await assertBackendPytestRepairSafety(input.workspaceRoot, input.initial, input.final);
+    const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.final.mappedScripts);
+    assertSameInventory(input.final, current);
+    return backendPytestCollectionFactsSchema.parse({
+        ...input.final,
+        phase: "effective",
+        repairEligible: false,
+        repairAttempt: 1,
+        collectionSource: "final",
+    });
+}

package/dist/workflows/dag/convergence/controller.js

@@ -18,7 +18,14 @@ const DEFAULT_CONVERGENCE_CHAIN_NODE_IDS = [
  */
 const REVIEW_GATE_NODE_ID = "review-gate-shell";
 const REVIEW_VERDICT_NODE_ID = "review-verdict-recovery-pi";
-const CONVERGENCE_NON_RETRY_FAILURES = new Set([
+const INITIAL_REVIEW_NODE_ID = "initial-review-pi";
+const INITIAL_REVIEW_GATE_NODE_ID = "initial-review-gate-shell";
+const INITIAL_REVIEW_PASS_NODE_ID = "initial-review-pass-shell";
+// Automatic code repair is authorized only for an ordinary command/test
+// failure. Unknown, protocol, validation, provider, safety, governance, and
+// human-decision categories all fail closed instead of reaching a writer.
+const HARD_VERIFY_REPAIR_ELIGIBLE_FAILURES = new Set(["nonzero-exit"]);
+const REVIEW_SOURCE_NON_RETRY_FAILURES = new Set([
     "timeout",
     "spawn-error",
     "write-guard",
@@ -26,9 +33,6 @@ const CONVERGENCE_NON_RETRY_FAILURES = new Set([
     "auth",
     "human-rejected",
     "decision-gate-requires-human",
-]);
-const REVIEW_SOURCE_NON_RETRY_FAILURES = new Set([
-    ...CONVERGENCE_NON_RETRY_FAILURES,
     "protocol-invalid",
     "invalid-output",
 ]);
@@ -38,26 +42,61 @@ export function shouldEnableDagConvergence(spec) {
 }
 export async function runConvergencePassController(input) {
     const convergence = input.state.convergence;
-    if (!convergence?.enabled)
+    if (!convergence)
         return { retry: false };
     if (process.env.HARNESS_DAG_CONVERGENCE === "off") {
         convergence.terminalReason = "feature-flag-off";
         return { retry: false };
     }
+    if (!convergence.enabled) {
+        return resolveNoRepairTerminal(input);
+    }
     if (!hasConvergenceChain(input.tasksById, input.spec)) {
         convergence.terminalReason = "unsupported-dag-shape";
         return { retry: false };
     }
     const chain = getConvergenceChain(input.spec);
     const observesReview = chain.includes(REVIEW_GATE_NODE_ID);
+    if (input.tasksById.has(INITIAL_REVIEW_NODE_ID)) {
+        const initialReview = input.state.nodes[INITIAL_REVIEW_NODE_ID];
+        const initialGate = input.state.nodes[INITIAL_REVIEW_GATE_NODE_ID];
+        const initialPass = input.state.nodes[INITIAL_REVIEW_PASS_NODE_ID];
+        if (initialReview?.status === "ERROR" || initialGate?.status === "ERROR") {
+            convergence.terminalReason = "non-retry-failure";
+            return { retry: false };
+        }
+        if (initialPass?.status === "FINISHED" &&
+            parseProcessVerdict(initialReview) === "pass") {
+            convergence.terminalReason = "review-pass";
+            return { retry: false };
+        }
+        const repair = input.state.nodes["repair-pi"];
+        if (convergence.currentPass === 1 &&
+            parseProcessVerdict(initialReview) === "request-revision" &&
+            (repair?.status === "FINISHED" || repair?.status === "ERROR")) {
+            // Pass 1 is the initial review. The first executed repair chain is pass 2,
+            // even though the scheduler completes it before the controller first runs.
+            convergence.currentPass = 2;
+        }
+        if (repair?.status === "ERROR") {
+            convergence.terminalReason = "non-retry-failure";
+            return { retry: false };
+        }
+    }
     const hardVerify = input.state.nodes["hard-verify-shell"];
     if (!hardVerify)
         return { retry: false };
     if (hardVerify.status === "ERROR") {
         return handleHardVerifyFailure(input, hardVerify);
     }
-    if (hardVerify.status !== "FINISHED")
+    if (hardVerify.status !== "FINISHED") {
+        // The scheduler has already settled every ordinary rank before invoking
+        // the controller. PENDING/SKIPPED here therefore means an earlier failure
+        // blocked the convergence chain; record a terminal reason so the deferred
+        // failure-aware closeout remains reachable.
+        convergence.terminalReason = "non-retry-failure";
         return { retry: false };
+    }
     // Hard verification passed. When the chain observes a review gate, success
     // is gated on the review verdict: a legitimate `request-revision` re-enters
     // the same bounded repair-reverify-review loop (AC3/AC4). Non-supervised
@@ -74,6 +113,13 @@ export async function runConvergencePassController(input) {
     const reviewGate = input.state.nodes[REVIEW_GATE_NODE_ID];
     if (!reviewGate)
         return { retry: false };
+    // Well-formed request-revision is a convergence routing result: the review
+    // gate finishes successfully (routingAccept) rather than shell ERROR.
+    // Still re-enter the bounded repair chain when revision evidence is valid.
+    if (reviewGate.status === "FINISHED" &&
+        isLegitimateReviewRequestRevision(input.state)) {
+        return handleReviewRequestRevision(input, reviewGate);
+    }
     if (reviewGate.status === "FINISHED") {
         convergence.terminalReason = "review-pass";
         await appendConvergenceKnowledgePattern({
@@ -82,10 +128,50 @@ export async function runConvergencePassController(input) {
         });
         return { retry: false };
     }
+    // Compatibility: gates without routingAccept still ERROR on revision.
     if (reviewGate.status === "ERROR") {
         return handleReviewRequestRevision(input, reviewGate);
     }
-    // Review gate still PENDING/SKIPPED mid-rank: wait for the next loop.
+    // The scheduler pass is settled; an unexecuted gate is a terminal upstream
+    // blockage, not a reason to leave closeout permanently pending.
+    convergence.terminalReason = "non-retry-failure";
+    return { retry: false };
+}
+/**
+ * `maxFixLoops=0` disables writer re-entry, not terminal adjudication. Review
+ * and hard-verify evidence still decide whether closeout is a truthful success
+ * or a bounded failure. Existing handlers are safe here because maxPasses=1,
+ * so they record the terminal pass without resetting any writer nodes.
+ */
+async function resolveNoRepairTerminal(input) {
+    const convergence = input.state.convergence;
+    const reviewGate = input.state.nodes[REVIEW_GATE_NODE_ID];
+    if (reviewGate) {
+        if (reviewGate.status === "FINISHED" &&
+            isLegitimateReviewRequestRevision(input.state)) {
+            return handleReviewRequestRevision(input, reviewGate);
+        }
+        if (reviewGate.status === "FINISHED") {
+            convergence.terminalReason = "review-pass";
+            return { retry: false };
+        }
+        if (reviewGate.status === "ERROR") {
+            return handleReviewRequestRevision(input, reviewGate);
+        }
+        convergence.terminalReason = "non-retry-failure";
+        return { retry: false };
+    }
+    const hardVerify = input.state.nodes["hard-verify-shell"];
+    if (hardVerify?.status === "ERROR") {
+        return handleHardVerifyFailure(input, hardVerify);
+    }
+    if (hardVerify?.status === "FINISHED") {
+        convergence.terminalReason = "hard-verify-pass";
+        return { retry: false };
+    }
+    convergence.terminalReason = hardVerify
+        ? "non-retry-failure"
+        : "unsupported-dag-shape";
     return { retry: false };
 }
 /**
@@ -104,7 +190,7 @@ async function handleHardVerifyFailure(input, hardVerify) {
         runDir: input.runDir,
         spec: input.spec,
     });
-    if (CONVERGENCE_NON_RETRY_FAILURES.has(hardFailure)) {
+    if (!HARD_VERIFY_REPAIR_ELIGIBLE_FAILURES.has(hardFailure)) {
         passRecord.status = "terminal";
         passRecord.reason = "non-retry-failure";
         convergence.passHistory.push(passRecord);
@@ -145,29 +231,32 @@ async function handleHardVerifyFailure(input, hardVerify) {
     await input.persistState();
     return { retry: true };
 }
+function isLegitimateReviewRequestRevision(state) {
+    const reviewNode = state.nodes["review-pi"];
+    const reviewVerdictNode = state.nodes[REVIEW_VERDICT_NODE_ID];
+    return (reviewNode?.status === "FINISHED" &&
+        parseProcessVerdict(reviewNode) === "request-revision" &&
+        reviewVerdictNode?.status === "FINISHED" &&
+        parseProcessVerdict(reviewVerdictNode) === "request-revision");
+}
 /**
- * Hard verification passed but the review gate blocked closeout with a
- * legitimate `request-revision` (review-gate-shell ERRORs when the verdict is
- * not `pass`). Re-enter the same bounded recovery chain so repair can address
- * the review findings, then re-verify and re-review. Review protocol-invalid
- * and invalid-output sources, plus safety failures such as auth/write-guard,
- * stay fail-closed and never enter code repair.
+ * Hard verification passed but the review path produced a legitimate
+ * `request-revision`. With routingAccept the review gate finishes as a routing
+ * result (not shell ERROR); older gates may still ERROR. Re-enter the same
+ * bounded recovery chain so repair can address the findings, then re-verify
+ * and re-review. Protocol/safety failures stay fail-closed.
  */
 async function handleReviewRequestRevision(input, reviewGate) {
     const convergence = input.state.convergence;
     const currentPass = convergence.currentPass || 1;
     const reviewNode = input.state.nodes["review-pi"];
     const reviewVerdictNode = input.state.nodes[REVIEW_VERDICT_NODE_ID];
-    // The gate commonly reports only nonzero-exit. Inspect the complete review
-    // chain so recovery output cannot launder provider/safety/protocol failures
-    // into automatic code repair.
+    // Inspect the complete review chain so recovery output cannot launder
+    // provider/safety/protocol failures into automatic code repair.
     const reviewFailure = [reviewGate, reviewVerdictNode, reviewNode]
         .map((node) => node?.failureCategory)
         .find((category) => category && REVIEW_SOURCE_NON_RETRY_FAILURES.has(category));
-    const legitimateRequestRevision = reviewNode?.status === "FINISHED" &&
-        parseProcessVerdict(reviewNode) === "request-revision" &&
-        reviewVerdictNode?.status === "FINISHED" &&
-        parseProcessVerdict(reviewVerdictNode) === "request-revision";
+    const legitimateRequestRevision = isLegitimateReviewRequestRevision(input.state);
     if (reviewFailure || !legitimateRequestRevision) {
         const passRecord = await buildConvergencePassRecord({
             pass: currentPass,