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

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

@@ -1,3 +1,5 @@
+import { reserveTaskSourceProviderRequest } from "../../task/source-prepare/source-provider-budget.js";
+import { frontendPlanSemanticDigest } from "./frontend-plan-progress.js";
 import { collectFrontendExecutionGroups } from "./frontend-execution-groups.js";
 import { reserveDagProviderRequest } from "./budget-enforcement.js";
 import { createHash } from "node:crypto";
@@ -374,15 +376,11 @@ async function countContractRecordSubmissions(runDir, nodeId) {
  * `hasTerminalFact` reflects a committed `finalize_plan` terminal fact.
  */
 async function readFrontendPlanCommittedSnapshot(runDir, nodeId) {
-    const records = await readTypedEventStoreFromJsonl(path.join(runDir, nodeId, "plan-typed-facts.jsonl"));
-    const committed = records.filter((record) => record.phase === "committed");
-    const digest = createHash("sha256")
-        .update(committed
-        .map((record) => record.payloadSha256)
-        .sort()
-        .join("\n"))
-        .digest("hex");
-    const hasTerminalFact = committed.some((record) => record.fact.kind === "finalize_plan");
+    const decisions = await readTypedEventStoreFromJsonl(path.join(runDir, nodeId, "plan-decision-facts.jsonl"));
+    const records = decisions.some(r => r.phase === "committed") ? decisions : await readTypedEventStoreFromJsonl(path.join(runDir, nodeId, "plan-typed-facts.jsonl"));
+    const committed = records.filter(record => record.phase === "committed");
+    const digest = frontendPlanSemanticDigest(committed);
+    const hasTerminalFact = committed.some((record) => ["finalize_plan", "finalize_decision"].includes(String(record.fact.kind)));
     return { digest, hasTerminalFact };
 }
 function planInputRecord(value) {
@@ -1564,6 +1562,7 @@ export async function executeDagNode(input) {
         // evidence so a late best-effort write cannot recreate an archived run dir.
         void input.persistState().catch(() => { });
     };
+    const scoutCompletedShards = task.id === "frontend-scout-pi" && isSafeReadOnlyPiRetryCandidate(task) ? new Map() : undefined;
     let terminalResult;
     let previousFailureCategory;
     let previousProtocolReason;
@@ -1665,7 +1664,8 @@ export async function executeDagNode(input) {
                 attemptPrompt,
             });
             result = await executeNode({
-                ...(state.budgetLedger?.mode === "hard" && state.budgetLedger.limits.maxProviderRequests !== undefined ? { reserveProviderRequest: () => reserveDagProviderRequest({ state, nodeId, attempt: attemptNumber, persist: input.persistState }) } : {}),
+                ...(scoutCompletedShards ? { scoutCompletedShards } : {}),
+                ...(state.budgetLedger?.mode === "hard" && state.budgetLedger.limits.maxProviderRequests !== undefined ? { reserveProviderRequest: () => reserveDagProviderRequest({ state, nodeId, attempt: attemptNumber, persist: input.persistState, ...(spec.sourceProviderBudget ? { reserveTaskRequest: () => reserveTaskSourceProviderRequest({ repoRoot: cwd, taskId: spec.sourceProviderBudget.ledger.taskId, maxProviderRequests: spec.sourceProviderBudget.ledger.maxProviderRequests, expectedBudgetId: spec.sourceProviderBudget.ledger.budgetId, minimumReservedRequests: spec.sourceProviderBudget.ledger.reservedRequests }) } : {}) }) } : {}),
                 task,
                 cwd,
                 model,
@@ -1906,7 +1906,7 @@ export async function executeDagNode(input) {
         // reason, detect new committed facts, and escalate instead of re-running.
         if (frontendPlanLadderEnabled && !result.ok) {
             const afterSnapshot = await readFrontendPlanCommittedSnapshot(runDir, nodeId);
-            const hasNewCommittedFact = beforeCommittedDigest !== undefined &&
+            const hasNewCommittedFact = !result.stderr?.includes("FRONTEND_PLAN_NO_PROGRESS") && beforeCommittedDigest !== undefined &&
                 afterSnapshot.digest !== beforeCommittedDigest;
             const protocolReason = projectFrontendNodeProtocolFailureReason({
                 failureCategory: result.failureCategory,

package/dist/workflows/dag/output-protocol.js

@@ -39,6 +39,7 @@ const reviewFindingSchema = z
     line: z.number().int().positive().optional(),
     issue: z.string().min(1),
     requiredChange: z.string().min(1).optional(),
+    repairAssertions: z.array(z.record(z.unknown())).optional(),
 })
     .strict();
 const reviewJsonVerdictSchema = z

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

@@ -1,9 +1,10 @@
+import { z } from "zod";
 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";
+import { readTypedEventStoreFromJsonl, reviewFindingSchema } 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;
@@ -236,6 +237,35 @@ async function readCommittedTerminalKind(input) {
     }
     return undefined;
 }
+/** Current rejecting terminal, with final-review approval as a barrier to
+ * older design findings. Binds snapshot consumers to the actual ledger bytes. */
+export async function readCurrentFrontendRepairFindings(runDir) {
+    for (const [sourceNodeId, file, approveKind, rejectKind] of [
+        [FRONTEND_REVIEW_NODE_ID, "review-typed-facts.jsonl", "approve_review", "request_review_changes"],
+        [FRONTEND_DESIGN_REVIEW_NODE_ID, "design-typed-facts.jsonl", "approve_design", "request_design_changes"],
+    ]) {
+        const ledger = path.join(runDir, sourceNodeId, file);
+        let raw;
+        try {
+            raw = await readFile(ledger, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+        const terminal = (await readTypedEventStoreFromJsonl(ledger)).filter(record => record.phase === "committed" && [approveKind, rejectKind].includes(String(record.fact.kind))).at(-1);
+        if (!terminal)
+            continue;
+        const { sha256OfCanonicalJson } = await import("../../task/contract/hash.js");
+        if (terminal.payloadSha256 !== sha256OfCanonicalJson(terminal.fact))
+            throw new Error("frontend repair terminal payload hash mismatch");
+        const verdict = terminal.fact.kind === approveKind ? "approve" : "request";
+        const findings = verdict === "request" ? z.array(reviewFindingSchema).parse(terminal.fact.findings) : [];
+        return { sourceNodeId, ledgerSha256: sha256(raw), terminalEventId: terminal.eventId, verdict, findings, fact: terminal.fact };
+    }
+    return undefined;
+}
 async function readReviewTerminalKind(runDir) {
     return readCommittedTerminalKind({
         runDir,
@@ -354,9 +384,10 @@ export async function deriveDagRerunFeedback(input) {
         // 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));
+        const current = await readCurrentFrontendRepairFindings(input.runDir);
+        if (current?.verdict === "approve")
+            return undefined;
+        const typedFact = current ? { nodeId: current.sourceNodeId, fact: current.fact } : await readAncestorTypedRequestFact(input.runDir);
         if (typedFact) {
             const parentSourceBindingHash = sourceBindingHash(input.spec);
             return withDigest({

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

@@ -1,3 +1,4 @@
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
 import { access, mkdir, readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
@@ -28,7 +29,7 @@ export function parseDagRerunTaskArgs(args) {
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined)
-            break;
+            throw new Error("dag rerun-task argument is missing");
         if (arg === "--run-id")
             parentRunId = args[++index];
         else if (arg.startsWith("--run-id="))
@@ -103,6 +104,9 @@ async function readFrontendRecoveryDescriptor(runDir, parentRunId, requestId) {
         plan.schemaVersion !== 1 ||
         plan.parentRunId !== parentRunId ||
         plan.requestId !== requestId ||
+        plan.failureSource !== raw.failureSource ||
+        plan.failureOwner !== raw.failureOwner ||
+        plan.resetRootNodeId !== raw.resetRootNodeId ||
         !Array.isArray(plan.resetNodeIds) ||
         !Array.isArray(plan.importedNodeIds)) {
         throw new Error("frontend recovery descriptor is invalid or unbound");
@@ -126,6 +130,8 @@ function buildFrontendRecoveryIntent(input) {
         attemptIndex: input.parentRecovery?.attemptIndex ?? 0,
         continuationCount: input.parentRecovery?.continuationCount ?? 0,
         failureSource: input.failureSource,
+        ...(input.failureOwner ? { failureOwner: input.failureOwner } : {}),
+        ...(input.resetRootNodeId ? { resetRootNodeId: input.resetRootNodeId } : {}),
         revision: 0,
     };
 }
@@ -391,6 +397,8 @@ async function executeFrontendRecoveryContinuation(input) {
             parentRunId: input.parentRunId,
             requestId: input.requestId,
             failureSource: descriptor.failureSource,
+            failureOwner: descriptor.failureOwner,
+            resetRootNodeId: descriptor.resetRootNodeId,
             parentRecovery: parentState.frontendRecoveryState,
         }),
         recoveryPlan: descriptor.plan,
@@ -404,75 +412,63 @@ async function executeFrontendRecoveryContinuation(input) {
     // these through its own durable tools (normal commit entry, child binding)
     // and the model only corrects the rows the design review flagged; the
     // parent ledger is never rewritten and the finalize terminal is not
-    // inherited. Best-effort: a parent without plan facts plans fresh.
-    try {
+    // inherited. Only an absent parent ledger permits a fresh Plan.
+    if (descriptor.plan.resetRootNodeId === "frontend-plan-pi") {
         const parentPlanLedger = path.join(located.runDir, "frontend-plan-pi", "plan-decision-facts.jsonl");
-        const parentRaw = await readFile(parentPlanLedger, "utf8");
-        const parentRecords = await readTypedEventStoreFromJsonl(parentPlanLedger);
-        // Collapse superseded records first: the parent ledger is append-only
-        // (replace:true appends a corrected row), and replaying both the original
-        // and its correction would trip FACT_IDENTITY_CONFLICT in the child.
-        const { collapseDecisionEntriesByKind } = await import("./frontend-plan-decision-contract.js");
-        const byKind = new Map();
-        for (const record of parentRecords) {
-            const kind = String(record.fact.kind);
-            if (record.phase !== "committed" || kind === "finalize_decision")
-                continue;
-            const entry = record.fact.entry;
-            if (typeof entry !== "object" || entry === null || Array.isArray(entry))
-                continue;
-            const bucket = byKind.get(kind) ?? [];
-            bucket.push(entry);
-            byKind.set(kind, bucket);
-        }
-        let parentCanonicalSha256;
-        try {
-            const parentCanonical = await readFile(path.join(located.runDir, "contracts", "frontend-implementation-contract.json"), "utf8");
-            parentCanonicalSha256 = createHash("sha256").update(parentCanonical).digest("hex");
-        }
-        catch {
-            // Parent canonical unavailable → the identical-plan guard is skipped.
-        }
-        // Carry the design findings that blocked the parent run: the child's
-        // finalize runs a per-finding closure check against them.
-        let designFindings = [];
-        try {
-            const designFacts = await readTypedEventStoreFromJsonl(path.join(located.runDir, "frontend-design-review-pi", "design-typed-facts.jsonl"));
-            for (const record of designFacts) {
-                const fact = record.fact;
-                if (record.phase !== "committed" || fact.kind !== "design-finding")
+        const parentRaw = await readFile(parentPlanLedger, "utf8").catch((error) => {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        if (parentRaw !== undefined) {
+            const parentRecords = await readTypedEventStoreFromJsonl(parentPlanLedger);
+            // Collapse superseded records first: the parent ledger is append-only
+            // (replace:true appends a corrected row), and replaying both the original
+            // and its correction would trip FACT_IDENTITY_CONFLICT in the child.
+            const { collapseDecisionEntriesByKind } = await import("./frontend-plan-decision-contract.js");
+            const byKind = new Map();
+            for (const record of parentRecords) {
+                const kind = String(record.fact.kind);
+                if (record.phase !== "committed" || kind === "finalize_decision")
                     continue;
-                const finding = (fact.finding ?? {});
-                designFindings.push({
-                    severity: typeof finding.severity === "string" ? finding.severity : "Important",
-                    issue: typeof finding.issue === "string" ? finding.issue : "",
-                    requiredChange: typeof finding.requiredChange === "string" ? finding.requiredChange : "",
-                });
+                const entry = record.fact.entry;
+                if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                    continue;
+                const bucket = byKind.get(kind) ?? [];
+                bucket.push(entry);
+                byKind.set(kind, bucket);
             }
+            let parentCanonicalSha256;
+            try {
+                const parentCanonical = await readFile(path.join(located.runDir, "contracts", "frontend-implementation-contract.json"), "utf8");
+                parentCanonicalSha256 = createHash("sha256").update(parentCanonical).digest("hex");
+            }
+            catch {
+                // Parent canonical unavailable → the identical-plan guard is skipped.
+            }
+            const { readCurrentFrontendRepairFindings } = await import("./rerun-feedback.js");
+            const feedback = await readCurrentFrontendRepairFindings(located.runDir);
+            const designFindings = feedback?.verdict === "request" ? feedback.findings : [];
+            const parentSpec = await readDagRunSpec(located.runDir);
+            const snapshot = {
+                schemaVersion: 1,
+                schemaId: "frontend-plan-parent-decision-snapshot-v1",
+                parentRunId: input.parentRunId,
+                parentLedgerSha256: createHash("sha256").update(parentRaw).digest("hex"),
+                sourceBindingSha256: sha256OfCanonicalJson(parentSpec.sourceBinding ?? null),
+                ...(feedback ? { feedbackBinding: { sourceNodeId: feedback.sourceNodeId, ledgerSha256: feedback.ledgerSha256, terminalEventId: feedback.terminalEventId } } : {}),
+                ...(parentCanonicalSha256 ? { parentCanonicalSha256 } : {}),
+                designFindings,
+                facts: [...byKind.entries()].flatMap(([kind, entries]) => collapseDecisionEntriesByKind(kind, entries).map((entry) => ({
+                    kind,
+                    entry,
+                }))),
+            };
+            await mkdir(path.join(locatedChild.runDir, "frontend-plan-pi"), {
+                recursive: true,
+            });
+            await writeJsonAtomic(path.join(locatedChild.runDir, "frontend-plan-pi", "parent-decision-snapshot.json"), snapshot);
         }
-        catch {
-            // No readable design findings → the closure check has no assertions.
-        }
-        const snapshot = {
-            schemaVersion: 1,
-            schemaId: "frontend-plan-parent-decision-snapshot-v1",
-            parentRunId: input.parentRunId,
-            parentLedgerSha256: createHash("sha256").update(parentRaw).digest("hex"),
-            ...(parentCanonicalSha256 ? { parentCanonicalSha256 } : {}),
-            designFindings,
-            facts: [...byKind.entries()].flatMap(([kind, entries]) => collapseDecisionEntriesByKind(kind, entries).map((entry) => ({
-                kind,
-                entry,
-            }))),
-        };
-        await mkdir(path.join(locatedChild.runDir, "frontend-plan-pi"), {
-            recursive: true,
-        });
-        await writeJsonAtomic(path.join(locatedChild.runDir, "frontend-plan-pi", "parent-decision-snapshot.json"), snapshot);
-    }
-    catch {
-        // No parent plan ledger (or unreadable) → the child plans fresh,
-        // exactly like a run without recovery lineage.
     }
     const childSpec = await readDagRunSpec(locatedChild.runDir);
     const childState = await readDagRunState(locatedChild.runDir);