@tea-agent/loop-agent 0.38.0 → 0.38.2

package/dist/workflows/dag/convergence/controller.js

@@ -21,6 +21,17 @@ const REVIEW_VERDICT_NODE_ID = "review-verdict-recovery-pi";
 const INITIAL_REVIEW_NODE_ID = "initial-review-pi";
 const INITIAL_REVIEW_GATE_NODE_ID = "initial-review-gate-shell";
 const INITIAL_REVIEW_PASS_NODE_ID = "initial-review-pass-shell";
+/**
+ * Standard-dag governance verify chain ids. When the convergence chain
+ * observes the governance standard gate, a legitimate verify-pi
+ * `request-revision` re-enters a bounded implement-repair loop instead of
+ * terminating the run at the gate, mirroring the review-chain re-entry
+ * semantics (AC3/AC4). Protocol/provider/safety failures on verify-pi keep
+ * failing closed; only a safe `request-revision` drives code repair here.
+ */
+const GOVERNANCE_VERIFY_GATE_NODE_ID = "governance-standard-gate-shell";
+const GOVERNANCE_VERIFY_NODE_ID = "verify-pi";
+const GOVERNANCE_VERIFY_WRITER_NODE_ID = "implement-pi";
 // Automatic code repair is authorized only for an ordinary command/test
 // failure. Unknown, protocol, validation, provider, safety, governance, and
 // human-decision categories all fail closed instead of reaching a writer.
@@ -57,6 +68,15 @@ export async function runConvergencePassController(input) {
     }
     const chain = getConvergenceChain(input.spec);
     const observesReview = chain.includes(REVIEW_GATE_NODE_ID);
