@sagentlab/navarch-runtime 0.1.76 → 0.1.78

package/dist/agent-auth.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAgentAuthFailure = detectAgentAuthFailure;
+const exit_conditions_cjs_1 = require("./exit-conditions.cjs");
+/**
+ * Errors the coding agent CLIs print when their stored login cannot be used.
+ * Matched only against CLI-authored error channels (a structured error result,
+ * Codex error events, stderr), never the agent's own prose, so a task about a
+ * login page cannot pause the machine.
+ *
+ * - Claude Code: "Failed to authenticate: OAuth session expired and could not
+ *   be refreshed", "OAuth token has expired", "Invalid API key · Please run
+ *   /login", "Not logged in · Please run /login", 401 authentication_error.
+ * - Codex: "Your access token could not be refreshed because your refresh
+ *   token has expired/was already used", "Not logged in", "Please run `codex
+ *   login`", token_expired / refresh_token_* error codes.
+ */
+const AGENT_AUTH_PATTERNS = [
+    /\bfailed to authenticate\b/i,
+    /\boauth (?:session|token) (?:has )?expired\b/i,
+    /\bplease run \/login\b/i,
+    /\bnot logged in\b/i,
+    /\bcodex login\b/i,
+    /\baccess token could not be refreshed\b/i,
+    /\brefresh token (?:has expired|was already used|is invalid|expired)\b/i,
+    /\b(?:refresh_token_(?:expired|reused|invalidated)|token_expired)\b/i,
+    /\bauthentication_error\b/i,
+];
+function matchingLine(text) {
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed && AGENT_AUTH_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+            return trimmed.length > 300 ? `${trimmed.slice(0, 299)}…` : trimmed;
+        }
+    }
+    return null;
+}
+/**
+ * Detects a turn that ended because the coding agent CLI could not
+ * authenticate. Only failed turns qualify: a clean exit whose structured result
+ * is not an error did real work, whatever its transcript mentions.
+ */
+function detectAgentAuthFailure(result) {
+    if (result.killedByLeaseLoss || result.timedOut || result.capacityError)
+        return null;
+    const claude = (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stdout) ?? (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stderr);
+    if (claude) {
+        if (!claude.is_error && result.exitCode === 0)
+            return null;
+        if (claude.is_error && typeof claude.result === "string") {
+            const detail = matchingLine(claude.result);
+            if (detail)
+                return { detail };
+        }
+    }
+    const codexErrors = (0, exit_conditions_cjs_1.parseCodexJsonEvents)(result.stdout).flatMap((event) => {
+        const raw = event;
+        if (raw.type === "error" && typeof raw.message === "string")
+            return [raw.message];
+        if (raw.type === "turn.failed") {
+            const error = raw.error;
+            if (typeof error?.message === "string")
+                return [error.message];
+        }
+        return [];
+    });
+    if (result.exitCode === 0 && codexErrors.length === 0 && !claude?.is_error)
+        return null;
+    for (const message of codexErrors) {
+        const detail = matchingLine(message);
+        if (detail)
+            return { detail };
+    }
+    const detail = matchingLine(result.stderr);
+    return detail ? { detail } : null;
+}

package/dist/completion-retry.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPLETION_TRANSIENT_RETRY_DELAYS_MS = void 0;
+exports.isTransientCompletionError = isTransientCompletionError;
+exports.completeWithTransientRetry = completeWithTransientRetry;
+const api_cjs_1 = require("./api.cjs");
+/**
+ * Backoff before each re-send of a completion that failed in transit. About
+ * two minutes in total: long enough to ride out a Wi-Fi drop or an edge blip,
+ * short enough that the lease is still live when the report finally lands.
+ */
+exports.COMPLETION_TRANSIENT_RETRY_DELAYS_MS = [2_000, 5_000, 15_000, 30_000, 60_000];
+/** Statuses the edge or a gateway answers for an unreachable origin; the completion route never chose them. */
+const TRANSIENT_STATUSES = new Set([408, 429, 502, 503, 504, 520, 521, 522, 523, 524]);
+/**
+ * A failure that says nothing about the completion itself: the request never
+ * got an answer from the completion route. A plain 500 is the route's own
+ * answer and keeps the existing crash path.
+ */
+function isTransientCompletionError(err) {
+    return (err instanceof api_cjs_1.NavarchTransportError ||
+        (err instanceof api_cjs_1.NavarchApiError && TRANSIENT_STATUSES.has(err.status)));
+}
+/**
+ * Sends a lease completion, re-sending it while the control plane is
+ * unreachable. Without this, one dropped connection turned a finished session
+ * (pull request already open) into `Session crashed:`, which spent an
+ * infrastructure retry and discarded the report and evidence the review loop
+ * needed (carova#310). A re-send whose earlier copy did land gets the
+ * `already_released` 409, which callers already treat as success.
+ */
+async function completeWithTransientRetry(send, options = {}) {
+    const delays = options.delaysMs ?? exports.COMPLETION_TRANSIENT_RETRY_DELAYS_MS;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await send();
+            return;
+        }
+        catch (err) {
+            const delayMs = delays[attempt];
+            if (delayMs === undefined || !isTransientCompletionError(err))
+                throw err;
+            options.onRetry?.(attempt + 1, delayMs, err);
+            await sleep(delayMs);
+        }
+    }
+}

package/dist/exit-conditions.cjs

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_AUTH_FAILURE_PREFIX = void 0;
+exports.agentAuthFailureReport = agentAuthFailureReport;
 exports.parseClaudeJsonResult = parseClaudeJsonResult;
 exports.extractUsageFromClaudeJson = extractUsageFromClaudeJson;
 exports.parseCodexJsonEvents = parseCodexJsonEvents;
