@tea-agent/loop-agent 0.39.0-beta.7 → 0.39.0-beta.8

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+- 前端 design-review 拒绝纳入自动恢复（方向 A 姊妹实现）：`request_design_changes`（definite finding）不再让 writer-admission blocked 变成 terminal failed——runner 终态判定识别 committed design fact 后生成 recovery trigger（new-dag，从 plan 重启）+ 渲染 design findings PRD 草稿 + `deriveDagRerunFeedback` 增加 design typed-fact 通道（findings 注入下一轮 `<rerun_feedback>`），受同一 `frontendRecoveryQuota` 控制；无 design fact 的 blocked admission 仍保持 terminal failed。design-review 发现"AC 未被契约/测试锚定"这类真问题会在写代码前自动进入修正轮，而非一次失败即停。
+- 前端 DAG 两个闭环补齐（P0-1 / P2-4）：
+  - **P0-1 前端 recovery 配额可配置**：`task.json frontendRecovery.maxContinuations`（默认 1，可配 2-5）冻结进 DAG spec（`spec.frontendRecovery`），runner 的 `finalizeTerminalRunStatus` 4 处硬编码 `< 1` 改为按配额判定——verify 偶发失败导致 run 真失败的场景可放宽到 2-3 次自动恢复，不必人工介入。
+  - **P2-4 `dag follow-up` 命令**：`loop-agent dag follow-up <parent-run-id> [--task-id <id>] [--execute] [--profile <p>]`——读取 parent run 的 `contracts/frontend-review-findings-prd.md`，createTask + importPrd（taskKind=frontend-implementation + PRD 内容）生成下游修复任务，`--execute` 直接 advance 走前端 DAG。review findings 从"只落文件的草稿"变成"一步进入下一轮 DAG 的任务"，闭环补齐。
+- frontend-plan-pi 重试上限从 5 收紧到 3（`FRONTEND_PLAN_LADDER_RETRY_POLICY.maxAttempts`）：每次 attempt 都是完整跑一遍 plan（读上下文 + 提交 record_* ledger），5 次在坏情况下等于 5 倍 plan token 成本；3 次仍覆盖常见失败（invalid-output 格式滑动、read-burst、传输类），四档阶梯只部分可遍历即判 non-converging，减少单节点无限烧 token 风险。
+
 - 前端 review `request_review_changes` 不再被静默当作成功（方向 A）：`frontend-review-pi` 提交 typed `request_review_changes` 时，run 终态判定为「未通过」（`partial_failed` + `terminalReason=review-request-changes`，即使全部节点 FINISHED 也不显示成功），committed findings 自动渲染为 run-owned 下游任务 PRD 草稿 `contracts/frontend-review-findings-prd.md`（含 issueCategory/evidenceRefs/findings/restartPhase 指引），并生成 recovery trigger（issueCategory→failureOwner 映射，new-dag）。`deriveDagRerunFeedback` 新增 typed-fact 通道：无文本 verdict、无 convergence 的 frontend 场景也能把 committed `request_review_changes` findings 注入下一轮 `<rerun_feedback>`，问题不再丢失、下一轮从 restartPhase 定点修复而非重复流程。
 - 前端 review findings PRD 草稿携带修复范围路由信号（方向 A 补充）：`deriveFrontendReviewFixScope` 从 committed findings 确定性推导建议 shape（单文件无远程 API→micro、同目录集中多文件→small、跨目录/API 信号→standard）与建议 complexity、目标文件、建议 allowedPaths；PRD 标题改为「修复 review 发现（<shape>）：<目标文件>」，正文新增「修复范围（供下一轮任务生成路由）」段（含 small 信号词，如「单文件局部修复」「无远程接口」），下一轮任务以该 PRD 生成 DAG 时，`resolveFrontendTaskShape` 能把小修复路由到 micro=7/small=10 节点拓扑，而非默认 11 节点 standard 全流程。
 - 前端 shape 分类 API 否定词覆盖中文空格形式（冒烟暴露边界）：`无 API/网络调用`、`无 API` 等表述不再被误判为远程 API 信号（原 `\b(...)\b` 对 CJK 开头无词边界），`resolveFrontendTaskShape` 与 `deriveFrontendReviewFixScope` 的 hasApiSignal 判定同步修正——带「无 API/无接口」声明的单文件小修复正确路由 micro/small，而非误升级 standard。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.39.0-beta.7",