+    const observesGovernanceVerify = chain.includes(GOVERNANCE_VERIFY_GATE_NODE_ID);
+    // Standard-dag governance verify convergence: verify-pi drives a bounded
+    // implement-repair loop on `request-revision`. This shape has no
+    // hard-verify/review nodes; dispatch before the legacy hard-verify logic so
+    // the standard governance DAG never falls into `unsupported-dag-shape`/
+    // `non-retry-failure` dead ends.
+    if (observesGovernanceVerify && !observesReview) {
+        return handleGovernanceVerifyConvergence(input);
+    }
     if (input.tasksById.has(INITIAL_REVIEW_NODE_ID)) {
         const initialReview = input.state.nodes[INITIAL_REVIEW_NODE_ID];
         const initialGate = input.state.nodes[INITIAL_REVIEW_GATE_NODE_ID];
@@ -397,6 +417,127 @@ async function handleReviewRequestRevision(input, reviewGate) {
 function getConvergenceChain(spec) {
     return spec.convergence?.chainNodeIds ?? DEFAULT_CONVERGENCE_CHAIN_NODE_IDS;
 }
+/**
+ * Legitimate governance verify revision: verify-pi finished and emitted
+ * `request-revision`. No secondary verdict-recovery node exists on the
+ * standard dag, so the single verify-pi verdict plus a non-transport failure
+ * category is the legitimacy bar (protocol-invalid/invalid-output/timeout on
+ * verify-pi fail closed instead of driving repair).
+ */
+function isLegitimateGovernanceVerifyRevision(state) {
+    const verifyNode = state.nodes[GOVERNANCE_VERIFY_NODE_ID];
+    return (verifyNode?.status === "FINISHED" &&
+        parseProcessVerdict(verifyNode) === "request-revision");
+}
+function isLegitimateGovernanceVerifyPass(state) {
+    const verifyNode = state.nodes[GOVERNANCE_VERIFY_NODE_ID];
+    return (verifyNode?.status === "FINISHED" &&
+        parseProcessVerdict(verifyNode) === "pass");
+}
+/**
+ * Standard-dag governance verify convergence loop. Terminal pass when
+ * verify-pi passes; bounded re-entry (reset implement-pi + verify chain) when
+ * verify-pi legitimately requests revision. The reset lets the next
+ * implement-pi pass consume the prior verify findings through the structured
+ * convergence feedback block (node-execution injects it for implementer
+ * roles), so `already-satisfied` no-ops are explicitly contradicted by the
+ * preserved verify-pi evidence refs.
+ */
+async function handleGovernanceVerifyConvergence(input) {
+    const convergence = input.state.convergence;
+    const currentPass = convergence.currentPass || 1;
+    const verifyNode = input.state.nodes[GOVERNANCE_VERIFY_NODE_ID];
+    const verifyShell = input.state.nodes["verify-shell"];
+    // Hard verify commands failed: not a governance verdict issue. Without a
+    // supervised repair chain, this stays terminal so the failure-aware
+    // closeout reports it truthfully.
+    if (verifyShell?.status === "ERROR") {
+        const passRecord = await buildConvergencePassRecord({
+            pass: currentPass,
+            status: "terminal",
+            reason: "hard-verify-failed",
+            state: input.state,
+            runDir: input.runDir,
+            spec: input.spec,
+        });
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "hard-verify-failed";
+        await input.persistState();
+        return { retry: false };
+    }
+    if (isLegitimateGovernanceVerifyPass(input.state)) {
+        convergence.terminalReason = "hard-verify-pass";
+        await appendConvergenceKnowledgePattern({
+            cwd: input.cwd,
+            state: input.state,
+        });
+        return { retry: false };
+    }
+    const verifyFailureCategory = verifyNode?.failureCategory;
+    const legitimateRevision = isLegitimateGovernanceVerifyRevision(input.state);
+    if (!legitimateRevision ||
+        (verifyFailureCategory &&
+            REVIEW_SOURCE_NON_RETRY_FAILURES.has(verifyFailureCategory))) {
+        const passRecord = await buildConvergencePassRecord({
+            pass: currentPass,
+            status: "terminal",
+            reason: "non-retry-failure",
+            state: input.state,
+            runDir: input.runDir,
+            spec: input.spec,
+        });
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "non-retry-failure";
+        await input.persistState();
+        return { retry: false };
+    }
+    const passRecord = await buildConvergencePassRecord({
+        pass: currentPass,
+        status: "retrying",
+        reason: "verify-request-revision",
+        state: input.state,
+        runDir: input.runDir,
+        spec: input.spec,
+    });
+    if (currentPass >= convergence.maxPasses) {
+        passRecord.status = "terminal";
+        passRecord.reason = "max-passes";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "max-passes";
+        await input.persistState();
+        return { retry: false };
+    }
+    convergence.passHistory.push(passRecord);
+    convergence.currentPass = currentPass + 1;
+    // Reset the writer plus the governance verify chain: the next implement-pi
+    // pass must consume the preserved verify-pi findings (injected as
+    // convergence feedback) instead of returning already-satisfied.
+    for (const id of collectGovernanceVerifyResetIds(input.spec)) {
+        const task = input.tasksById.get(id);
+        if (!task)
+            continue;
+        input.state.nodes[id] = freshNodeRecord(task);
+    }
+    await input.persistState();
+    return { retry: true };
+}
+/**
+ * Reset set for the governance verify loop: the exclusive writer and the
+ * verify chain closure (verify-shell, verify-pi, governance gate, and every
+ * transitive descendant so closeout re-adjudicates from fresh evidence).
+ */
+function collectGovernanceVerifyResetIds(spec) {
+    const resetIds = new Set([
+        GOVERNANCE_VERIFY_WRITER_NODE_ID,
+        "verify-shell",
+        GOVERNANCE_VERIFY_NODE_ID,
+        GOVERNANCE_VERIFY_GATE_NODE_ID,
+    ]);
+    for (const id of collectTransitiveDescendantTaskIds(spec, GOVERNANCE_VERIFY_GATE_NODE_ID)) {
+        resetIds.add(id);
+    }
+    return resetIds;
+}
 function hasConvergenceChain(tasksById, spec) {
     const chain = getConvergenceChain(spec);
     return chain.every((id) => tasksById.has(id));

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -367,19 +367,26 @@ export async function executeDynamicMapExpansion(input) {
         }
     }
     const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
+    const failOnTokenBudgetExhaustion = input.expansion.failOnTokenBudgetExhaustion === true;
     const failedChildren = tolerateChildFailures
         ? []
         : childNodeIds.filter((nodeId) => {
             const record = input.state.nodes[nodeId];
             if (!record || record.status === "FINISHED")
                 return false;
-            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
-                return false;
+            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record)) {
+                return failOnTokenBudgetExhaustion;
+            }
             return true;
         });
