@tea-agent/loop-agent 0.20.1-beta.0 → 0.20.1

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

@@ -8,6 +8,7 @@ import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
+import { buildProtocolRetryInstruction, validateOutputProtocol, } from "./output-protocol.js";
 import { writeDagNodeJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { buildProjectGovernanceContext, readCompletedWriterChangeManifests, writeProjectGovernanceContext, } from "./project-governance-context.js";
 import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
@@ -25,9 +26,19 @@ export function buildNodePrompt(spec, task, upstream, options) {
         projectGovernanceContext: options?.projectGovernanceContext,
     });
 }
-function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory) {
-    if (attemptNumber <= 1 ||
-        task.outputMode !== "structured-required" ||
+function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason) {
+    if (attemptNumber <= 1)
+        return basePrompt;
+    if (previousFailureCategory === "protocol-invalid" &&
+        task.outputProtocol &&
+        previousProtocolReason) {
+        return [
+            basePrompt,
+            "",
+            buildProtocolRetryInstruction(task.outputProtocol, previousProtocolReason),
+        ].join("\n");
+    }
+    if (task.outputMode !== "structured-required" ||
         previousFailureCategory !== "output-too-large") {
         return basePrompt;
     }
@@ -301,6 +312,7 @@ export async function executeDagNode(input) {
     let totalBackoffMs = 0;
     let terminalResult;
     let previousFailureCategory;
+    let previousProtocolReason;
     for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
         const attemptStartedAt = new Date().toISOString();
         const attemptStarted = Date.now();
@@ -315,7 +327,7 @@ export async function executeDagNode(input) {
                 task,
                 cwd,
                 model,
-                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory),
+                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason),
             });
         }
         catch (error) {
@@ -326,6 +338,26 @@ export async function executeDagNode(input) {
                 durationMs: Date.now() - attemptStarted,
             };
         }
+        // R0: executor ok=true still fails closed when outputProtocol is violated.
+        // Valid semantic results (e.g. VERDICT: request-revision) pass validation.
+        if (result.ok && task.outputProtocol) {
+            const protocolText = `${result.assistantText ?? ""}\n${result.stdout ?? ""}`;
+            const protocolCheck = validateOutputProtocol(task.outputProtocol, protocolText);
+            if (!protocolCheck.ok) {
+                result = {
+                    ...result,
+                    ok: false,
+                    failureCategory: protocolCheck.failureCategory,
+                    stderr: [result.stderr, protocolCheck.reason]
+                        .filter(Boolean)
+                        .join("\n"),
+                };
+                previousProtocolReason = protocolCheck.reason;
+            }
+            else {
+                previousProtocolReason = undefined;
+            }
+        }
         const attemptFinishedAt = new Date().toISOString();
         const attemptRecord = {
             attempt: attemptNumber,
@@ -384,9 +416,11 @@ export async function executeDagNode(input) {
             break;
         const canRetry = retryPolicy !== undefined && attemptNumber < maxAttempts;
         const retryable = retryPolicy !== undefined &&
-            isRetryablePiFailureCategory(result.failureCategory, {
+            (isRetryablePiFailureCategory(result.failureCategory, {
                 retryCategories: retryPolicy.retryCategories,
-            });
+            }) ||
+                (result.failureCategory === "protocol-invalid" &&
+                    task.outputProtocol?.retryOnInvalid === true));
         if (!canRetry || !retryable)
             break;
         const delayMs = computeBackoffDelayMs(attemptNumber + 1, retryPolicy);

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/**
+ * Machine-readable output protocol for safe read-only Pi nodes.
+ *
+ * Phase 1 only supports first-line-enum (e.g. VERDICT lines). Structured JSON
+ * continues to use existing structured-required / deterministic gates.
+ */
+export const dagOutputProtocolSchema = z
+    .object({
+    type: z.literal("first-line-enum"),
+    validLines: z.array(z.string().min(1)).min(1),
+    retryOnInvalid: z.boolean().default(true),
+})
+    .strict();
+/** Reviewer VERDICT protocol used by reviewed/supervised DAGs. */
+export const REVIEW_VERDICT_OUTPUT_PROTOCOL = {
+    type: "first-line-enum",
+    validLines: ["VERDICT: pass", "VERDICT: request-revision"],
+    retryOnInvalid: true,
+};
+/**
+ * Extract the first non-empty line from assistant/stdout text.
+ */
+export function firstNonEmptyLine(text) {
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return undefined;
+}
+/**
+ * Validate node output against an explicit outputProtocol.
+ * Pure function — does not mutate run facts.
+ */
+export function validateOutputProtocol(protocol, text) {
+    if (protocol.type !== "first-line-enum") {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: `unsupported outputProtocol.type: ${protocol.type ?? "unknown"}`,
+        };
+    }
+    const first = firstNonEmptyLine(text);
+    if (!first) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: `missing first non-empty line; expected one of: ${protocol.validLines.map((l) => JSON.stringify(l)).join(" or ")}`,
+        };
+    }
+    if (!protocol.validLines.includes(first)) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: `first non-empty line ${JSON.stringify(first)} is not a valid protocol line; expected one of: ${protocol.validLines.map((l) => JSON.stringify(l)).join(" or ")}`,
+            firstNonEmptyLine: first,
+        };
+    }
+    return { ok: true, matchedLine: first };
+}
+/**
+ * Correction instruction appended on protocol-invalid retry attempts.
+ */
+export function buildProtocolRetryInstruction(protocol, reason) {
+    const expected = protocol.validLines
+        .map((line) => JSON.stringify(line))
+        .join(" or ");
+    return [
+        "<retry_instruction>",
+        "Previous attempt violated the output protocol:",
+        reason,
+        `Return one valid protocol line before any explanation. Expected first non-empty line: ${expected}.`,
+        "</retry_instruction>",
+    ].join("\n");
+}