@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.11

package/dist/workflows/dag/prompt.js

@@ -19,6 +19,40 @@ const RERUN_FEEDBACK_ROLES = new Set([
     "verifier",
     "reviewer",
 ]);
+function globPatternToRegExp(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    let source = "";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index];
+        if (char === "*" && normalized[index + 1] === "*") {
+            source += ".*";
+            index += 1;
+        }
+        else if (char === "*") {
+            source += "[^/]*";
+        }
+        else {
+            source += char.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+function readSetAllowsArtifactPath(task, artifactPath) {
+    const readSet = task.readSet ?? [];
+    if (readSet.length === 0)
+        return true;
+    const candidate = artifactPath.replace(/\\/g, "/");
+    const candidates = [candidate];
+    for (const marker of ["/.harness/", "/source/", "/testcase/"]) {
+        const index = candidate.indexOf(marker);
+        if (index >= 0)
+            candidates.push(candidate.slice(index + 1));
+    }
+    return readSet.some((pattern) => {
+        const regex = globPatternToRegExp(pattern);
+        return candidates.some((value) => regex.test(value));
+    });
+}
 function formatBulletList(items, emptyLabel) {
     if (!items || items.length === 0)
         return emptyLabel;
@@ -46,9 +80,42 @@ function formatResolvedSkillInstructions(instructions) {
     if (!instructions || instructions.length === 0)
         return "(none)";
     return instructions
-        .map((instruction) => instruction.promptText)
+        .map((instruction) => formatSkillChecklist(instruction))
         .join("\n\n---\n\n");
 }
+/** Keep skill provenance, but turn bounded inline manuals into a small action list. */
+function formatSkillChecklist(instruction) {
+    const metadata = [
+        `Skill: ${instruction.name}`,
+        `Resolution: ${instruction.resolution}`,
+        ...(instruction.path ? [`Path: ${instruction.path}`] : []),
+        ...(instruction.sha256 ? [`Sha256: ${instruction.sha256}`] : []),
+        "Injection mode: checklist",
+    ];
+    if (instruction.resolution !== "resolved")
+        return [...metadata, instruction.promptText].join("\n");
+    const source = instruction.promptText.split("Instructions:\n")[1] ?? "";
+    const candidates = source
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^(?:#{1,3}\s+|[-*]\s+|\d+[.)]\s+)/.test(line) || line.length > 0)
+        .map((line) => line.replace(/^#{1,3}\s+/, "").replace(/^[-*]\s+/, "").replace(/^\d+[.)]\s+/, ""))
+        .filter((line) => line.length > 0);
+    const checklist = [];
+    let chars = 0;
+    for (const item of candidates) {
+        const bounded = item.slice(0, 240);
+        if (checklist.length >= 10 || chars + bounded.length > 1_600)
+            break;
+        checklist.push(`- ${bounded}`);
+        chars += bounded.length;
+    }
+    return [
+        ...metadata,
+        "Checklist (apply these actions; consult the immutable resolved file only when a listed action requires detail):",
+        ...(checklist.length > 0 ? checklist : ["- Follow the resolved skill's declared workflow."]),
+    ].join("\n");
+}
 export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE) {
     if (language === "en") {
         return [
@@ -96,7 +163,7 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
                 : artifactKind === "assistant"
                     ? record.assistantArtifactPath
                     : undefined;
-            if (truncated && artifactPath) {
+            if (truncated && artifactPath && readSetAllowsArtifactPath(task, artifactPath)) {
                 section += formatUpstreamArtifactPointerMap(record, artifactKind === "stdout" ? "stdout" : "assistant");
             }
             else if (truncated && record.nodeRecordPath) {
@@ -172,7 +239,7 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
         if (consumedArtifactSection) {
             section += `\n\n${consumedArtifactSection}`;
         }
-        if (truncated && artifactPath) {
+        if (truncated && artifactPath && readSetAllowsArtifactPath(task, artifactPath)) {
             section += formatUpstreamArtifactPointerMap(record, artifactKind);
         }
         sections.push(section);

package/dist/workflows/dag/recovery-lease.js

@@ -0,0 +1,170 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { hostname as localHostname } from "node:os";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { DAG_RUNS_DIR } from "./lifecycle.js";
+function recoveryLeasePath(cwd, parentRunId) {
+    // Never derive a filesystem name directly from an externally supplied legacy
+    // run id. The content remains auditable while the filename is traversal-safe.
+    const key = createHash("sha256").update(parentRunId).digest("hex");
+    return path.join(cwd, DAG_RUNS_DIR, ".recovery-leases", `${key}.json`);
+}
+function parseLease(raw, parentRunId) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("invalid dag recovery lease: expected object");
+    }
+    const record = raw;
+    if (record.schemaVersion !== 1 ||
+        record.parentRunId !== parentRunId ||
+        typeof record.requestId !== "string" ||
+        record.requestId.length === 0 ||
+        (record.kind !== "auto-frontend-recovery" &&
+            record.kind !== "rerun-from-node" &&
+            record.kind !== "standalone-task-rerun") ||
+        typeof record.leaseToken !== "string" ||
+        record.leaseToken.length === 0 ||
+        typeof record.ownerPid !== "number" ||
+        !Number.isInteger(record.ownerPid) ||
+        record.ownerPid <= 0 ||
+        typeof record.ownerHostname !== "string" ||
+        record.ownerHostname.length === 0 ||
+        typeof record.acquiredAt !== "string" ||
+        typeof record.executionRef !== "undefined" &&
+            typeof record.executionRef !== "string") {
+        throw new Error("invalid dag recovery lease: schema mismatch");
+    }
+    return record;
+}
+const LEASE_MUTATION_LOCK_STALE_MS = 60_000;
+const LEASE_MUTATION_LOCK_RETRIES = 200;
+async function withLeaseMutationLock(leasePath, operation) {
+    const lockPath = `${leasePath}.mutation-lock`;
+    for (let attempt = 0; attempt < LEASE_MUTATION_LOCK_RETRIES; attempt += 1) {
+        try {
+            await mkdir(lockPath);
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+                throw error;
+            }
+            try {
+                const lockStat = await stat(lockPath);
+                if (Date.now() - lockStat.mtimeMs >= LEASE_MUTATION_LOCK_STALE_MS) {
+                    await rm(lockPath, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch (statError) {
+                if (statError &&
+                    typeof statError === "object" &&
+                    "code" in statError &&
+                    statError.code === "ENOENT") {
+                    continue;
+                }
+                throw statError;
+            }
+            await delay(10);
+            continue;
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            await rm(lockPath, { recursive: true, force: true });
+        }
+    }
+    throw new Error("dag recovery lease mutation lock is busy");
+}
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function leaseOwnerIsAlive(input) {
+    if (input.lease.ownerHostname !== input.hostname)
+        return true;
+    return input.isProcessAlive(input.lease.ownerPid);
+}
+export async function acquireDagRecoveryLease(input) {
+    const leasePath = recoveryLeasePath(input.cwd, input.parentRunId);
+    const lease = {
+        schemaVersion: 1,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        kind: input.kind,
+        leaseToken: randomBytes(16).toString("hex"),
+        ownerPid: process.pid,
+        ownerHostname: localHostname(),
+        acquiredAt: (input.now ?? (() => new Date()))().toISOString(),
+    };
+    await mkdir(path.dirname(leasePath), { recursive: true });
+    try {
+        // `wx` is the cross-process compare-and-create primitive. The lease is
+        // parent-scoped for the full recovery lineage. Ownership may only be
+        // replaced by claimDagRecoveryLease after the recorded owner is proven dead.
+        await writeFile(leasePath, `${JSON.stringify(lease, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        return { kind: "acquired", leasePath, lease };
+    }
+    catch (error) {
+        if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+            throw error;
+        }
+        const existing = parseLease(JSON.parse(await readFile(leasePath, "utf8")), input.parentRunId);
+        return { kind: "held", leasePath, lease: existing };
+    }
+}
+/**
+ * Reclaim a lease only after its recorded same-host owner is proven dead.
+ * The mutation lock serializes reclaim with execution binding, so a live owner
+ * can never race a stale-owner takeover and launch a second recovery.
+ */
+export async function claimDagRecoveryLease(input) {
+    const hostname = input.hostname ?? localHostname();
+    const isProcessAlive = input.isProcessAlive ?? defaultIsProcessAlive;
+    return withLeaseMutationLock(input.leasePath, async () => {
+        const existing = parseLease(JSON.parse(await readFile(input.leasePath, "utf8")), input.lease.parentRunId);
+        if (existing.leaseToken !== input.lease.leaseToken ||
+            leaseOwnerIsAlive({ lease: existing, hostname, isProcessAlive })) {
+            return { kind: "held", leasePath: input.leasePath, lease: existing };
+        }
+        const claimed = {
+            ...existing,
+            leaseToken: randomBytes(16).toString("hex"),
+            ownerPid: process.pid,
+            ownerHostname: hostname,
+            acquiredAt: (input.now ?? (() => new Date()))().toISOString(),
+        };
+        await writeJsonAtomic(input.leasePath, claimed);
+        return { kind: "acquired", leasePath: input.leasePath, lease: claimed };
+    });
+}
+/** Persist the operation/run identity before the caller is allowed to execute it. */
+export async function bindDagRecoveryLeaseExecution(input) {
+    if (!input.executionRef.trim()) {
+        throw new Error("dag recovery lease executionRef is required");
+    }
+    return withLeaseMutationLock(input.leasePath, async () => {
+        const existing = parseLease(JSON.parse(await readFile(input.leasePath, "utf8")), input.lease.parentRunId);
+        if (existing.leaseToken !== input.lease.leaseToken) {
+            throw new Error("dag recovery lease ownership drift");
+        }
+        if (existing.executionRef && existing.executionRef !== input.executionRef) {
+            throw new Error("dag recovery lease execution identity drift");
+        }
+        const bound = {
+            ...existing,
+            executionRef: input.executionRef,
+        };
+        await writeJsonAtomic(input.leasePath, bound);
+        return bound;
+    });
+}

package/dist/workflows/dag/report.js

@@ -125,6 +125,8 @@ const dagNodeArtifactsReportSchema = z
     humanEscalationMd: dagArtifactRefSchema,
     humanApproval: dagArtifactRefSchema,
     humanRejection: dagArtifactRefSchema,
+    changeManifest: dagArtifactRefSchema,
+    changeManifestChangedFiles: z.array(z.string()).optional(),
 })
     .strict();
 const dagNodeReportRowSchema = z
@@ -259,6 +261,20 @@ export async function probeArtifact(filePath) {
 export async function buildNodeArtifactsReport(runDir, nodeId) {
     const nodeDir = path.join(runDir, nodeId);
     const artifact = (name) => probeArtifact(path.join(nodeDir, name));
+    const changeManifestRef = await artifact("change-manifest.json");
+    let changeManifestChangedFiles;
+    if (changeManifestRef.exists) {
+        try {
+            const manifest = JSON.parse(await readFile(path.join(nodeDir, "change-manifest.json"), "utf-8"));
+            changeManifestChangedFiles = Array.isArray(manifest.changedFiles)
+                ? manifest.changedFiles
+                    .filter((item) => typeof item === "string")
+                : undefined;
+        }
+        catch {
+            // unreadable manifest → leave undefined
+        }
+    }
     return {
         resultSummary: await artifact("result.summary.md"),
         promptRedacted: await artifact("prompt.redacted.md"),
@@ -270,6 +286,8 @@ export async function buildNodeArtifactsReport(runDir, nodeId) {
         humanEscalationMd: await artifact("human-escalation.md"),
         humanApproval: await artifact("human-approval.json"),
         humanRejection: await artifact("human-rejection.json"),
+        changeManifest: changeManifestRef,
+        changeManifestChangedFiles,
     };
 }
 function taskById(spec) {
@@ -726,6 +744,12 @@ function formatArtifactFlags(artifacts) {
         flags.push("approval");
     if (artifacts.humanRejection.exists)
         flags.push("rejection");
+    if (artifacts.changeManifest.exists) {
+        const count = artifacts.changeManifestChangedFiles?.length;
+        flags.push(count !== undefined
+            ? `changed:${count}`
+            : "change-manifest");
+    }
     return flags.length > 0 ? flags.join(",") : "-";
 }
 function formatTimestamp(value) {
@@ -749,7 +773,19 @@ function summarizeNodeStatuses(nodes) {
     return `${total} total / ${finished} finished / ${failed} failed / ${skipped} skipped / ${pending} pending`;
 }
 function hasArtifact(artifacts) {
-    return Object.values(artifacts).some((artifact) => artifact.exists);
+    return [
+        artifacts.resultSummary,
+        artifacts.promptRedacted,
+        artifacts.skills,
+        artifacts.nodeRecord,
+        artifacts.decisionEnvelope,
+        artifacts.decisionEnvelopeValidation,
+        artifacts.humanEscalationJson,
+        artifacts.humanEscalationMd,
+        artifacts.humanApproval,
+        artifacts.humanRejection,
+        artifacts.changeManifest,
+    ].some((artifact) => artifact.exists);
 }
 function failureRows(run) {
     return run.nodes.filter((node) => node.status === "ERROR" ||

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);