+    const finishedItemCount = childNodeIds.filter((nodeId) => input.state.nodes[nodeId]?.status === "FINISHED").length;
+    const blockedItemCount = budgetBlockedIds.size;
     const aggregate = {
         workflowNodeId: input.expansion.workflowNodeId,
         itemCount: items.length,
+        expectedItemCount: items.length,
+        finishedItemCount,
+        blockedItemCount,
         children: childNodeIds.map((nodeId, index) => ({
             nodeId,
             item: items[index],
@@ -399,21 +406,30 @@ export async function executeDynamicMapExpansion(input) {
                 ?.reason,
         })),
         tokensUsed: totalTokensUsed,
+        maxTotalTokens: tokenBudget?.maxTotalTokens,
         caseOutcomeNotes: caseOutcomeNotes.length > 0 ? caseOutcomeNotes : undefined,
     };
+    const tokenBudgetFailure = failOnTokenBudgetExhaustion && blockedItemCount > 0;
     return {
-        // With tolerateChildFailures: barrier always succeeds; product outcomes live in
-        // case evidence + result materialization. Without it: real child failures fail-close.
-        ok: failedChildren.length === 0,
+        // With tolerateChildFailures: barrier succeeds and product outcomes live in
+        // case evidence. Backend-test opts into token-budget fail-closed because a
+        // partial generated module set is never a valid downstream input.
+        ok: failedChildren.length === 0 && !tokenBudgetFailure,
         stdout: JSON.stringify(aggregate),
         stderr: caseOutcomeNotes.length > 0
             ? `map children recorded as case outcomes: ${caseOutcomeNotes
                 .map((entry) => `${entry.nodeId}=${entry.status}:${entry.reason}`)
                 .join(", ")}`
+            : tokenBudgetFailure
+                ? `dynamic map token budget exhausted: expected=${items.length} finished=${finishedItemCount} blocked=${blockedItemCount} tokensUsed=${totalTokensUsed} maxTotalTokens=${tokenBudget?.maxTotalTokens ?? "unbounded"}`
+                : failedChildren.length > 0
+                    ? `dynamic map children failed: ${failedChildren.join(", ")}`
+                    : "",
+        failureCategory: tokenBudgetFailure
+            ? "dynamic-expansion-token-budget-exhausted"
             : failedChildren.length > 0
-                ? `dynamic map children failed: ${failedChildren.join(", ")}`
-                : "",
-        failureCategory: failedChildren.length > 0 ? "dynamic-expansion-child-failed" : "success",
+                ? "dynamic-expansion-child-failed"
+                : "success",
         durationMs: Date.now() - started,
     };
 }

package/dist/workflows/dag/dynamic-runtime/shared.js

@@ -30,7 +30,7 @@ export function getNodeOutputAsJson(state, nodeId) {
 /** Normalize a line the same way verdict gates do (strip whole-line Markdown emphasis). */
 export function normalizeVerdictCandidateLine(value) {
     const trimmed = String(value).trim();
-    const emphasized = trimmed.match(/^\*{1,3}\s*(VERDICT:[^*]+?)\s*\*{1,3}$/);
+    const emphasized = trimmed.match(/^(?:`{1,3}|\*{1,3})\s*(VERDICT:[^`*]+?)\s*(?:`{1,3}|\*{1,3})$/);
     const line = (emphasized ? emphasized[1] : trimmed).trim();
     // Canonicalize the colon separator and trailing sentence punctuation so
     // "VERDICT:pass", "VERDICT:  pass", or "VERDICT: pass." match the declared

package/dist/workflows/dag/failure-routing.js

@@ -44,7 +44,9 @@ function routeToProductLine(input) {
         case "decision-envelope":
             return "NeedsHuman";
         case "skipped":
-            return "DependencyFailure";
+            return input.skippedReason === "frontend-prewrite-not-authorized"
+                ? "ContractMismatch"
+                : "DependencyFailure";
         case "shell-command":
             if (/\b(ENOENT|PATH|command not found|No such file|not found in PATH|bash: .*: No such file)\b/i.test(raw)) {
                 return "EnvFailure";
@@ -90,9 +92,12 @@ export function routeDagFailure(input) {
     if (!productLineFailureCategory)
         return {};
     const recommendedFollowUp = productLineFailureCategory === "ContractMismatch" &&
-        isFrontendDesignGateNode(input.nodeId ?? "")
-        ? "frontend-plan-revision-and-rerun"
-        : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
+        input.skippedReason === "frontend-prewrite-not-authorized"
+        ? "fix-frontend-task-contract-and-regenerate-dag"
+        : productLineFailureCategory === "ContractMismatch" &&
+            isFrontendDesignGateNode(input.nodeId ?? "")
+            ? "frontend-plan-revision-and-rerun"
+            : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
     return {
         productLineFailureCategory,
         recommendedFollowUp,