nexus-agents 2.173.3 → 2.173.4

package/dist/{chunk-QZLISECU.js → chunk-CGIT3MVV.js}

@@ -8,7 +8,7 @@ import {
   checkSqlite,
   defaultConfig,
   initDataDirectories
-} from "./chunk-WJHTVYP6.js";
+} from "./chunk-YYCG236I.js";
 import {
   BUILT_IN_EXPERTS
 } from "./chunk-ZM4O442V.js";
@@ -2001,4 +2001,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-QZLISECU.js.map
+//# sourceMappingURL=chunk-CGIT3MVV.js.map

package/dist/{chunk-GNZ2ZIT3.js → chunk-R4ZINS62.js}

@@ -21,7 +21,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-WJHTVYP6.js";
+} from "./chunk-YYCG236I.js";
 import {
   executeExpert
 } from "./chunk-MBTEWGZK.js";
@@ -12438,29 +12438,33 @@ function highestConfidenceFailure(failures) {
   }, void 0);
 }
 function classifyExpertFailure(error, detector, taskDescription, signal) {
-  if (signal?.aborted === true) {
-    return { kind: "permanent", source: "default" };
-  }
-  if (isRetryableErrorChain(error)) {
-    return { kind: "transient", source: "transport" };
-  }
-  const detection = detector.detect({
-    messages: [{ role: "assistant", content: extractErrorMessage(error) }],
-    ...taskDescription !== void 0 ? { taskDescription } : {}
-  });
-  if (detection.hasFailure) {
-    const top = highestConfidenceFailure(detection.failures);
-    if (top !== void 0) {
-      const action = DEFAULT_RECOVERY_STRATEGIES[top.archetype].action;
-      return {
-        kind: RECOVERABLE_ACTIONS.has(action) ? "transient" : "permanent",
-        source: "archetype",
-        archetype: top.archetype,
-        confidence: top.confidence
-      };
+  try {
+    if (signal?.aborted === true) {
+      return { kind: "permanent", source: "default" };
+    }
+    if (isRetryableErrorChain(error)) {
+      return { kind: "transient", source: "transport" };
+    }
+    const detection = detector.detect({
+      messages: [{ role: "assistant", content: extractErrorMessage(error) }],
+      ...taskDescription !== void 0 ? { taskDescription } : {}
+    });
+    if (detection.hasFailure) {
+      const top = highestConfidenceFailure(detection.failures);
+      if (top !== void 0) {
+        const action = DEFAULT_RECOVERY_STRATEGIES[top.archetype].action;
+        return {
+          kind: RECOVERABLE_ACTIONS.has(action) ? "transient" : "permanent",
+          source: "archetype",
+          archetype: top.archetype,
+          confidence: top.confidence
+        };
+      }
     }
+    return { kind: "permanent", source: "default" };
+  } catch {
+    return { kind: "permanent", source: "default" };
   }
-  return { kind: "permanent", source: "default" };
 }
 function mergeRecoveryConfig(policy) {
   return {
@@ -12533,27 +12537,47 @@ var RecoverableExpert = class extends Expert {
           return lastClassification.kind === "transient";
         },
         onRetry: (info) => {
-          this.recoveryLogger.info("Expert execution retry", {
-            expertId: this.expertConfig.id,
-            attempt: info.attempt,
-            delayMs: info.delayMs,
-            classification: lastClassification?.kind,
-            source: lastClassification?.source,
-            archetype: lastClassification?.archetype
-          });
-          if (lastClassification?.source === "archetype" && lastClassification.archetype !== void 0) {
-            currentTask = this.injectRecoveryGuidance(
-              currentTask,
-              lastClassification.archetype,
-              info
-            );
-          }
+          currentTask = this.handleRetry(info, lastClassification, currentTask);
         }
       }
     );
     if (outcome.ok) return ok(outcome.value);
     return err(this.annotateExhausted(outcome.error, currentTask, signal));
   }
+  /**
+   * Per-retry callback: logs the attempt and, for a recoverable archetype,
+   * injects archetype-specific guidance into the next attempt's task.
+   *
+   * Returns the (possibly augmented) task. onRetry runs INSIDE withRetry's catch
+   * but is NOT itself try-guarded (adapters/retry.ts:352-359 — the try wraps only
+   * `operation()`), so a throw here would escape withRetry and reject the Promise.
+   * The guidance path re-reads the error (extractErrorMessage) and calls
+   * detector.detect, so a pathological error (#4303 throwing getter) could throw —
+   * guard it: on failure, skip injection and retry with the un-augmented task.
+   */
+  handleRetry(info, classification, currentTask) {
+    this.recoveryLogger.info("Expert execution retry", {
+      expertId: this.expertConfig.id,
+      attempt: info.attempt,
+      delayMs: info.delayMs,
+      classification: classification?.kind,
+      source: classification?.source,
+      archetype: classification?.archetype
+    });
+    if (classification?.source !== "archetype" || classification.archetype === void 0) {
+      return currentTask;
+    }
+    try {
+      return this.injectRecoveryGuidance(currentTask, classification.archetype, info);
+    } catch (guidanceError) {
+      this.recoveryLogger.warn("Skipping recovery guidance injection (threw)", {
+        expertId: this.expertConfig.id,
+        archetype: classification.archetype,
+        error: getErrorMessage(guidanceError)
+      });
+      return currentTask;
+    }
+  }
   /**
    * Builds the annotated failure returned when recovery is exhausted. withRetry
    * skips isRetryable on the final attempt, so the per-attempt `lastClassification`
@@ -54021,4 +54045,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-GNZ2ZIT3.js.map
+//# sourceMappingURL=chunk-R4ZINS62.js.map