@tea-agent/loop-agent 0.39.0-beta.11 → 0.39.0-beta.13

package/dist/workflows/dag/node-execution.js

@@ -17,6 +17,7 @@ import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, pars
 import { getStructuredContractValidator } from "./contract-output-registry.js";
 import "./contract-validator-registrations.js";
 import { computeNormalizedFailureFingerprint } from "./frontend-recovery-lineage.js";
+import { parseLedgerJson } from "../../task/source-prepare/ledger.js";
 import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 import { allowedRepairReadPaths, auditRepairAttemptToolUse, buildStructuredOutputRepairPrompt, freezeStructuredOutputRepairContext, hasNonEmptyStructuredCandidate, isFrontendStructuredRepairSchemaId, isStructuredRepairableFailureCategory, persistStructuredAttemptRaw, sessionEventsByteLength, GOVERNANCE_BLOCKED_CATEGORY, STRUCTURED_REPAIR_EXHAUSTED_CATEGORY, } from "./structured-output-repair.js";
 import { readFrontendCanonicalCandidate } from "./frontend-implementation-contract.js";
@@ -221,6 +222,62 @@ export function buildContextOverflowRetryPrompt(task, basePrompt) {
 function isFrontendPlanLadderTask(task) {
     return task.id === FRONTEND_PLAN_NODE_ID;
 }
+/** Contract node consumes the compiled ledger input; local predicate avoids a
+ * dag-pi-executor import cycle. */
+function isFrontendContractTypedNode(task) {
+    return task.id === "frontend-contract-pi";
+}
+/** Resolve the source-fidelity ledger path from a v2 source binding, refusing
+ * any path that escapes the workspace root (mirrors dag-pi-executor). */
+function resolveFrontendLedgerPath(sourceBinding, cwd) {
+    if (!sourceBinding || sourceBinding.schemaVersion !== 2) {
+        throw new Error(`frontend-contract-input-unavailable: sourceBinding v2 ledger required (got ${sourceBinding?.schemaVersion ?? "none"})`);
+    }
+    const absolutePath = path.resolve(cwd, sourceBinding.ledgerPath);
+    const workspaceRoot = path.resolve(cwd);
+    if (absolutePath !== workspaceRoot &&
+        !absolutePath.startsWith(`${workspaceRoot}${path.sep}`)) {
+        throw new Error(`frontend-contract-input-unavailable: ledger path escapes workspace root: ${sourceBinding.ledgerPath}`);
+    }
+    return absolutePath;
+}
+/** record_* submissions observed for the contract node in its session events. */
+const FRONTEND_CONTRACT_RECORD_TOOL_NAMES_LOCAL = new Set([
+    "record_requirement",
+    "record_constraint",
+    "record_evidence_expectation",
+    "record_handoff_intent",
+    "record_open_question",
+    "record_split_proposal",
+]);
+async function countContractRecordSubmissions(runDir, nodeId) {
+    const eventsPath = path.join(runDir, nodeId, "session-events.jsonl");
+    let count = 0;
+    try {
+        for (const line of (await readFile(eventsPath, "utf8")).split("\n")) {
+            if (!line.trim())
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (event !== null &&
+                typeof event === "object" &&
+                event.type === "tool_execution_start" &&
+                typeof event.toolName === "string" &&
+                FRONTEND_CONTRACT_RECORD_TOOL_NAMES_LOCAL.has(event.toolName)) {
+                count += 1;
+            }
+        }
+    }
+    catch {
+        // Missing events file = zero submissions.
+    }
+    return count;
+}
 /**
  * Read the committed plan ledger snapshot for the ladder's "no new committed
  * fact" check. The digest is over the sorted committed payload hashes, and
@@ -254,11 +311,165 @@ function planInputStrings(value) {
         ? value.filter((item) => typeof item === "string")
         : [];
 }
+/** Input bound for the planner evidence block; protects the model input budget. */
+const FRONTEND_PLAN_INPUT_MAX_CHARS = 12_000;
+const FRONTEND_PLAN_INPUT_CAP_LADDER = [
+    { text: 240, array: 40 },
+    { text: 120, array: 20 },
+    { text: 60, array: 10 },
+    { text: 24, array: 4 },
+];
+/**
+ * Frozen requirement→PRD citation map for the plan review checklist: lets the
+ * model declare sourceRequirementIds whose section/line match the component
+ * purpose, so the runtime-derived specReference survives reviewer scrutiny
+ * (r12: 4 of 9 decision=new choices cited a mismatched PRD section).
+ */
+async function resolveComponentSourceCitations(spec, cwd) {
+    const binding = spec.sourceBinding;
+    if (!binding || binding.schemaVersion !== 2 || !binding.ledgerPath)
+        return new Map();
+    const absolutePath = path.resolve(cwd, binding.ledgerPath);
+    const workspaceRoot = path.resolve(cwd);
+    if (absolutePath !== workspaceRoot &&
+        !absolutePath.startsWith(`${workspaceRoot}${path.sep}`))
+        return new Map();
+    try {
+        const ledger = JSON.parse(await readFile(absolutePath, "utf8"));
+        const fragmentsById = new Map((ledger.fragments ?? []).map((fragment) => [fragment.id, fragment]));
+        const references = new Map();
+        for (const requirement of ledger.canonicalRequirements ?? []) {
+            const id = typeof requirement.id === "string" ? requirement.id : "";
+            if (!id)
+                continue;
+            const citations = (requirement.sourceFragmentIds ?? [])
+                .map((fragmentId) => fragmentsById.get(fragmentId))
+                .filter((fragment) => fragment !== undefined)
+                .map((fragment) => ({
+                fragmentId: fragment.id,
+                path: typeof fragment.path === "string" ? fragment.path : "",
+                section: typeof fragment.headingPath === "string"
+                    ? fragment.headingPath
+                    : "",
+                line: typeof fragment.lineRange?.start === "number"
+                    ? fragment.lineRange.start
+                    : undefined,
+            }));
+            if (citations.length > 0)
+                references.set(id, citations);
+        }
+        return references;
+    }
+    catch {
+        return new Map();
+    }
+}
+/** Input bound for the contract node's compiled ledger block. */
+const FRONTEND_CONTRACT_INPUT_MAX_CHARS = 12_000;
+/**
+ * Render the contract node's complete-but-bounded ledger handoff. The
+ * source-fidelity ledger already extracted canonical requirements with source
+ * spans; the contract node confirms and commits them incrementally through
+ * record_requirement instead of re-reading the raw source (extreme-environment:
+ * a small output window cannot absorb a full source re-read).
+ *
+ * Same shape guarantees as the plan input block: always valid JSON under the
+ * char bound, ids never drop, texts degrade through the cap ladder.
+ */
+export function renderFrontendContractInputContext(input) {
+    // Fragment bindings are ids, not prose: they are the one thing the contract
+    // must never lose. r6 regression — the last-resort degradation dropped
+    // sourceFragmentIds entirely, the model (correctly refusing to invent ids)
+    // committed empty bindings, and the plan compile failed the ledger-binding
+    // gate for every requirement. Bindings therefore bypass the cap ladder and
+    // every degradation level; only requirement TEXTS and fragment CONTEXT
+    // (path/headingPath) may degrade. Fragment context is rendered only for
+    // fragments actually referenced by a requirement and shrinks first.
+    const referencedFragmentIds = new Set(input.canonicalRequirements.flatMap((requirement) => planInputStrings(requirement.sourceFragmentIds)));
+    const referencedFragments = input.fragments.filter((fragment) => referencedFragmentIds.has(fragment.id));
+    const serializeAtCap = (cap) => JSON.stringify({
+        requirements: input.canonicalRequirements.map((requirement) => ({
+            id: requirement.id,
+            text: planInputText(requirement.text, cap.text),
+            sourceFragmentIds: planInputStrings(requirement.sourceFragmentIds),
+        })),
+        fragments: referencedFragments.map((fragment) => ({
+            id: fragment.id,
+            path: planInputText(fragment.path, 200),
+            headingPath: planInputText(fragment.headingPath, 120),
+            lineRange: fragment.lineRange,
+        })),
+    });
+    let serialized = serializeAtCap(FRONTEND_PLAN_INPUT_CAP_LADDER[0]);
+    for (const cap of FRONTEND_PLAN_INPUT_CAP_LADDER.slice(1)) {
+        if (serialized.length <= FRONTEND_CONTRACT_INPUT_MAX_CHARS)
+            break;
+        serialized = serializeAtCap(cap);
+    }
+    if (serialized.length > FRONTEND_CONTRACT_INPUT_MAX_CHARS) {
+        // Last resort: keep every requirement id AND its fragment bindings,
+        // degrade texts, and shrink referenced fragment context first (halve,
+        // then drop context fields, then drop the fragment list entirely).
+        // Requirement ids and sourceFragmentIds are never dropped.
+        let fragments = referencedFragments.map((fragment) => ({
+            id: fragment.id,
+            path: planInputText(fragment.path, 120),
+        }));
+        let requirements = input.canonicalRequirements.map((requirement) => {
+            const sourceFragmentIds = planInputStrings(requirement.sourceFragmentIds);
+            return {
+                id: requirement.id,
+                text: "(truncated)",
+                // Empty bindings carry no information; omit them so the payload
+                // stays inside the char bound when no requirement is bound.
+                ...(sourceFragmentIds.length > 0 ? { sourceFragmentIds } : {}),
+            };
+        });
+        let bounded = JSON.stringify({ degraded: "requirement-texts-truncated", requirements, fragments });
+        while (bounded.length > FRONTEND_CONTRACT_INPUT_MAX_CHARS && fragments.length > 0) {
+            fragments = fragments.slice(0, Math.floor(fragments.length / 2));
+            bounded = JSON.stringify({
+                degraded: "requirement-texts-truncated",
+                requirements,
+                fragments,
+            });
+        }
+        serialized = bounded;
+    }
+    return [
+        "<frontend_contract_input>",
+        "Canonical requirements extracted by the source-fidelity ledger, compiled by the runner. Treat them as the authoritative requirement inventory: confirm and commit each requirement through record_requirement (one per tool call); the ledger already binds source fragments, so do NOT re-read the raw source files.",
+        serialized,
+        "</frontend_contract_input>",
+    ].join("\n");
+}
+export async function buildFrontendContractInputContext(input) {
+    const ledger = parseLedgerJson(await readFile(input.ledgerPath, "utf8"));
+    return renderFrontendContractInputContext({
+        canonicalRequirements: ledger.canonicalRequirements.map((requirement) => ({
+            id: requirement.id,
+            text: requirement.text,
+            sourceFragmentIds: requirement.sourceFragmentIds ?? [],
+        })),
+        fragments: ledger.fragments.map((fragment) => ({
+            id: fragment.id,
+            path: fragment.path,
+            headingPath: fragment.headingPath,
+            lineRange: fragment.lineRange,
+        })),
+    });
+}
 /**
  * Render the planner's complete-but-bounded evidence handoff from committed
  * typed facts. It deliberately excludes upstream response prose and artifact
  * paths: Contract and Scout have already established these facts, so Plan
  * should decide and commit rather than spend another model turn reading them.
+ *
+ * The block is always valid JSON under the char bound: field texts shrink
+ * through a cap ladder before any fact is dropped, and the last-resort
+ * fallback keeps every requirement id (with `text: "(truncated)"`) while
+ * declaring the degradation, so the planner records targeted evidence gaps
+ * instead of receiving a silently corrupted tail.
  */
 export function renderFrontendPlanInputContext(input) {
     const committedFacts = (records) => records.flatMap((record) => record.phase === "committed" && planInputRecord(record.fact)
@@ -277,45 +488,143 @@ export function renderFrontendPlanInputContext(input) {
     const targetSurface = scoutFacts
         .filter((fact) => fact.kind === "target-surface" && fact.origin === "scout")
         .map((fact) => ({
-        completeness: planInputText(fact.completeness, 32),
-        entrypoint: planInputText(fact.entrypoint, 240),
-        routeOrMount: planInputText(fact.routeOrMount, 240),
-        implementationPaths: planInputStrings(fact.implementationPaths),
-        testPaths: planInputStrings(fact.testPaths),
-        dataSource: planInputText(fact.dataSource),
-        allowedPathConflicts: planInputStrings(fact.allowedPathConflicts),
-        unresolvedPaths: planInputStrings(fact.unresolvedPaths),
+        completeness: fact.completeness,
+        entrypoint: fact.entrypoint,
+        routeOrMount: fact.routeOrMount,
+        implementationPaths: fact.implementationPaths,
+        testPaths: fact.testPaths,
+        dataSource: fact.dataSource,
+        allowedPathConflicts: fact.allowedPathConflicts,
+        unresolvedPaths: fact.unresolvedPaths,
     }));
     const designEvidence = scoutFacts
         .filter((fact) => fact.kind === "design-evidence" && fact.origin === "scout")
         .map((fact) => ({
-        source: planInputText(fact.source),
-        paths: planInputStrings(fact.paths),
-        conflicts: planInputStrings(fact.conflicts),
+        source: fact.source,
+        paths: fact.paths,
+        conflicts: fact.conflicts,
     }));
-    const serialized = JSON.stringify({ requirements, targetSurface, designEvidence });
-    const bounded = serialized.length <= 12_000
-        ? serialized
-        : `${serialized.slice(0, 11_999)}…`;
+    // Reviewer-rubric scaffold: the design reviewer re-runs the design-policy
+    // checks on the committed facts, so publish the checklist to the producer.
+    // Requirements whose contract evidence expects behavioural verification are
+    // enumerated explicitly — those are the slots the reviewer finds missing
+    // when the plan models interactions ad hoc (r8/r9 findings).
+    const behaviorRequiredIds = requirements
+        .filter((requirement) => {
+        const fact = contractFacts.find((candidate) => candidate.kind === "requirement" &&
+            candidate.origin === "contract" &&
+            candidate.id === requirement.id);
+        const evidence = fact?.evidence;
+        return evidence?.behavior === "required";
+    })
+        .map((requirement) => requirement.id);
+    const serializeAtCap = (cap) => JSON.stringify({
+        requirements: requirements.map((requirement) => ({
+            id: requirement.id,
+            text: planInputText(requirement.text, cap.text),
+            sourceFragmentIds: planInputStrings(requirement.sourceFragmentIds).slice(0, cap.array),
+        })),
+        targetSurface: targetSurface.map((surface) => ({
+            completeness: planInputText(surface.completeness, 32),
+            entrypoint: planInputText(surface.entrypoint, cap.text),
+            routeOrMount: planInputText(surface.routeOrMount, cap.text),
+            implementationPaths: planInputStrings(surface.implementationPaths).slice(0, cap.array),
+            testPaths: planInputStrings(surface.testPaths).slice(0, cap.array),
+            dataSource: planInputText(surface.dataSource, cap.text),
+            allowedPathConflicts: planInputStrings(surface.allowedPathConflicts).slice(0, cap.array),
+            unresolvedPaths: planInputStrings(surface.unresolvedPaths).slice(0, cap.array),
+        })),
+        designEvidence: designEvidence.map((evidence) => ({
+            source: planInputText(evidence.source, cap.text),
+            paths: planInputStrings(evidence.paths).slice(0, cap.array),
+            conflicts: planInputStrings(evidence.conflicts).slice(0, cap.array),
+        })),
+    });
+    let serialized = serializeAtCap(FRONTEND_PLAN_INPUT_CAP_LADDER[0]);
+    for (const cap of FRONTEND_PLAN_INPUT_CAP_LADDER.slice(1)) {
+        if (serialized.length <= FRONTEND_PLAN_INPUT_MAX_CHARS)
+            break;
+        serialized = serializeAtCap(cap);
+    }
+    if (serialized.length > FRONTEND_PLAN_INPUT_MAX_CHARS) {
+        // Last resort: keep every requirement id (ids are short and the plan
+        // prompt separately lists them) but drop their texts, shrink scout facts
+        // to the minimum, and declare the degradation instead of corrupting JSON.
+        let fallback = {
+            degraded: "requirement-texts-truncated",
+            requirements: requirements.map((requirement) => ({
+                id: requirement.id,
+                text: "(truncated)",
+            })),
+            targetSurface: targetSurface.map((surface) => ({
+                completeness: planInputText(surface.completeness, 32),
+                implementationPaths: planInputStrings(surface.implementationPaths).slice(0, FRONTEND_PLAN_INPUT_CAP_LADDER[3].array),
+            })),
+            designEvidence: [],
+        };
+        let bounded = JSON.stringify(fallback);
+        let keep = fallback.requirements.length;
+        while (bounded.length > FRONTEND_PLAN_INPUT_MAX_CHARS &&
+            keep > 0) {
+            keep = Math.max(0, Math.floor(keep / 2));
+            fallback = { ...fallback, requirements: fallback.requirements.slice(0, keep) };
+            bounded = JSON.stringify({
+                ...fallback,
+                requirementIdsTruncated: keep < requirements.length,
+            });
+        }
+        serialized = bounded;
+    }
+    const checklistLines = [
+        "1. Every interaction you record needs a uiComponentChoices entry whose purpose equals the interaction name, or one decision=reuse-existing choice covering behavioural interactions.",
+        "2. Every applicable UI state needs a purpose-matching component choice or a stylingStrategy.",
+        "3. Every requirement marked (behavior) below needs modelled interactions plus at least one verification target that references it.",
+        "4. targets.files must name the concrete deliverable files; never leave the scope broader than the frozen requirements state.",
+        "5. Verification targets may only reference UI states and requirements you actually recorded (the record_* tools reject unknown references).",
+        `Requirements requiring behavioural coverage: ${behaviorRequiredIds.length > 0 ? behaviorRequiredIds.join(", ") : "(none)"}`,
+        "6. A decision=new component must declare sourceRequirementIds and pass sourceFragmentId for the frozen PRD fragment whose section matches the component's purpose — the runtime validates that binding and derives specReference (path/section/line); the reviewer checks purpose↔citation consistency.",
+        ...[...input.componentSourceCitations ?? []]
+            .filter(([id]) => behaviorRequiredIds.includes(id))
+            .flatMap(([id, citations]) => citations.map((citation) => `   ${id} + ${citation.fragmentId} → ${citation.section}${citation.line ? ` (line ${citation.line})` : ""}`)),
+    ];
     return [
         "<frontend_plan_input>",
         "Committed Contract/Scout facts, compiled by the runner. Treat them as the complete planning evidence.",
-        bounded,
+        serialized,
         "Do not read upstream artifacts, task sources, or repository files. If this input cannot support a decision, record a genuine evidence gap.",
         "</frontend_plan_input>",
+        "<plan_review_checklist>",
+        "The design reviewer re-runs these exact checks on the committed facts; satisfy every line before finalize_plan:",
+        ...checklistLines,
+        "</plan_review_checklist>",
     ].join("\n");
 }
-async function buildFrontendPlanInputContext(runDir) {
+export async function buildFrontendPlanInputContext(runDir, componentSourceCitations) {
+    const contractFactsPath = path.join(runDir, "frontend-contract-pi", "contract-typed-facts.jsonl");
+    const scoutFactsPath = path.join(runDir, "frontend-scout-pi", "scout-typed-facts.jsonl");
+    let contractRecords;
+    let scoutRecords;
     try {
-        const [contractRecords, scoutRecords] = await Promise.all([
-            readTypedEventStoreFromJsonl(path.join(runDir, "frontend-contract-pi", "contract-typed-facts.jsonl")),
-            readTypedEventStoreFromJsonl(path.join(runDir, "frontend-scout-pi", "scout-typed-facts.jsonl")),
+        [contractRecords, scoutRecords] = await Promise.all([
+            readTypedEventStoreFromJsonl(contractFactsPath),
+            readTypedEventStoreFromJsonl(scoutFactsPath),
         ]);
-        return renderFrontendPlanInputContext({ contractRecords, scoutRecords });
     }
-    catch {
-        return "";
+    catch (error) {
+        // A missing/unreadable upstream store is a broken pipeline, not an
+        // evidence gap; fail before spending a model turn on a prompt that
+        // forbids reading anything.
+        throw new Error(`frontend-plan-input-unavailable: cannot read committed typed facts (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const committedCount = [...contractRecords, ...scoutRecords].filter((record) => record.phase === "committed").length;
+    if (committedCount === 0) {
+        throw new Error(`frontend-plan-input-unavailable: no committed Contract/Scout facts in ${contractFactsPath} / ${scoutFactsPath}`);
     }
+    return renderFrontendPlanInputContext({
+        contractRecords,
+        scoutRecords,
+        componentSourceCitations,
+    });
 }
 export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics, frontendPlanRetryStep) {
     if (attemptNumber <= 1)
@@ -1018,9 +1327,36 @@ export async function executeDagNode(input) {
         return;
     }
     if (isFrontendPlanLadderTask(task)) {
-        const planInputContext = await buildFrontendPlanInputContext(runDir);
-        if (planInputContext)
-            prompt = `${prompt}\n\n${planInputContext}`;
+        let planInputContext;
+        try {
+            const componentSourceCitations = await resolveComponentSourceCitations(spec, cwd);
+            planInputContext = await buildFrontendPlanInputContext(runDir, componentSourceCitations);
+        }
+        catch (error) {
+            await failBeforePrompt(error, "frontend-plan-input-unavailable");
+            return;
+        }
+        prompt = `${prompt}\n\n${planInputContext}`;
+    }
+    if (isFrontendContractTypedNode(task)) {
+        // Extreme-environment input handoff: compile the ledger's canonical
+        // requirements into a bounded block so the contract node never re-reads
+        // the raw source (mirrors the plan node's compiled input; its tool set
+        // is record_* + finalize_contract, no read tools).
+        let contractInputContext;
+        try {
+            const ledgerPath = resolveFrontendLedgerPath(spec.sourceBinding, cwd);
+            contractInputContext = await buildFrontendContractInputContext({
+                ledgerPath,
+            });
+            prompt = `${prompt}\n\n${contractInputContext}`;
+        }
+        catch (error) {
+            // Ledger unreadable is a broken pipeline: fail before spending a
+            // model turn on a prompt that forbids reading anything.
+            await failBeforePrompt(error, "frontend-contract-input-unavailable");
+            return;
+        }
     }
     node.resolvedSkills = resolvedSkills;
     await writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills);
@@ -1321,6 +1657,28 @@ export async function executeDagNode(input) {
                 prompt: promptRestartCandidate,
             });
         }
+        // C: contract incremental-progress guard. A failed contract attempt that
+        // committed zero record_* submissions is a "no-progress" failure, not an
+        // opaque timeout/error: normalize it to empty-output so the retryPolicy
+        // retries with the incremental-commit discipline instead of burning the
+        // remaining attempts on the same stalled behavior.
+        if (isFrontendContractTypedNode(task) &&
+            !result.ok &&
+            retryPolicy !== undefined) {
+            const submissions = await countContractRecordSubmissions(runDir, nodeId);
+            if (submissions === 0) {
+                result = {
+                    ...result,
+                    failureCategory: "empty-output",
+                    stderr: [
+                        result.stderr,
+                        "contract attempt failed with zero record_* submissions; retrying with incremental-commit discipline (one record_* call per message, starting from the first tool call)",
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                };
+            }
+        }
         const attemptRecord = {
             attempt: attemptNumber,
             startedAt: attemptStartedAt,

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

@@ -3,6 +3,7 @@ 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;
@@ -201,6 +202,127 @@ async function readTypedDesignRequestFact(runDir) {
         },
     };
 }
+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.
@@ -225,15 +347,25 @@ export async function deriveDagRerunFeedback(input) {
         // 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).
+        // 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 readTypedDesignRequestFact(input.runDir)) ??
+            (await readAncestorTypedRequestFact(input.runDir));
         if (typedFact) {
             const parentSourceBindingHash = sourceBindingHash(input.spec);
             return withDigest({
                 schemaVersion: 1,
                 kind: "unresolved-terminal-feedback",
-                parentRunId: input.parentRunId,
+                parentRunId: "parentRunId" in typedFact &&
+                    typeof typedFact.parentRunId === "string"
+                    ? typedFact.parentRunId
+                    : input.parentRunId,
                 taskId: input.taskId,
                 sourceNodeId: typedFact.nodeId,
                 verdict: "request-revision",