@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

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

@@ -3,7 +3,8 @@ import path from "node:path";
 import { generateTaskDagUseCase } from "../../application/dag/generate-task-dag.js";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { DAG_RUNS_DIR, isTerminalDagRunStatus, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
-import { parseDagSpec } from "./types.js";
+import { deriveDagRerunFeedback } from "./rerun-feedback.js";
+import { parseDagSpec, } from "./types.js";
 export const RERUN_TASK_LINEAGE_REL_PATH = ".runtime/rerun-task-lineage.json";
 export function parseDagRerunTaskArgs(args) {
     if (args.length === 0) {
@@ -218,6 +219,7 @@ async function writeRerunTaskLineage(cwd, newRunId, input) {
         parentRunId: input.parentRunId,
         reason: input.reason,
         requestId: input.requestId,
+        feedback: input.feedback,
         createdAt: new Date().toISOString(),
     }, { repoRoot: cwd, allowCompletedFactsWrite: true });
 }
@@ -228,12 +230,30 @@ function blockedResult(input) {
         reason: input.reason,
         requestId: input.requestId,
         mode: "blocked",
+        feedback: input.feedback ?? {
+            inherited: false,
+            reason: "no-unresolved-verify-review-feedback",
+        },
         blockedReason: input.blockedReason,
         ...(input.note ? { note: input.note } : {}),
         ...(input.taskId ? { taskId: input.taskId } : {}),
         ...(input.conflictPaths ? { conflictPaths: input.conflictPaths } : {}),
     };
 }
+async function readGeneratedRerunFeedback(outputPath) {
+    const raw = JSON.parse(await readFile(outputPath, "utf8"));
+    return parseDagSpec(raw).rerunFeedback;
+}
+function summarizeFeedback(feedback, fallbackReason) {
+    return feedback
+        ? {
+            inherited: true,
+            sourceNodeId: feedback.sourceNodeId,
+            digest: feedback.digest,
+            bindingStatus: feedback.binding.status,
+        }
+        : { inherited: false, reason: fallbackReason };
+}
 function extractRunSummary(generateResult) {
     if (generateResult.mode === "generate+basic-validate")
         return undefined;
@@ -277,7 +297,26 @@ export async function rerunStandaloneTask(input) {
             note: eligibility.note,
         });
     }
+    let parentFeedback;
+    let missingFeedbackReason = "no-unresolved-verify-review-feedback";
+    try {
+        parentFeedback = await deriveDagRerunFeedback({
+            parentRunId: input.parentRunId,
+            taskId: taskResolution.taskId,
+            runDir: located.runDir,
+            spec,
+            state,
+        });
+    }
+    catch {
+        // Feedback is additive recovery context. A corrupt/missing historical
+        // artifact must be reported honestly but must not block an otherwise
+        // eligible full rerun.
+        missingFeedbackReason = "feedback-unavailable";
+    }
     const execute = input.execute ?? true;
+    let effectiveFeedback;
+    let expectedRerunFeedbackDigest;
     // AC-001 generated-output-conflict preflight: when a real execution is
     // requested, first generate the DAG draft (execute:false) so we can inspect
     // the regenerated spec's requireChangedFiles writer write sets against
