@tea-agent/loop-agent 0.4.0 → 0.6.0

package/dist/worker/pool/failure-routing.js

@@ -52,12 +52,14 @@ export function deriveFailureRoute(result) {
     if (result.status === "succeeded")
         return undefined;
     const primaryFailure = readObject(result.reportDecision.primaryFailure);
-    const category = readProductCategory(primaryFailure, "productLineFailureCategory") ??
-        readProductCategory(primaryFailure, "productLineCategory") ??
-        readProductCategory(primaryFailure, "product_line_failure_category") ??
-        mapDagCategory(readString(primaryFailure, "failureCategory")) ??
-        mapDagCategory(readString(primaryFailure, "normalizedFailureCategory")) ??
-        categoryFromDecisionReason(result.reportDecision.reason);
+    const category = looksLikeExecutorConfigurationFailure(primaryFailure)
+        ? "EnvFailure"
+        : readProductCategory(primaryFailure, "productLineFailureCategory") ??
+            readProductCategory(primaryFailure, "productLineCategory") ??
+            readProductCategory(primaryFailure, "product_line_failure_category") ??
+            mapDagCategory(readString(primaryFailure, "failureCategory")) ??
+            mapDagCategory(readString(primaryFailure, "normalizedFailureCategory")) ??
+            categoryFromDecisionReason(result.reportDecision.reason);
     const recommendedFollowUpKind = readString(primaryFailure, "recommendedFollowUpKind") ??
         readString(primaryFailure, "recommendedFollowUp") ??
         FOLLOW_UP_BY_CATEGORY[category];
@@ -68,6 +70,18 @@ export function deriveFailureRoute(result) {
         source: primaryFailure ? "report-primary-failure" : "fallback",
     };
 }
+/** Route a failure raised before a DAG report can be produced. */
+export function deriveFailureRouteFromError(message, businessId) {
+    const category = looksLikeExecutorConfigurationText(message)
+        ? "EnvFailure"
+        : "Unknown";
+    return {
+        category,
+        recommendedFollowUpKind: FOLLOW_UP_BY_CATEGORY[category],
+        derivedFollowUpTaskId: `${FOLLOW_UP_PREFIX_BY_CATEGORY[category]}-${businessId}`,
+        source: "runner-error",
+    };
+}
 function readProductCategory(value, key) {
     const candidate = readString(value, key);
     return candidate && PRODUCT_CATEGORIES.has(candidate)
@@ -85,6 +99,27 @@ function categoryFromDecisionReason(reason) {
     }
     return "Unknown";
 }
+function looksLikeExecutorConfigurationFailure(value) {
+    if (!value)
+        return false;
+    return looksLikeExecutorConfigurationText([
+        "failureCategory",
+        "normalizedFailureCategory",
+        "message",
+        "error",
+        "stderr",
+        "detail",
+    ]
+        .map((key) => readString(value, key))
+        .filter((candidate) => Boolean(candidate))
+        .join("\n"));
+}
+function looksLikeExecutorConfigurationText(message) {
+    const value = message.toLowerCase();
+    const executorTerms = /provider|model|executor|api[ _-]?key|credential|thinking level/;
+    const configurationTerms = /unknown|invalid|unsupported|missing|not configured|configuration|unavailable/;
+    return executorTerms.test(value) && configurationTerms.test(value);
+}
 function readObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;

package/dist/worker/pool/run-store.js

@@ -22,6 +22,48 @@ export async function findRunByWorkerRunId(repoRoot, workerRunId) {
     const runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
     return runs.find((run) => run.workerRunId === workerRunId);
 }