@@ -8,6 +10,19 @@ exports.extractFinalMessageFromCodexEvents = extractFinalMessageFromCodexEvents;
 exports.leadingVerificationVerdict = leadingVerificationVerdict;
 exports.leadWithReviewFixMarker = leadWithReviewFixMarker;
 exports.mapExitCondition = mapExitCondition;
+/**
+ * Leading text of every report for a turn the coding agent CLI refused because
+ * its own login on this machine is gone (agent-auth.cts). The control plane
+ * recognizes it -- and the raw CLI errors, for older runtimes -- and requeues
+ * the task without spending a retry while pausing this machine's claims until
+ * someone logs in again (lib/navarch/failure-attribution.ts
+ * `provider.agent_auth`).
+ */
+exports.AGENT_AUTH_FAILURE_PREFIX = "Coding agent authentication failed";
+function agentAuthFailureReport(detail) {
+    return `${exports.AGENT_AUTH_FAILURE_PREFIX}: ${detail} ` +
+        "Log the coding agent in again on this machine (`claude /login` or `codex login`), then resume the agent.";
+}
 /**
  * Best-effort parse of `claude -p --output-format json` stdout into the
  * assumed result shape above. Tries the whole trimmed stdout first (the
@@ -260,6 +275,14 @@ function mapExitCondition(result) {
             evidenceUrls,
         };
     }
+    if (result.authError) {
+        return {
+            leaseOutcome: "failed",
+            exitStatus: "failed",
+            reportSummary: summarize(agentAuthFailureReport(result.authError)),
+            evidenceUrls,
+        };
+    }
     if (result.timedOut) {
         return {
             leaseOutcome: "failed",

package/dist/session.cjs

@@ -25,7 +25,9 @@ const delivery_cjs_1 = require("./delivery.cjs");
 const worktree_guard_cjs_1 = require("./worktree-guard.cjs");
 const adapter_watchdog_cjs_1 = require("./adapter-watchdog.cjs");
 const lease_heartbeat_cjs_1 = require("./lease-heartbeat.cjs");
+const completion_retry_cjs_1 = require("./completion-retry.cjs");
 const adapter_capacity_cjs_1 = require("./adapter-capacity.cjs");
+const agent_auth_cjs_1 = require("./agent-auth.cjs");
 const browser_evidence_cjs_1 = require("./browser-evidence.cjs");
 /** Filename the generated platform MCP config is written under inside the session metadata directory. */
 const MCP_CONFIG_FILENAME = "mcp-config.json";
@@ -551,6 +553,15 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 await checkpointForRecovery(turnResult);
                 sessionOutcome.claimCooldownUntil = Math.max(sessionOutcome.claimCooldownUntil ?? 0, capacityLimit.retryAtMs);
             }
+            // A dead CLI login fails every task this machine claims in well under a
+            // second. Report it as such so the control plane requeues the task
+            // without spending a retry and pauses this machine until it is logged in
+            // again, instead of burning the task's budget into needs_human.
+            const authFailure = capacityLimit ? null : (0, agent_auth_cjs_1.detectAgentAuthFailure)(turnResult);
+            if (authFailure) {
+                turnResult.authError = authFailure.detail;
+                log.warn(`session ${leaseId}: coding agent authentication failed: ${authFailure.detail}`);
+            }
             // Close the small race between a naturally completed turn and the next
             // scheduled heartbeat. If guidance landed, run another turn before the
             // lease can be completed. A terminal heartbeat response means the
@@ -563,7 +574,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 log.warn(`session ${leaseId} stopped without completion because its lease is no longer active.`);
                 return sessionOutcome;
             }
-            if (!capacityLimit && !leaseLost && !turnResult.timedOut && pendingGuidance.length > 0)
+            if (!capacityLimit && !authFailure && !leaseLost && !turnResult.timedOut && pendingGuidance.length > 0)
                 continue;
             const result = {
                 ...turnResult,
@@ -720,7 +731,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 transcript_url: completion.transcript_url,
             };
             try {
-                await api.completeLease(leaseId, completion);
+                await (0, completion_retry_cjs_1.completeWithTransientRetry)(() => api.completeLease(leaseId, completion), {
+                    onRetry: (attempt, delayMs, err) => log.warn(`completion for ${leaseId} did not reach the control plane (${(0, redact_cjs_1.redactText)(String(err), knownSecrets)}); re-sending in ${delayMs / 1000}s (${attempt}).`),
+                });
                 if (deliveredPullRequest && completion.status === "completed" && gitWorktree.restoredHostedCheckpoint) {
                     // The pull request carries the hosted attempt's work now; a later
                     // hosted attempt must not resume the stale snapshot.
@@ -756,7 +769,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     log.error(`completion for ${leaseId} was rejected as ${rejection.code}, which is not remediable; failing the lease.`);
                 }
                 try {
-                    await api.completeLease(leaseId, {
+                    await (0, completion_retry_cjs_1.completeWithTransientRetry)(() => api.completeLease(leaseId, {
                         ...completion,
                         status: "failed",
                         report: remediable
@@ -764,7 +777,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                             : `${redactedRejection}\n\n---\n\n${completion.report}`,
                         failure_summary: redactedRejection,
                         exit_status: "failed",
-                    });
+                    }));
                 }
                 catch (fallbackErr) {
                     // Same race as the primary completion above: if something else released

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",