@tea-agent/loop-agent 0.39.0-beta.4 → 0.39.0-beta.5

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.39.0-beta.4",
-  "gitSha": "c2dcaef179cd0526f8f5779e866d0e1103451baa",
-  "builtAt": "2026-08-23T07:52:07.528Z"
+  "version": "0.39.0-beta.5",
+  "gitSha": "0981b80311d973603a870fd80693331cb5e48335",
+  "builtAt": "2026-08-23T11:38:56.113Z"
 }

package/dist/executors/dag-pi-executor.js

@@ -216,6 +216,9 @@ export const FRONTEND_PLAN_RECORD_TOOL_NAMES = [
     "record_mock_api",
     "record_design_deviation",
     "record_dependency",
+    "record_plan_requirement",
+    "record_plan_verification_target",
+    "record_plan_evidence_gap",
 ];
 export const FRONTEND_PLAN_TERMINAL_TOOL_NAMES = ["finalize_plan"];
 export const FRONTEND_PLAN_ADOPT_TOOL_NAMES = ["adopt_staged_fact"];
@@ -923,16 +926,83 @@ export async function createFrontendPlanLedgerTools(input) {
             return planToolReceipt(result);
         },
     });
+    // Incremental plan payload records (one entry per call) so requirements,
+    // verification targets, evidence gaps, and implementation steps never have
+    // to be emitted as one large array inside a single finalize_plan call —
+    // they aggregate from the ledger in commit order. Mirrors the contract
+    // node's record_requirement pattern to stay within any model output budget.
+    const recordPlanRequirementTool = defineTool({
+        name: "record_plan_requirement",
+        label: "record_plan_requirement",
+        description: "Commit one plan requirement entry (origin=plan plan-requirement fact). Call once per requirement; each entry carries id, expectedOutcome, implementationTargets, verificationTargetIds, and optional evidenceGap.",
+        promptSnippet: "Commit one plan requirement entry.",
+        parameters: Type.Object({
+            entry: requirementSchema,
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const rawEntry = params?.entry;
+            if (!isRecordObject(rawEntry)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-requirement",
+                    error: "record_plan_requirement requires a non-empty entry object",
+                });
+            }
+            const entry = rawEntry;
+            const result = await adoptPlanFact("plan-requirement", `${attemptId}:record_plan_requirement:${randomUUID()}`, { kind: "plan-requirement", origin: "plan", entry });
+            return planToolReceipt(result);
+        },
+    });
+    const recordPlanVerificationTargetTool = defineTool({
+        name: "record_plan_verification_target",
+        label: "record_plan_verification_target",
+        description: "Commit one plan verification target entry (origin=plan plan-verification-target fact). Call once per target; entry carries id, type, commandLabel, file, symbol, requirementIds, uiStates.",
+        promptSnippet: "Commit one plan verification target entry.",
+        parameters: Type.Object({
+            entry: verificationTargetSchema,
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const rawEntry = params?.entry;
+            if (!isRecordObject(rawEntry)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-verification-target",
+                    error: "record_plan_verification_target requires a non-empty entry object",
+                });
+            }
+            const entry = rawEntry;
+            const result = await adoptPlanFact("plan-verification-target", `${attemptId}:record_plan_verification_target:${randomUUID()}`, { kind: "plan-verification-target", origin: "plan", entry });
+            return planToolReceipt(result);
+        },
+    });
+    const recordPlanEvidenceGapTool = defineTool({
+        name: "record_plan_evidence_gap",
+        label: "record_plan_evidence_gap",
+        description: "Commit one plan evidence gap entry (origin=plan plan-evidence-gap fact). Call once per gap; entry carries requirementId, description, blocking.",
+        promptSnippet: "Commit one plan evidence gap entry.",
+        parameters: Type.Object({
+            entry: evidenceGapSchema,
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const rawEntry = params?.entry;
+            if (!isRecordObject(rawEntry)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-evidence-gap",
+                    error: "record_plan_evidence_gap requires a non-empty entry object",
+                });
+            }
+            const entry = rawEntry;
+            const result = await adoptPlanFact("plan-evidence-gap", `${attemptId}:record_plan_evidence_gap:${randomUUID()}`, { kind: "plan-evidence-gap", origin: "plan", entry });
+            return planToolReceipt(result);
+        },
+    });
     const finalizePlanTool = defineTool({
         name: "finalize_plan",
         label: "finalize_plan",
-        description: "Assemble the canonical editable plan patch from committed record facts plus these remaining fields, publish it on a target-surface fact, and commit the finalize_plan terminal. Call exactly once.",
-        promptSnippet: "Assemble and commit the finalize_plan terminal (requirements + verificationTargets + evidenceGaps + optional fields).",
+        description: "Commit the finalize_plan terminal. Requirements, verification targets, and evidence gaps (optional) were already committed incrementally through record_plan_requirement / record_plan_verification_target / record_plan_evidence_gap; finalize_plan assembles them from the ledger together with these optional remaining fields, publishes the canonical editable patch on a target-surface fact, and commits the terminal. Call exactly once.",
+        promptSnippet: "Commit the finalize_plan terminal (ledger fields + optional residualRisks / realIntegrationGap).",
         parameters: Type.Object({
-            requirements: Type.Array(requirementSchema),
-            verificationTargets: Type.Array(verificationTargetSchema),
-            evidenceGaps: Type.Array(evidenceGapSchema),
-            implementationSteps: optionalStringArray,
             residualRisks: optionalStringArray,
             realIntegrationGap: optionalString,
         }, { additionalProperties: false }),
@@ -942,12 +1012,6 @@ export async function createFrontendPlanLedgerTools(input) {
                 const fragment = assemblePlanPatchFromCommittedFacts(committed) ?? {};
                 const patch = {
                     ...fragment,
-                    requirements: params?.requirements ?? [],
-                    verificationTargets: params?.verificationTargets ?? [],
-                    evidenceGaps: params?.evidenceGaps ?? [],
-                    ...(params?.implementationSteps
-                        ? { implementationSteps: params.implementationSteps }
-                        : {}),
                     ...(params?.residualRisks
                         ? { residualRisks: params.residualRisks }
                         : {}),
@@ -1024,6 +1088,9 @@ export async function createFrontendPlanLedgerTools(input) {
             recordMockApiTool,
             recordDesignDeviationTool,
             recordDependencyTool,
+            recordPlanRequirementTool,
+            recordPlanVerificationTargetTool,
+            recordPlanEvidenceGapTool,
             adoptStagedFactTool,
             finalizePlanTool,
         ],

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

@@ -209,7 +209,6 @@ export function loadFrontendImplementationContractJsonSchema(startDir = path.dir
         "mockApi",
         "designEvidence",
         "verificationTargets",
-        "evidenceGaps",
     ];
     const actualRequired = Array.isArray(schema.required) ? schema.required : [];
     const missing = expectedRequired.filter((key) => !actualRequired.includes(key));
@@ -407,7 +406,7 @@ export const frontendImplementationContractSchema = z
         uiStates: z.array(z.string().min(1)),
     })
         .strict()).min(1),
-    evidenceGaps: z.array(gap),
+    evidenceGaps: z.array(gap).optional(),
     implementationSteps: z.array(z.string().min(1)).optional(),
     stylingStrategy: z.string().min(1).optional(),
     uiComponentChoices: uiComponentChoicesSchema.optional(),
@@ -1687,7 +1686,7 @@ export async function analyzeFrontendImplementationContract(input) {
     if (!result.success)
         fail("retryable-invalid", `invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`, candidateJsonSha256);
     const blockingGaps = [
-        ...result.data.evidenceGaps,
+        ...(result.data.evidenceGaps ?? []),
         ...result.data.requirements.flatMap((item) => item.evidenceGap ? [item.evidenceGap] : []),
     ].filter((item) => item.blocking);
     if (blockingGaps.length > 0)
@@ -1696,7 +1695,7 @@ export async function analyzeFrontendImplementationContract(input) {
             .join(", ")}`, candidateJsonSha256);
     for (const requirementId of canonicalBinding.requirementIds)
         if (!result.data.requirements.some((item) => item.id === requirementId) &&
-            !result.data.evidenceGaps.some((item) => item.requirementId === requirementId))
+            !(result.data.evidenceGaps ?? []).some((item) => item.requirementId === requirementId))
             fail("blocked", `frontend contract does not cover ${requirementId}`, candidateJsonSha256);
     return {
         canonical: result.data,
@@ -1728,6 +1727,9 @@ const PLAN_LEDGER_FACT_KINDS_FOR_COMPILE = [
     "mock-api",
     "design-deviation",
     "dependency",
+    "plan-requirement",
+    "plan-verification-target",
+    "plan-evidence-gap",
 ];
 /**
  * Restore the editable RFC 7386 plan patch from a committed plan ledger.

package/dist/workflows/dag/frontend-plan-render.js

@@ -54,9 +54,6 @@ export function renderFrontendPlanMarkdown(contract) {
         "## Requirement Coverage",
         requirementsCoverage(contract),
         "",
-        "## Implementation Steps",
-        bulletList(contract.implementationSteps) || "_(not specified)_",
-        "",
         "## Target Files",
         bulletList(contract.targets.files) || "_(none)_",
         "",

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -232,6 +232,9 @@ export const PLAN_LEDGER_FACT_KINDS = [
     "mock-api",
     "design-deviation",
     "dependency",
+    "plan-requirement",
+    "plan-verification-target",
+    "plan-evidence-gap",
 ];
 function skeletonTargetFiles(skeleton) {
     if (!isRecord(skeleton))
@@ -320,6 +323,29 @@ export function assemblePlanPatchFromCommittedFacts(records) {
     const dependencyPolicy = asString(dependency?.policy);
     if (dependencyPolicy)
         patch.dependencyPolicy = dependencyPolicy;
+    // Requirements / verification targets / evidence gaps / implementation
+    // steps arrive as individual facts (one per record_plan_* call) so a large
+    // plan never exceeds a single model output budget. Aggregate them in
+    // ledger order.
+    const requirements = facts
+        .filter((fact) => fact.kind === "plan-requirement")
+        .map((fact) => fact.entry)
+        .filter(isRecord);
+    if (requirements.length > 0)
+        patch.requirements = requirements;
+    const verificationTargets = facts
+        .filter((fact) => fact.kind === "plan-verification-target")
+        .map((fact) => fact.entry)
+        .filter(isRecord);
+    if (verificationTargets.length > 0) {
+        patch.verificationTargets = verificationTargets;
+    }
+    const evidenceGaps = facts
+        .filter((fact) => fact.kind === "plan-evidence-gap")
+        .map((fact) => fact.entry)
+        .filter(isRecord);
+    if (evidenceGaps.length > 0)
+        patch.evidenceGaps = evidenceGaps;
     return Object.keys(patch).length > 0 ? patch : undefined;
 }
 /** Derive the 7 origin=plan ledger facts from an editable patch. Skeleton
@@ -460,7 +486,8 @@ function planLedgerFactsFromCommittedRecords(records) {
         .filter((fact) => isRecord(fact) &&
         fact.origin === "plan" &&
         typeof fact.kind === "string" &&
-        PLAN_LEDGER_FACT_KINDS.includes(fact.kind));
+        PLAN_LEDGER_FACT_KINDS.includes(fact.kind))
+        .map((fact) => fact);
 }
 export async function loadCommittedPlanLedgerFacts(runDir, nodeId = "frontend-plan-pi") {
     const { readTypedEventStoreFromJsonl } = await import("./frontend-typed-event-store.js");

package/dist/workflows/dag/frontend-typed-event-store.js

@@ -113,6 +113,18 @@ export const contractBlockingOwnerSchema = z.enum([
  * `finalize_plan` terminal fact.
  */
 export const PLAN_TERMINAL_FACT_KINDS = ["finalize_plan"];
+/**
+ * A+B: incremental payload records for `frontend-plan-pi` (requirements,
+ * verification targets, evidence gaps). Each is committed by one
+ * `record_plan_*` call so a large plan never exceeds a single model output
+ * budget; `assemblePlanPatchFromCommittedFacts` aggregates them from the
+ * ledger in commit order.
+ */
+export const PLAN_RECORD_FACT_KINDS = [
+    "plan-requirement",
+    "plan-verification-target",
+    "plan-evidence-gap",
+];
 /**
  * A+B (AC-009): typed issue category shared by review and design change
  * requests. The five-value enum replaces free-form issueCategory strings.
@@ -143,6 +155,7 @@ const ALL_TYPED_EVENT_FACT_KIND_VALUES = [
         ...FRONTEND_SHAPE_FACT_KINDS,
         ...CONTRACT_FACT_KINDS,
         ...PLAN_TERMINAL_FACT_KINDS,
+        ...PLAN_RECORD_FACT_KINDS,
     ]),
 ];
 export const typedEventFactKindSchema = z.enum(ALL_TYPED_EVENT_FACT_KIND_VALUES);

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

@@ -11,7 +11,7 @@ import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { DEFAULT_OPENSPEC_GOVERNANCE_ROOT, DEFAULT_FRONTEND_SPEC_ROOTS, extractTaskSourceFrontendSpecPaths, } from "../../shared/openspec-spec.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
-import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PLANNER_OUTPUT_LIMIT_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, FRONTEND_PLAN_LADDER_RETRY_POLICY, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY, isCanonicalFinalVerifyShellRetryCandidate, isSafeReadOnlyPiRetryCandidate, isTargetTemplateImplementPi, isWriterTransportRetryCandidate, } from "./retry-policy.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PLANNER_OUTPUT_LIMIT_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, FRONTEND_PLAN_LADDER_RETRY_POLICY, FRONTEND_REVIEW_TERMINAL_RETRY_POLICY, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY, isCanonicalFinalVerifyShellRetryCandidate, isSafeReadOnlyPiRetryCandidate, isTargetTemplateImplementPi, isWriterTransportRetryCandidate, } from "./retry-policy.js";
 import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
@@ -2651,7 +2651,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             '{"strategy":"native","productionDefaultOff":true,"activation":"VITE_ENABLE_MOCK=true","endpoints":[{"method":"GET","path":"/api/users","fixture":"mocks/fixtures/users.json","consumer":"src/api/users.ts"}]}',
             "",
             "### optional plan fields - GOOD (all optional; omit when absent):",
-            '{"implementationSteps":["confirm contract","sync tests"],"stylingStrategy":"reuse existing design tokens","dependencyPolicy":"no new runtime deps","residualRisks":["browser a11y not-run"],"realIntegrationGap":"FE-TEST owns live HTTP"}',
+            '{"stylingStrategy":"reuse existing design tokens","dependencyPolicy":"no new runtime deps","residualRisks":["browser a11y not-run"],"realIntegrationGap":"FE-TEST owns live HTTP"}',
             "",
             "### optional plan fields - BAD (present-but-empty strings are rejected):",
             '{"stylingStrategy":"","dependencyPolicy":""}  <-- REJECTED: optional string fields must be non-empty when present; omit them instead',
@@ -2676,8 +2676,8 @@ async function buildFrontendHybridDagFromTask(sources) {
         "- targets: files, routes, publicApiChanges",
         "- mockApi: strategy, productionDefaultOff, activation, endpoints[]",
         "- verificationTargets[]: id, type, commandLabel, file, symbol, requirementIds, uiStates",
-        "- designEvidence: source, paths, conflicts; evidenceGaps[]",
-        "- optional: implementationSteps[], stylingStrategy, uiComponentChoices[], dependencyPolicy, residualRisks[], realIntegrationGap",
+        "- designEvidence: source, paths, conflicts; evidenceGaps[] (optional)",
+        "- optional: stylingStrategy, uiComponentChoices[], dependencyPolicy, residualRisks[], realIntegrationGap",
         "- uiComponentChoices[]: purpose, component, decision (specified|reuse-existing|new), specReference { path, section, line } | null, rationale",
         "Do not require or read a separate plan prose section; the contract JSON is the only plan surface.",
     ].join("\n");
@@ -2982,13 +2982,14 @@ async function buildFrontendHybridDagFromTask(sources) {
                     retryOnInvalid: true,
                     skeleton: frontendContractSkeleton,
                 },
-                outputContract: "Short Markdown narrative plus incremental typed plan record tools (record_target_surface / record_component_choice / record_state_flow / record_data_flow / record_mock_api / record_design_deviation / record_dependency) and exactly one finalize_plan terminal call. finalize_plan assembles the canonical editable patch from committed facts (requirements / verificationTargets / evidenceGaps / implementationSteps / residualRisks / realIntegrationGap). Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. The runtime compiles facts ⊕ skeleton into canonical full-contract JSON for downstream review. No file writes.",
+                outputContract: "Short Markdown narrative plus incremental typed plan record tools (record_target_surface / record_component_choice / record_state_flow / record_data_flow / record_mock_api / record_design_deviation / record_dependency / record_plan_requirement / record_plan_verification_target / record_plan_evidence_gap) and exactly one finalize_plan terminal call. finalize_plan assembles the canonical editable patch from the committed ledger facts (requirements / verificationTargets / evidenceGaps / residualRisks / realIntegrationGap). Commit requirements and verification targets incrementally — one entry per record call — so the plan never needs a single large output; evidence gaps are optional and only needed for genuine gaps. Implementation steps are NOT part of the plan — the implementer designs its own ordering. Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. The runtime compiles facts ⊕ skeleton into canonical full-contract JSON for downstream review. No file writes.",
                 subtask_prompt: [
                     "Use frontend-contract-pi typed requirement facts (stable REQ/BR/AC identifiers, dispositions, evidence expectations, and frontend-test handoff intents), frontend-scout-pi, task sources, and the generation-time Mock capability evidence to fill the runtime-owned frontend contract skeleton. Record the plan decision ledger through the incremental record_* tools, then call finalize_plan exactly once. The runtime already owns schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff; omit those protected paths even when their values look obvious.",
+                    "Commit requirements with record_plan_requirement (one entry per call) and verification targets with record_plan_verification_target (one entry per call). Evidence gaps are optional — call record_plan_evidence_gap only for genuine gaps. Never bundle these into finalize_plan arguments — finalize_plan only closes the plan. Splitting one entry per call keeps every single output small. Do NOT plan implementation steps: the implementer decides ordering itself.",
                     ...(requiresOpenspecClassification ? ["Additionally consume the frontend-contract-pi openspec classification. Successfully read every required selection (including mandatory paths) and declare any used component specReference in the typed decision ledger; relevant/irrelevant selections are not forced into the ledger unless the plan actually uses them."] : []),
                     "The incremental record_* facts become the complete implementation plan after deterministic merge with the protected skeleton. Do not treat leftover JSON in the narrative as the compile authority.",
                     "Select the Mock / API strategy only through record_mock_api. Encode endpoint/fixture mapping, explicit activation, verification commands, and Real Integration Gap in schema-defined fields; productionDefaultOff comes from the protected skeleton and there is no second plan output.",
-                    "Encode ordered steps (implementationSteps), target files, UI state handling, styling/component strategy (stylingStrategy), interaction notes, Mock/API strategy, dependency policy (dependencyPolicy), deterministic verification entrypoints, Real Integration Gap (realIntegrationGap), and residual risks (residualRisks) into the ledger payload. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
+                    "Encode target files, UI state handling, styling/component strategy (stylingStrategy), interaction notes, Mock/API strategy, dependency policy (dependencyPolicy), deterministic verification entrypoints, Real Integration Gap (realIntegrationGap), and residual risks (residualRisks) into the ledger payload. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
                     "Every target file and verification target must be selected from the current target workspace and task scope. Do not reuse paths or symbols from examples, prior tasks, or loop-agent itself; if the project uses app/, packages/, spec/, __tests__, or another layout, preserve that layout.",
                     "Consume the Scout target surface and design evidence before selecting files. Preserve the discovered existing entrypoint and data source. If implementationPaths or testPaths are outside task allowedPaths, record a blocking scope conflict; do not substitute a new page or silently broaden the writeSet.",
                     "Output a short Markdown narrative, record the incremental facts, then call finalize_plan exactly once. Do NOT emit protected skeleton fields or a full contract as the authority.",
@@ -3234,6 +3235,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: "HIGH",
                 writePolicy: "read-only",
+                retryPolicy: FRONTEND_REVIEW_TERMINAL_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_REVIEW_SKILLS,

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

@@ -228,6 +228,16 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             buildProtocolRetryInstruction(task.outputProtocol, previousProtocolReason),
         ].join("\n");
     }
+    if (previousFailureCategory === "review-terminal-missing") {
+        return [
+            basePrompt,
+            "",
+            "<retry_instruction>",
+            "The review emitted a verdict in response text but never committed the authoritative typed terminal tool call (approve_review / request_review_changes). The response text is NOT the authority: no branch or gate reads it.",
+            "Call exactly one typed terminal tool to finish: approve_review (implementation passes, no Critical/Important findings) or request_review_changes (with typed issueCategory, at least one evidenceRef, and non-empty findings). Do not repeat the review analysis; commit the terminal tool once and stop.",
+            "</retry_instruction>",
+        ].join("\n");
+    }
     if (previousFailureCategory === "invalid-output" &&
         task.structuredContractOutput &&
         previousProtocolReason) {

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

@@ -25,6 +25,13 @@ export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
 export const STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY = "invalid-output";
 /** Provider stopReason=length truncated the response before the JSON contract completed. */
 export const STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY = "structured-output-truncated";
+/**
+ * The review node emitted a verdict in response text (e.g. "VERDICT: pass")
+ * but never committed the authoritative typed terminal tool call
+ * (approve_review / request_review_changes). Read-only and safe to retry with
+ * a corrected instruction; the typed terminal is the only authority.
+ */
+export const REVIEW_TERMINAL_MISSING_RETRY_CATEGORY = "review-terminal-missing";
 /** Retry only a proven no-op from an explicitly opt-in bounded Pi writer. */
 export const WRITER_EMPTY_DIFF_RETRY_CATEGORY = "writer-empty-diff";
 /** Retry when a backend-test writer finished but Completeness Gate found missing/broken targets. */
@@ -57,6 +64,7 @@ export const ALL_DAG_RETRY_CATEGORIES = [
     WRITER_EMPTY_DIFF_RETRY_CATEGORY,
     INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
     WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
+    REVIEW_TERMINAL_MISSING_RETRY_CATEGORY,
 ];
 const RETRY_SAFE_PI_ROLES = new Set([
     "planner",
@@ -143,6 +151,20 @@ export const PROTOCOL_AWARE_PI_RETRY_POLICY = {
     ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
     retryCategories: [...PROTOCOL_AWARE_DAG_RETRY_CATEGORIES],
 };
+/**
+ * frontend-review-pi retry policy. The review verdict must be committed
+ * through the typed terminal tools (approve_review / request_review_changes);
+ * a model that only echoes "VERDICT: pass" text fails as
+ * review-terminal-missing. That is read-only and safe to retry with a
+ * corrected instruction so a single model slip does not burn the whole run.
+ */
+export const FRONTEND_REVIEW_TERMINAL_RETRY_POLICY = {
+    ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
+    retryCategories: [
+        ...DEFAULT_DAG_RETRY_CATEGORIES,
+        REVIEW_TERMINAL_MISSING_RETRY_CATEGORY,
+    ],
+};
 /**
  * The sole writer retry policy for requireChangedFiles writers. It is
  * intentionally not included in any read-only default: a writer may retry only

package/package.json

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