-  "gitSha": "7f2b8f56e95923c3bde69fffa0575cfeae065c42",
-  "builtAt": "2026-08-24T02:16:38.537Z"
+  "version": "0.39.0-beta.8",
+  "gitSha": "b698721e82e0ff98c85484a5b2864d9b28e968f8",
+  "builtAt": "2026-08-24T06:32:44.509Z"
 }

package/dist/cli/command-definitions.js

@@ -35,6 +35,7 @@ import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
+import { runDagFollowUp } from "../commands/dag-follow-up.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagResume } from "../commands/dag-resume.js";
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
@@ -135,6 +136,7 @@ const DAG_SUBCOMMANDS = [
     "request-interrupt",
     "rerun",
     "rerun-task",
+    "follow-up",
     "reconcile-tasks",
     "final-verification",
     "decision",
@@ -577,6 +579,11 @@ export const COMMAND_DEFINITIONS = [
                 await runDagRerunTask(repoRoot, rerunTaskArgs);
                 return;
             }
+            if (subcommand === "follow-up") {
+                const followUpArgs = rest.filter((arg) => Boolean(arg));
+                await runDagFollowUp(repoRoot, followUpArgs);
+                return;
+            }
             if (subcommand === "reconcile-tasks") {
                 const reconcileArgs = rest.filter((arg) => Boolean(arg));
                 await runDagReconcileTasks(repoRoot, reconcileArgs);

package/dist/cli/program.js

@@ -13,6 +13,7 @@ import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
+import { runDagFollowUp } from "../commands/dag-follow-up.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
@@ -352,6 +353,9 @@ async function runDagAction(repoRoot, subcommand, rest) {
         case "rerun-task":
             await runDagRerunTask(repoRoot, args);
             return;
+        case "follow-up":
+            await runDagFollowUp(repoRoot, args);
+            return;
         case "reconcile-tasks":
             await runDagReconcileTasks(repoRoot, args);
             return;
@@ -511,6 +515,7 @@ function addDagCommand(program, defaultRepoRoot) {
         "request-interrupt",
         "rerun",
         "rerun-task",
+        "follow-up",
         "reconcile-tasks",
         "final-verification",
     ], defaultRepoRoot);

package/dist/commands/dag-follow-up.js

@@ -0,0 +1,138 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { FRONTEND_REVIEW_FINDINGS_PRD_REL, readFrontendReviewFindingsPrd, } from "../workflows/dag/frontend-review-findings.js";
+import { locateDagRun } from "../workflows/dag/lifecycle.js";
+import { createTask, getTaskPaths } from "../task/runtime.js";
+import { importPrdDocument } from "../task/source-references.js";
+function parseFlagValue(rawArgs, flag) {
+    const index = rawArgs.indexOf(flag);
+    if (index < 0 || index + 1 >= rawArgs.length)
+        return undefined;
+    return rawArgs[index + 1];
+}
+export function parseDagFollowUpArgs(rawArgs) {
+    const positional = rawArgs.filter((arg) => !arg.startsWith("-"));
+    const parentRunId = positional[0];
+    if (!parentRunId) {
+        throw new Error("usage: dag follow-up <parent-run-id> [--task-id <id>] [--execute] [--profile <profile>]");
+    }
+    return {
+        parentRunId,
+        taskId: parseFlagValue(rawArgs, "--task-id"),
+        execute: rawArgs.includes("--execute"),
+        profile: parseFlagValue(rawArgs, "--profile"),
+    };
+}
+export function deriveFollowUpTaskId(parentRunId) {
+    // Deterministic, valid task id derived from the parent run id.
+    return `${parentRunId}-followup`;
+}
+/** CLI entry: parse raw args and run the follow-up flow. */
+export async function runDagFollowUp(repoRoot, rawArgs) {
+    const parsed = parseDagFollowUpArgs(rawArgs);
+    const result = await runDagFollowUpInternal(repoRoot, parsed.parentRunId, {
+        taskId: parsed.taskId,
+        execute: parsed.execute,
+        profile: parsed.profile,
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+        process.exitCode = result.mode === "blocked" ? 2 : 1;
+    }
+}
+export async function runDagFollowUpInternal(repoRoot, parentRunId, options = {}) {
+    const located = await locateDagRun(repoRoot, parentRunId);
+    if (!located) {
+        return {
+            ok: false,
+            mode: "invalid",
+            reason: `dag run not found: ${parentRunId}`,
+        };
+    }
+    const prd = await readFrontendReviewFindingsPrd(located.runDir);
+    if (!prd) {
+        return {
+            ok: false,
+            mode: "invalid",
+            reason: `no frontend review findings PRD found in run ${parentRunId} (${FRONTEND_REVIEW_FINDINGS_PRD_REL}); the review must have committed request_review_changes`,
+        };
+    }
+    const taskId = options.taskId ?? deriveFollowUpTaskId(parentRunId);
+    try {
+        await createTask(repoRoot, taskId, `修复 review 发现（parent ${parentRunId}）`);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            mode: "blocked",
+            reason: `failed to create task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    // Materialize the PRD draft into the task's source directory so the task
+    // lifecycle can import it as its requirement.
+    const prdMaterialized = path.join(getTaskPaths(repoRoot, taskId).sourceDir, "review-findings-prd.md");
+    try {
+        await mkdir(path.dirname(prdMaterialized), { recursive: true });
+        await importPrdDocument({
+            repoRoot,
+            taskId,
+            filePath: path.join(located.runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL),
+            name: "review-findings-prd",
+        });
+    }
+    catch (error) {
+        return {
+            ok: false,
+            mode: "blocked",
+            reason: `failed to import PRD into task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (!options.execute) {
+        return {
+            ok: true,
+            mode: "created",
+            taskId,
+            prdPath: prdMaterialized,
+            next: {
+                kind: "advance",
+                command: `loop-agent task advance ${taskId} --task-kind frontend-implementation --json`,
+            },
+        };
+    }
+    // Execute: advance through the frontend DAG.
+    const { advanceTaskLifecycle } = await import("../application/task-lifecycle/advance.js");
+    const profile = options.profile === "auto" ||
+        options.profile === "minimal" ||
+        options.profile === "standard" ||
+        options.profile === "reviewed" ||
+        options.profile === "supervised"
+        ? options.profile
+        : undefined;
+    const result = await advanceTaskLifecycle({
+        repoRoot,
+        taskId,
+        taskKind: "frontend-implementation",
+        taskKindExplicit: true,
+        ...(profile ? { profile, profileExplicit: true } : {}),
+        observer: undefined,
+    });
+    const ok = result.lifecycleState === "run-succeeded" ||
+        result.lifecycleState === "awaiting-write-set-approval";
+    return {
+        ok,
+        mode: ok ? "created" : "blocked",
+        taskId,
+        prdPath: prdMaterialized,
+        reason: ok
+            ? undefined
+            : `advance lifecycleState: ${result.lifecycleState}${result.blockers.length > 0
+                ? `; blockers: ${result.blockers.map((b) => b.code).join(", ")}`
+                : ""}`,
+        next: ok
+            ? undefined
+            : {
+                kind: "advance",
+                command: `loop-agent task advance ${taskId} --task-kind frontend-implementation --json`,
+            },
+    };
+}

package/dist/task/config-types.js

@@ -219,6 +219,21 @@ const taskConfigObjectSchema = z.object({
     maxFixLoops: z.number().int().min(0).optional().default(2),
     /** Supervised DAG convergence is opt-in until runtime smoke evidence is stronger. */
     convergence: convergenceConfigSchema.optional().default({ enabled: false }),
+    /** Frontend recovery continuation quota. Bounds how many times a failed
+     * frontend run may auto-recover via M6 recovery operations (1 = current
+     * default; raise to 2-3 for more tolerance of transient verify failures). */
+    frontendRecovery: z
+        .object({
+        maxContinuations: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .default(1),
+    })
+        .strict()
+        .optional(),
     /** Outer loop auto mode never writes by default; DAG execute requires this policy plus path/writeSet gates. */
     loopAutoExecutionPolicy: loopAutoExecutionPolicySchema
         .optional()

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -14,6 +14,7 @@ import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 // on each other without module-init ordering issues.
 import { checkDependencies, checkTargetPaths, checkUiDesignCoverage, checkUiStateAttribution, } from "./frontend-design-policy.js";
 import { canonicalContractRel, classifyStructuredContractFailure, formatStructuredArtifactPointer, persistRuntimeSkeleton, } from "./structured-output-repair.js";
+import { renderFrontendPlanMarkdown } from "./frontend-plan-render.js";
 import { isConfigurationVerificationFile, verificationSymbolMatchesContent, } from "./frontend-verification-trace.js";
 export const frontendNormalizationActionSchema = z.enum([
     "remove-trailing-commas",
@@ -2075,11 +2076,17 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             sha256: canonicalArtifact.sha256,
             schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
         };
+        // Human-readable plan summary appended after the artifact pointer. The
+        // pointer remains the machine authority (path/schema/sha256); the
+        // rendered summary is a deterministic view of the canonical contract so
+        // Console/reviewers can read the plan without opening the JSON. It never
+        // participates in downstream validation.
+        const planSummary = renderFrontendPlanMarkdown(analysis.canonical);
         return {
             ok: true,
             contract: analysis.canonical,
             artifact,
-            normalizedText: formatStructuredArtifactPointer(artifact),
+            normalizedText: `${formatStructuredArtifactPointer(artifact)}\n\n${planSummary}`,
         };
     }
     catch (error) {

package/dist/workflows/dag/frontend-review-findings.js

@@ -10,10 +10,17 @@ import { readTypedEventStoreFromJsonl, } from "./frontend-typed-event-store.js";
  * rendered into a downstream-task PRD draft that a later DAG round can consume
  * instead of repeating the previous flow. Rendering is deterministic (pure);
  * only the JSONL read and PRD write are IO.
+ *
+ * The design-review analog (`request_design_changes`) reuses the same PRD
+ * rendering and typed-fact channel: a design rejection is a definite finding
+ * (not a protocol/environment error), so it auto-re-enters the next plan round
+ * with the committed design findings instead of terminating the run.
  */
 export const FRONTEND_REVIEW_FINDINGS_PRD_REL = "contracts/frontend-review-findings-prd.md";
 /** Review node id whose committed typed facts drive the findings PRD. */
 export const FRONTEND_REVIEW_NODE_ID = "frontend-review-pi";
+/** Design review node id whose committed typed facts drive the findings PRD. */
+export const FRONTEND_DESIGN_REVIEW_NODE_ID = "frontend-design-review-pi";
 /** Deterministic issueCategory → failure owner mapping (A+B AC-009 §4.10). */
 export function classifyReviewIssueCategoryFailureOwner(issueCategory) {
     switch (issueCategory) {
@@ -122,10 +129,34 @@ export function deriveFrontendReviewFixScope(fact) {
  * approve_review, missing store, or an unreadable store).
  */
 export async function readCommittedReviewRequestFact(input) {
+    const { runDir: reviewRunDir } = input;
     const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    return readCommittedRequestFactByKind({
+        runDir: reviewRunDir,
+        nodeId: reviewNodeId,
+        factsFile: "review-typed-facts.jsonl",
+        kind: "request_review_changes",
+    });
+}
+/**
+ * Read the committed `request_design_changes` fact from the design review
+ * node's typed event store. Returns undefined when no committed request fact
+ * exists (e.g. approve_design, missing store, or an unreadable store).
+ */
+export async function readCommittedDesignRequestFact(input) {
+    const { runDir: designRunDir } = input;
+    const designNodeId = input.designNodeId ?? FRONTEND_DESIGN_REVIEW_NODE_ID;
+    return readCommittedRequestFactByKind({
+        runDir: designRunDir,
+        nodeId: designNodeId,
+        factsFile: "design-typed-facts.jsonl",
+        kind: "request_design_changes",
+    });
+}
+async function readCommittedRequestFactByKind(input) {
     let records;
     try {
-        records = await readTypedEventStoreFromJsonl(path.join(input.runDir, reviewNodeId, "review-typed-facts.jsonl"));
+        records = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.nodeId, input.factsFile));
     }
     catch {
         return undefined;
@@ -133,9 +164,7 @@ export async function readCommittedReviewRequestFact(input) {
     const committed = records.filter((record) => record.phase === "committed");
     if (committed.length === 0)
         return undefined;
-    // A committed approve_review means the review passed; only a committed
-    // request_review_changes carries a "not passed" verdict.
-    const request = committed.find((record) => record.fact.kind === "request_review_changes");
+    const request = committed.find((record) => record.fact.kind === input.kind);
     if (!request)
         return undefined;
     const fact = request.fact;
@@ -166,25 +195,28 @@ function findingLines(findings) {
 }
 /**
  * Deterministically render a downstream-task PRD draft from a committed
- * `request_review_changes` fact. Same fact always renders byte-identical
- * output; the parent run id and review node id are the only context.
+ * `request_review_changes` / `request_design_changes` fact. Same fact always
+ * renders byte-identical output; the parent run id and review node id are the
+ * only context.
  */
 export function renderFrontendReviewFindingsPrd(input) {
     const { parentRunId, fact } = input;
-    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    const isDesign = fact.kind === "request_design_changes";
+    const reviewNodeId = input.reviewNodeId ??
+        (isDesign ? FRONTEND_DESIGN_REVIEW_NODE_ID : FRONTEND_REVIEW_NODE_ID);
     const restartPhase = classifyReviewIssueCategoryFailureOwner(fact.issueCategory);
     const scope = deriveFrontendReviewFixScope(fact);
     const targetSummary = scope.targetFiles.length > 0
         ? scope.targetFiles.join(", ")
         : fact.issueCategory;
     return [
-        `# 修复 review 发现（${scope.shape}）：${targetSummary}`,
+        `# 修复 ${isDesign ? "设计" : "review"} 发现（${scope.shape}）：${targetSummary}`,
         "",
         "## 背景",
         "",
         `- parentRunId: \`${parentRunId}\``,
         `- reviewNodeId: \`${reviewNodeId}\``,
-        `- typedVerdict: \`request_review_changes\``,
+        `- typedVerdict: \`${fact.kind}\``,
         `- issueCategory: \`${fact.issueCategory}\``,
         `- restartPhase/failureOwner: \`${restartPhase}\``,
         "",
@@ -216,7 +248,7 @@ export function renderFrontendReviewFindingsPrd(input) {
         "",
         `- 按 issueCategory 映射的重启阶段（${restartPhase}）定点修复，不复用上一轮未通过的实现。`,
         "- 逐条关闭上面「问题清单」中的 findings，并保留上一轮已通过的验证目标继续有效。",
-        "- 完成修复后重新走 frontend DAG 的 implement → verify → review 链，直到 review 提交 approve_review。",
+        `- 完成修复后重新走 frontend DAG 的 ${isDesign ? "plan → design" : "implement → verify → review"} 链，直到${isDesign ? " design-review 提交 approve_design" : " review 提交 approve_review"}。`,
         "",
     ].join("\n");
 }

package/dist/workflows/dag/init-hybrid.js

@@ -3384,6 +3384,10 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...(spec.advisories ?? []),
         `frontend-task-shape: ${frontendTaskShape.shape} (${frontendTaskShape.reason})`,
     ];
+    // Freeze the frontend recovery continuation quota from task.json so the
+    // runner can bound M6 auto-recovery without re-reading the task config.
+    const frontendMaxContinuations = sources.taskConfig.frontendRecovery?.maxContinuations ?? 1;
+    spec.frontendRecovery = { maxContinuations: frontendMaxContinuations };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);

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

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseJsonReviewVerdict } from "./output-protocol.js";
-import { FRONTEND_REVIEW_NODE_ID, readCommittedReviewRequestFact, } from "./frontend-review-findings.js";
+import { FRONTEND_DESIGN_REVIEW_NODE_ID, FRONTEND_REVIEW_NODE_ID, readCommittedDesignRequestFact, readCommittedReviewRequestFact, } from "./frontend-review-findings.js";
 export const MAX_RERUN_FEEDBACK_CHARS = 12_000;
 const RERUN_FEEDBACK_TRUNCATION_MARKER = "\n\n...[上一轮反馈已按长度上限截断]...\n\n";
 const MAX_EVIDENCE_REFS = 8;
@@ -183,6 +183,24 @@ async function readTypedReviewRequestFact(runDir) {
         },
     };
 }
+/**
+ * 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,
+        },
+    };
+}
 /**
  * Derive only the latest unresolved verify/review feedback from canonical
  * parent-run facts. Provider-only failures intentionally return undefined.
@@ -201,12 +219,15 @@ export async function deriveDagRerunFeedback(input) {
         }
     }
     if (!sourceNodeId || !sourceNode) {
-        // Typed terminal channel: the frontend review commits its verdict as a
-        // typed fact (request_review_changes) instead of VERDICT text, and the
-        // frontend DAG has no convergence passHistory. Fall back to reading the
-        // review node's typed event store so findings still flow into the next
-        // round as unresolved feedback.
-        const typedFact = await readTypedReviewRequestFact(input.runDir);
+        // 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).
+        const typedFact = (await readTypedReviewRequestFact(input.runDir)) ??
+            (await readTypedDesignRequestFact(input.runDir));
         if (typedFact) {
             const parentSourceBindingHash = sourceBindingHash(input.spec);
             return withDigest({
@@ -216,7 +237,9 @@ export async function deriveDagRerunFeedback(input) {
                 taskId: input.taskId,
                 sourceNodeId: typedFact.nodeId,
                 verdict: "request-revision",
-                failureCategory: "review-request-changes",
+                failureCategory: typedFact.nodeId === FRONTEND_REVIEW_NODE_ID
+                    ? "review-request-changes"
+                    : "design-request-changes",
                 feedbackText: scrubAndBoundFeedbackText(formatTypedReviewRequestFeedback(typedFact.fact), input.runDir, input.state.cwd),
                 evidenceRefs: [
                     {

package/dist/workflows/dag/retry-policy.js

@@ -536,14 +536,16 @@ function reasonMandatedFrontendPlanRetryStep(reason) {
     }
 }
 /**
- * Opt-in retry policy mounted on the frontend-plan-pi node. maxAttempts=5 is
- * the schema cap, matching the four-rung ladder plus one non-converging stop.
- * `invalid-output` (typed-fact schema violations, e.g. verification targets
- * referencing undeclared UI states) retries at the `normal` rung with the
- * contractCheck reason injected via `<retry_instruction>` (§5.1 ladder).
+ * Opt-in retry policy mounted on the frontend-plan-pi node. maxAttempts=3
+ * bounds plan retry cost: the four-rung ladder is only partially traversable
+ * before the run fails non-converging (rungs: normal → bounded-tool-only →
+ * compact-terminal-first → backup-model). `invalid-output` (typed-fact schema
+ * violations, e.g. verification targets referencing undeclared UI states)
+ * retries at the `normal` rung with the contractCheck reason injected via
+ * `<retry_instruction>` (§5.1 ladder).
  */
 export const FRONTEND_PLAN_LADDER_RETRY_POLICY = {
-    maxAttempts: 5,
+    maxAttempts: 3,
     backoff: "exponential",
     initialDelayMs: 2000,
     maxDelayMs: 30000,

package/dist/workflows/dag/runner.js

@@ -26,7 +26,7 @@ import { runConvergencePassController, } from "./convergence/controller.js";
 import { executeDagRanksOnce, FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT, FRONTEND_WRITER_NODE_IDS, isConditionSkippedReason, readFrontendPrewriteResult, } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
 import { isFrontendWriterTransientPartialWrite } from "./frontend-writer-recovery.js";
-import { classifyReviewIssueCategoryFailureOwner, readCommittedReviewRequestFact, writeFrontendReviewFindingsPrd, } from "./frontend-review-findings.js";
+import { classifyReviewIssueCategoryFailureOwner, readCommittedDesignRequestFact, readCommittedReviewRequestFact, writeFrontendReviewFindingsPrd, } from "./frontend-review-findings.js";
 import { bindFrontendShapeStateToRunTopology, commitFrontendShapeTransitionCas, commitRuntimeFrontendShapeFact, isCanonicalFrontendShapeDag, } from "./frontend-shape-facts.js";
 import { assertFrontendTopologyBinding, buildFrontendTopologyBinding, computeFrontendShapeSourceDigest, } from "./frontend-shape.js";
 import { ensureFrontendShapeCapsuleRecord } from "./frontend-shape-capsule-store.js";
@@ -794,7 +794,7 @@ async function executeDagCheckpoint(input) {
             runDir = await moveToPausedRunDir(runDir, pausedRunDir);
         }
         else {
-            const { recoveryPending, recovery: recoveryTrigger } = await finalizeTerminalRunStatus(state, spec.tasks.length, runDir, cwd);
+            const { recoveryPending, recovery: recoveryTrigger } = await finalizeTerminalRunStatus(state, spec.tasks.length, runDir, cwd, spec.frontendRecovery?.maxContinuations ?? 1);
             await finalizeRunOwnedInterrupt({
                 runDir,
                 state,
@@ -1042,7 +1042,7 @@ function buildRecoveryResultForTrigger(state, trigger, outcome) {
         evidenceRefs: [],
     };
 }
-export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
+export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd, frontendRecoveryQuota = 1) {
     const repoRoot = cwd ?? path.resolve(runDir, "..", "..", "..", "..");
     if (state.frontendShapeState?.terminalOutcome &&
         state.frontendShapeState.transitionCapsule) {
@@ -1064,16 +1064,53 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
             // every other blocked admission is terminal.
             const planContractInvalid = admission.result.classification === "blocked" &&
                 admission.result.failureSource === "frontend-plan-pi";
+            // A blocked admission caused by the design review committing
+            // `request_design_changes` is a definite finding (not a protocol or
+            // environment error): the design was reviewed and rejected. It is the
+            // design-review analog of review-request-changes — not terminal, but
+            // re-enters the next plan round with the committed design findings.
+            // The failureSource may be frontend-writer-admission-shell or
+            // frontend-design-policy-shell; the committed design fact is the
+            // authoritative signal.
+            const designRequestFact = await readCommittedDesignRequestFact({
+                runDir,
+            });
+            const designRejected = admission.result.classification === "blocked" &&
+                designRequestFact !== undefined;
             const terminalAdmissionDenial = (admission.result.classification === "blocked" ||
                 admission.result.classification === "stale") &&
-                !planContractInvalid;
+                !planContractInvalid &&
+                !designRejected;
             if (terminalAdmissionDenial) {
                 state.status = "failed";
                 return { recoveryPending: false };
             }
+            if (designRejected && designRequestFact) {
+                state.terminalReason = "design-request-changes";
+                try {
+                    await writeFrontendReviewFindingsPrd({
+                        runDir,
+                        parentRunId: state.runId,
+                        fact: designRequestFact,
+                    });
+                }
+                catch (error) {
+                    console.warn(`[run-dag] warning: failed to write frontend design findings PRD: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                const continuationCount = state.frontendRecoveryState?.continuationCount ?? 0;
+                if (continuationCount < frontendRecoveryQuota) {
+                    recoveryTrigger = {
+                        requestId: state.runId,
+                        failureSource: "frontend-design-review-pi",
+                        failureOwner: classifyReviewIssueCategoryFailureOwner(designRequestFact.issueCategory),
+                        protocolFailureReason: `frontend design review request_design_changes (issueCategory=${designRequestFact.issueCategory})`,
+                        recoveryMode: "new-dag",
+                    };
+                }
+            }
             if (planContractInvalid) {
                 const continuationCount = state.frontendRecoveryState?.continuationCount ?? 0;
-                if (continuationCount >= 1) {
+                if (continuationCount >= frontendRecoveryQuota) {
                     // Continuation quota exhausted: a second contract-invalid candidate
                     // is authoritative candidate-contract-invalid → forced failed.
                     state.frontendRecoveryResult = buildCandidateContractInvalidResult(state, admission.result, admission.artifactHash);
@@ -1109,7 +1146,7 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
         });
         if (writerNodeId) {
             const continuationCount = state.frontendRecoveryState?.continuationCount ?? 0;
-            if (continuationCount < 1) {
+            if (continuationCount < frontendRecoveryQuota) {
                 const { rollbackFrontendWriter } = await import("./frontend-writer-recovery.js");
                 const rollback = await rollbackFrontendWriter({
                     cwd: repoRoot,
@@ -1141,7 +1178,7 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
         const verifyFailed = state.nodes["frontend-verify-shell"]?.status === "ERROR";
         if (verifyFailed) {
             const continuationCount = state.frontendRecoveryState?.continuationCount ?? 0;
-            if (continuationCount < 1) {
+            if (continuationCount < frontendRecoveryQuota) {
                 recoveryTrigger = {
                     requestId: state.runId,
                     failureSource: "frontend-verify-shell",
@@ -1179,7 +1216,7 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
         }
         if (!recoveryTrigger && !skipFrontendRecovery) {
             const continuationCount = state.frontendRecoveryState?.continuationCount ?? 0;
-            if (continuationCount < 1) {
+            if (continuationCount < frontendRecoveryQuota) {
                 recoveryTrigger = {
                     requestId: state.runId,
                     failureSource: "frontend-review-pi",

package/dist/workflows/dag/types.js

@@ -1147,6 +1147,22 @@ export const dagSpecSchema = z
     taskContractBinding: dagTaskContractBindingSchema.optional(),
     /** Optional unresolved parent-run feedback for a full task rerun. */
     rerunFeedback: dagRerunFeedbackSchema.optional(),
+    /** Frontend recovery continuation quota (frozen at generation time from
+     * task.json frontendRecovery.maxContinuations). Bounds how many times a
+     * failed frontend run may auto-recover via M6 recovery operations before
+     * the run stays failed and needs human intervention. */
+    frontendRecovery: z
+        .object({
+        maxContinuations: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .default(1),
+    })
+        .strict()
+        .optional(),
     /** Frozen backend-test artifact layout (plan A); absent = historical default testcase/ layout. */
     backendTestLayout: z
         .object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.39.0-beta.7",
+  "version": "0.39.0-beta.8",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",