@@ -296,15 +335,23 @@ export async function rerunStandaloneTask(input) {
             dryRun: false,
             profile: input.profile ?? "auto",
             profileExplicit: input.profileExplicit ?? false,
+            rerunFeedback: parentFeedback,
         });
         if (preflight.mode === "generate+basic-validate") {
             let conflictPaths = [];
             try {
                 const raw = await readFile(preflight.outputPath, "utf8");
                 const preflightSpec = parseDagSpec(JSON.parse(raw));
+                effectiveFeedback = preflightSpec.rerunFeedback;
+                expectedRerunFeedbackDigest = effectiveFeedback?.digest;
+                if (parentFeedback && !effectiveFeedback) {
+                    throw new Error("rerun feedback missing from generated preflight DAG");
+                }
                 conflictPaths = await assessGeneratedOutputConflict(preflightSpec, input.cwd);
             }
-            catch {
+            catch (error) {
+                if (parentFeedback)
+                    throw error;
                 // If the draft cannot be parsed, fall through to the real execution
                 // path: execution's own validation will surface the structural defect.
                 conflictPaths = [];
@@ -332,7 +379,17 @@ export async function rerunStandaloneTask(input) {
         dryRun: false,
         profile: input.profile ?? "auto",
         profileExplicit: input.profileExplicit ?? false,
+        rerunFeedback: parentFeedback,
+        expectedRerunFeedbackDigest,
     });
+    if (parentFeedback && !effectiveFeedback) {
+        effectiveFeedback = await readGeneratedRerunFeedback(generateResult.outputPath);
+    }
+    if (expectedRerunFeedbackDigest &&
+        effectiveFeedback?.digest !== expectedRerunFeedbackDigest) {
+        throw new Error(`rerun feedback drift after generation: expected ${expectedRerunFeedbackDigest}, got ${effectiveFeedback?.digest ?? "missing"}`);
+    }
+    const feedbackSummary = summarizeFeedback(effectiveFeedback, missingFeedbackReason);
     const newRunId = extractNewRunId(generateResult);
     const runSummary = extractRunSummary(generateResult);
     const completedSuccessfully = !execute ||
@@ -342,6 +399,7 @@ export async function rerunStandaloneTask(input) {
             parentRunId: input.parentRunId,
             reason: input.reason,
             requestId: input.requestId,
+            feedback: feedbackSummary,
         });
     }
     const result = {
@@ -350,6 +408,7 @@ export async function rerunStandaloneTask(input) {
         reason: input.reason,
         requestId: input.requestId,
         mode: "generate+validate+execute",
+        feedback: feedbackSummary,
         taskId: taskResolution.taskId,
         ...(newRunId ? { newRunId } : {}),
         ...(runSummary && !completedSuccessfully && "status" in runSummary

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

@@ -165,6 +165,36 @@ export const WRITER_TRANSPORT_RETRY_POLICY = {
     maxDelayMs: 30000,
     retryCategories: [WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY],
 };
+/**
+ * Implicit runtime retry for canonical final verify shells. Not a DagRetryPolicy:
+ * `spawn-error` / `test-timeout` are runtime command categories and must not enter
+ * `dagRetryPolicySchema` / `ALL_DAG_RETRY_CATEGORIES`.
+ */
+export const VERIFY_SHELL_RETRY_CATEGORIES = [
+    "timeout",
+    "spawn-error",
+    "test-timeout",
+];
+export const VERIFY_SHELL_RETRY_POLICY = {
+    maxAttempts: 2,
+    backoff: "exponential",
+    initialDelayMs: 2000,
+    maxDelayMs: 30000,
+    retryCategories: VERIFY_SHELL_RETRY_CATEGORIES,
+};
+export const TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE = "standard-reviewed-supervised-v1";
+/**
+ * Target-template exclusive implement-pi transport retry. Same schema category
+ * as frontend (`writer-clean-timeout`) so DagSpec validation stays unchanged;
+ * only the delay cap is wider. Do not mutate {@link WRITER_TRANSPORT_RETRY_POLICY}.
+ */
+export const TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY = {
+    maxAttempts: 2,
+    backoff: "exponential",
+    initialDelayMs: 5000,
+    maxDelayMs: 60000,
+    retryCategories: [WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY],
+};
 /**
  * Backend-test generation writers: empty-diff once, plus bounded incomplete-write-set
  * recovery attempts driven by Completeness Gate (missing/broken target files).
@@ -201,6 +231,24 @@ function isExclusivePiImplementer(task) {
         !task.dynamicCondition &&
         !task.dynamicLoopUntil);
 }
+/**
+ * Provider/transport failure categories that can crash a writer executor
+ * after some workspace writes already landed on disk. A continuation may
+ * restart that writer itself; it must never import or normalize the ERROR fact.
+ */
+export const WRITER_TRANSPORT_FAILURE_CATEGORIES = new Set([
+    "unavailable",
+    "network",
+    "rate-limit",
+    "timeout",
+]);
+export function isTransportCrashedExclusiveWriter(task, failureCategory) {
+    if (!task)
+        return false;
+    return (isExclusivePiImplementer(task) &&
+        failureCategory !== undefined &&
+        WRITER_TRANSPORT_FAILURE_CATEGORIES.has(failureCategory));
+}
 /**
  * Static eligibility for the requireChangedFiles writer-empty-diff class.
  * The Pi executor assigns writer-empty-diff only after post-write-guard
@@ -220,6 +268,67 @@ export function isWriterTransportRetryCandidate(task) {
         task.writerOutcomePolicy?.type === "implementation-outcome-v1" &&
         task.writerOutcomePolicy.requireChangedFiles !== true);
 }
+/**
+ * Canonical standard exclusive `implement-pi` only. Frontend designers and
+ * completeness writers stay on the existing timeout-only transport candidate.
+ */
+export function isTargetTemplateImplementPi(task) {
+    return isWriterTransportRetryCandidate(task) && task.id === "implement-pi";
+}
+export function hasTargetTemplateTransientRetryProfile(task) {
+    return (task?.transientRetryProfile === TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE);
+}
+/**
+ * Dual-condition eligibility: canonical shape AND generated-path stamp.
+ * Custom / other-template nodes that only match id or shape stay ineligible.
+ */
+export function isTargetTemplateTransientRetryNode(task) {
+    if (!hasTargetTemplateTransientRetryProfile(task))
+        return false;
+    return (isCanonicalFinalVerifyShellRetryCandidate(task) ||
+        isTargetTemplateImplementPi(task));
+}
+/**
+ * Shape-based eligibility for implicit canonical final verify-shell retry.
+ * Does not consult node id or a template field.
+ */
+export function isCanonicalFinalVerifyShellRetryCandidate(task) {
+    if (task.executor !== "shell")
+        return false;
+    if (task.role !== "verifier")
+        return false;
+    if (task.writePolicy !== undefined &&
+        task.writePolicy !== "read-only" &&
+        task.writePolicy !== "none") {
+        return false;
+    }
+    if ((task.writeSet?.length ?? 0) > 0)
+        return false;
+    const shell = task.shell;
+    if (!shell || (shell.commands?.length ?? 0) === 0)
+        return false;
+    const evidence = shell.verifyEvidence;
+    if (!evidence)
+        return false;
+    if (evidence.phase !== "final")
+        return false;
+    if (evidence.quota !== "full")
+        return false;
+    if (evidence.commandSource !== "adapter")
+        return false;
+    if (evidence.finalFullRequired !== true)
+        return false;
+    if (shell.frontendPrewriteGate ||
+        shell.frontendVerificationBundle ||
+        shell.frontendBrowserToolPreflight ||
+        shell.backendTestPipeline ||
+        shell.jacocoCoverage ||
+        shell.repairArtifactGate ||
+        shell.verdictGate) {
+        return false;
+    }
+    return true;
+}
 export function isSafeReadOnlyPiRetryCandidate(task) {
     if (task.executor !== "pi")
         return false;