nexus-agents 2.173.3 → 2.173.5

package/dist/{chunk-GNZ2ZIT3.js → chunk-6YM52YW6.js}

@@ -21,7 +21,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-WJHTVYP6.js";
+} from "./chunk-7GIRIDHH.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`
@@ -46510,11 +46534,15 @@ function buildPrReviewRecord(input) {
   };
   return { ...payload, hash: computePrReviewRecordHash(payload) };
 }
-function resolvePrReviewRecordsPath() {
+function resolvePrReviewRecordsPath(repoPathOverride) {
   const envPath = process.env[PR_REVIEW_RECORDS_PATH_ENV];
   if (envPath !== void 0 && envPath.trim() !== "") {
     return isAbsolute(envPath) ? envPath : resolve13(envPath);
   }
+  if (repoPathOverride !== void 0 && repoPathOverride.trim() !== "") {
+    const overrideRoot = findRepoRoot(repoPathOverride);
+    if (overrideRoot !== null) return join9(overrideRoot, PR_REVIEW_RECORDS_REL_PATH);
+  }
   const root = findRepoRoot(process.cwd());
   if (root === null) return void 0;
   return join9(root, PR_REVIEW_RECORDS_REL_PATH);
@@ -46553,7 +46581,7 @@ function readPrReviewLedgerTip(filePath, logger58) {
 }
 function persistPrReviewRecord(opts) {
   const logger58 = opts.logger ?? createLogger({ component: "pr-review-record-store" });
-  const filePath = opts.filePath ?? resolvePrReviewRecordsPath();
+  const filePath = opts.filePath ?? resolvePrReviewRecordsPath(opts.repoPathOverride);
   if (filePath === void 0) {
     logger58.warn("Cannot persist pr-review record: no records path resolved", {
       prNumber: opts.prNumber
@@ -46610,6 +46638,9 @@ function buildAndPersist(prNumber, baseSha, args) {
       total: reviewCount
     },
     summary: `${aggregate.decision} (${String(counts.approveCount)} approve / ${String(counts.requestChangesCount)} request_changes / ${String(counts.abstainCount)} abstain) \u2014 ${input.prTitle}${coverageSuffix}`,
+    // #4278: lets a caller (e.g. an MCP server whose cwd has no `.git`
+    // ancestor) say where the repo is, so the record isn't silently dropped.
+    ...input.repoPath !== void 0 ? { repoPathOverride: input.repoPath } : {},
     logger: logger58
   });
   if (record === void 0) {
@@ -46791,6 +46822,45 @@ function applyPartialCoverageGate(aggregate, coverage) {
   return aggregate;
 }
 
+// src/mcp/tools/pr-review-result-mapping.ts
+function resolveFindings(result) {
+  const raw = result.vote.findings;
+  if (raw !== void 0 && raw.length > 0) {
+    return raw.map((f) => ({
+      summary: f.summary,
+      location: f.location,
+      severity: f.severity,
+      gate: f.gate,
+      claim: f.claim,
+      verified: isFindingVerified(f.gate)
+    }));
+  }
+  return parseFindings(result.vote.reasoning);
+}
+function toPrReviewVote(result) {
+  return {
+    role: result.role,
+    decision: mapVoteDecisionToPrDecision(result.vote.decision),
+    confidence: result.vote.confidence,
+    reasoning: result.vote.reasoning,
+    findings: resolveFindings(result),
+    source: result.source,
+    cli: result.cli,
+    processingTimeMs: result.processingTimeMs,
+    ...result.error !== void 0 && { errorMessage: result.error }
+  };
+}
+function summarizeReviews(reviews) {
+  return {
+    approveCount: reviews.filter((r) => r.source !== "error" && r.decision === "approve").length,
+    requestChangesCount: reviews.filter(
+      (r) => r.source !== "error" && r.decision === "request_changes"
+    ).length,
+    abstainCount: reviews.filter((r) => r.source !== "error" && r.decision === "abstain").length,
+    errorCount: reviews.filter((r) => r.source === "error").length
+  };
+}
+
 // src/mcp/tools/pr-review-tool.ts
 var PR_REVIEW_ROLES = [
   "architect",
@@ -46830,6 +46900,9 @@ var PrReviewInputSchema = z93.object({
   baseSha: z93.string().regex(/^[0-9a-f]{40}$/, "baseSha must be a 40-char lowercase hex commit sha").optional().describe(
     "40-hex base commit sha the reviewed diff was computed from (Option-C binding, #4031)"
   ),
+  repoPath: z93.string().max(1024).optional().describe(
+    "Repo root path for persisting the governance pr-review record (overrides cwd auto-detection). Must contain a .git ancestor \u2014 relative paths are resolved against cwd; ignored (falls back to cwd auto-detection) if it is not a real repo root. Env NEXUS_PR_REVIEW_RECORDS_PATH still takes precedence and is unrestricted."
+  ),
   simulate: z93.boolean().default(false).describe("Use simulated voters (testing only; never ship live with this true)"),
   /**
    * Error policy (#4132). `standard` (default) keeps the pre-#4132 aggregation:
@@ -46945,43 +47018,6 @@ ${FINDINGS_FORMAT_INSTRUCTIONS}
 `);
   return parts.join("");
 }
-function resolveFindings(result) {
-  const raw = result.vote.findings;
-  if (raw !== void 0 && raw.length > 0) {
-    return raw.map((f) => ({
-      summary: f.summary,
-      location: f.location,
-      severity: f.severity,
-      gate: f.gate,
-      claim: f.claim,
-      verified: isFindingVerified(f.gate)
-    }));
-  }
-  return parseFindings(result.vote.reasoning);
-}
-function toPrReviewVote(result) {
-  return {
-    role: result.role,
-    decision: mapVoteDecisionToPrDecision(result.vote.decision),
-    confidence: result.vote.confidence,
-    reasoning: result.vote.reasoning,
-    findings: resolveFindings(result),
-    source: result.source,
-    cli: result.cli,
-    processingTimeMs: result.processingTimeMs,
-    ...result.error !== void 0 && { errorMessage: result.error }
-  };
-}
-function summarizeReviews(reviews) {
-  return {
-    approveCount: reviews.filter((r) => r.source !== "error" && r.decision === "approve").length,
-    requestChangesCount: reviews.filter(
-      (r) => r.source !== "error" && r.decision === "request_changes"
-    ).length,
-    abstainCount: reviews.filter((r) => r.source !== "error" && r.decision === "abstain").length,
-    errorCount: reviews.filter((r) => r.source === "error").length
-  };
-}
 function resolveAggregate(reviews, input, errorCount, coverage, logger58) {
   const preGate = aggregatePrDecisions(reviews, input.errorPolicy);
   if (preGate.reason !== void 0) {
@@ -54021,4 +54057,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-GNZ2ZIT3.js.map
+//# sourceMappingURL=chunk-6YM52YW6.js.map