+/**
+ * Explicitly requeue a failed task without deleting or rewriting prior evidence.
+ * The runner consumes `retryOfWorkerRunId` and derives a guaranteed fresh run id.
+ */
+export async function prepareTaskPoolRetry(input) {
+    const current = await readTaskPoolState(input.repoRoot, input.taskId);
+    if (!current) {
+        throw new Error(`cannot retry ${input.taskId}: Task Pool state does not exist`);
+    }
+    if (current.status !== "Failed") {
+        throw new Error(`cannot retry ${input.taskId}: expected Failed state, found ${current.status}`);
+    }
+    if (!current.workerRunId) {
+        throw new Error(`cannot retry ${input.taskId}: failed state is missing workerRunId`);
+    }
+    const retryRequestedAt = (input.now ?? new Date()).toISOString();
+    const result = {
+        taskId: input.taskId,
+        status: "Ready",
+        previousWorkerRunId: current.workerRunId,
+        retryRequestedAt,
+        ...(input.reason ? { reason: input.reason } : {}),
+    };
+    await writeTaskPoolState(input.repoRoot, {
+        taskId: current.taskId,
+        status: "Ready",
+        updatedAt: retryRequestedAt,
+        retryOfWorkerRunId: current.workerRunId,
+        retryRequestedAt,
+        ...(input.reason ? { retryReason: input.reason } : {}),
+    });
+    await ensurePoolDirs(input.repoRoot);
+    await appendJsonlFile(getEventsJsonlPath(input.repoRoot), {
+        schemaVersion: 1,
+        at: retryRequestedAt,
+        type: "task-retry-requested",
+        taskId: input.taskId,
+        previousWorkerRunId: current.workerRunId,
+        ...(input.reason ? { reason: input.reason } : {}),
+    });
+    return result;
+}
 export async function readTaskPoolState(repoRoot, taskId) {
     const statePath = getTaskStatePath(repoRoot, taskId);
     try {
@@ -74,7 +116,15 @@ export async function readJsonlFile(filePath) {
 }
 async function appendJsonlFile(filePath, value) {
     await mkdir(path.dirname(filePath), { recursive: true });
-    await appendFile(filePath, `${JSON.stringify(value)}\n`, "utf-8");
+    try {
+        await appendFile(filePath, `${JSON.stringify(value)}\n`, "utf-8");
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        // Include path so callers/tests can identify which JSONL file failed
+        // (Node EISDIR messages on Windows often omit the path).
+        throw new Error(`failed to append ${filePath}: ${detail}`, { cause: error });
+    }
 }
 async function ensurePoolDirs(repoRoot) {
     await mkdir(path.join(getTaskPoolRoot(repoRoot), "runs"), { recursive: true });
@@ -89,11 +139,19 @@ function stateFromRun(run) {
         workerRunId: run.workerRunId,
         ...(run.runRecordPath ? { lastRunRecordPath: run.runRecordPath } : {}),
         ...(run.failure ? { failure: run.failure } : {}),
+        ...(run.retryOfWorkerRunId
+            ? { retryOfWorkerRunId: run.retryOfWorkerRunId }
+            : {}),
     };
 }
 function stateStatusFromRun(run) {
     if (run.status === "succeeded")
         return "Done";
+    // A pre-DAG provider/executor configuration failure is retryable after the
+    // operator corrects the environment; do not bury it in a non-retryable Blocked state.
+    if (run.status === "run-error" && run.failure?.category === "EnvFailure") {
+        return "Failed";
+    }
     if (run.status === "run-error")
         return "Blocked";
     return "Failed";

package/dist/worker/progress-reporter.js

@@ -1,21 +1,3 @@
-/**
- * Human-readable progress reporting for long-running worker commands.
- *
- * Why this exists: agent-worker batch runs can take many minutes per task with
- * zero stdout/stderr feedback, which looks indistinguishable from a hang. The
- * system writes rich state to disk (state.json, run.json, .task-pool artifacts)
- * but never echoes it to the triggering terminal, so users assume it is dead.
- *
- * Design:
- * - Progress goes to STDERR only. STDOUT stays reserved for the final
- *   machine-readable JSON payload, so `... | jq` and pipes keep working.
- * - Default ON. `--quiet` disables it. Non-interactive use that only wants JSON
- *   can pass `--quiet` (or redirect stderr).
- * - TTY-aware for ANSI only: if stderr is not a TTY, we still print the lines
- *   (they are line-buffered text and flush fine) but skip ANSI decoration.
- * - A `noop` reporter keeps library callers (and tests that don't care) quiet
- *   with zero changes to their call sites beyond accepting the option.
- */
 const ANSI = {
     bold: "\x1b[1m",
     green: "\x1b[32m",