nexus-agents 2.120.1 → 2.120.3

package/dist/{chunk-LV26EF7E.js → chunk-4DUL5HKB.js}

@@ -26,7 +26,7 @@ import {
   writeJobComplete,
   writeJobFailed,
   writeJobPending
-} from "./chunk-KQYEBRLU.js";
+} from "./chunk-HCBALIWN.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
@@ -42,14 +42,16 @@ import {
 } from "./chunk-PN6BFDVL.js";
 import {
   withPrerequisite
-} from "./chunk-AEPFWQLE.js";
+} from "./chunk-S7JNS4NN.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
   abortSignalStorage,
+  coarsenFailureCategory,
   createDefaultRateLimiter,
   createMcpNotifier,
   createSecureHandler,
+  defaultRetryable,
   getMcpAnnotations,
   getToolAnnotations,
   getToolTimeout,
@@ -62,7 +64,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-2PQNHP5Y.js";
+} from "./chunk-FUZ2LMMD.js";
 import {
   generateSecurityPlan
 } from "./chunk-5CIKBB4B.js";
@@ -115,7 +117,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-NHCAY372.js";
+} from "./chunk-XOQEPBSL.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -185,6 +187,7 @@ import {
   WorkflowError,
   buildCapabilityProfiles,
   buildDefaultModelSources,
+  categorizeOutcomeError,
   categorizeOutcomeErrorMessage,
   clamp,
   clamp01,
@@ -26274,6 +26277,9 @@ async function runSinglePrecondition(config, ctx, options) {
 
 // src/orchestration/graph/graph-executor.ts
 var logger16 = createLogger({ component: "GraphExecutor" });
+function failureClassification(category) {
+  return { errorCategory: category, isRetryable: defaultRetryable(category) };
+}
 var DEFAULT_MAX_STEPS = GRAPH_TIMEOUTS.maxSteps;
 var DEFAULT_TIMEOUT_MS3 = GRAPH_TIMEOUTS.defaultMs;
 var GRAPH_UNIFIED_CONTEXT_KEY = "__unifiedContext";
@@ -26637,7 +26643,9 @@ async function executeWithVerification(args) {
       stateUpdates: {},
       durationMs: getTimeProvider().now() - startTime,
       status: "failed",
-      error: `Verification failed: ${verifyResult.error ?? "unknown"}`
+      error: `Verification failed: ${verifyResult.error ?? "unknown"}`,
+      // Post-step verification is a domain check — re-running won't change it.
+      ...failureClassification("business")
     };
   }
   return {
@@ -26649,6 +26657,11 @@ async function executeWithVerification(args) {
   };
 }
 async function executeSingleNode(graph, nodeId, state, nodeCtx, options) {
+  const prior = options?.priorResults?.get(nodeId);
+  if (prior?.status === "success") {
+    logger16.debug("Replaying prior successful node result", { nodeId });
+    return prior;
+  }
   const node = graph.nodes.get(nodeId);
   if (node === void 0) {
     return {
@@ -26656,7 +26669,9 @@ async function executeSingleNode(graph, nodeId, state, nodeCtx, options) {
       stateUpdates: {},
       durationMs: 0,
       status: "failed",
-      error: `Node '${nodeId}' not found`
+      error: `Node '${nodeId}' not found`,
+      // Missing node is a graph-construction bug, not a transient failure.
+      ...failureClassification("internal")
     };
   }
   const startTime = getTimeProvider().now();
@@ -26669,12 +26684,14 @@ async function executeSingleNode(graph, nodeId, state, nodeCtx, options) {
   } catch (error) {
     const message = getErrorMessage(error);
     logger16.warn("Node execution failed", { nodeId, error: message });
+    const category = coarsenFailureCategory(categorizeOutcomeError(error));
     return {
       nodeId,
       stateUpdates: {},
       durationMs: getTimeProvider().now() - startTime,
       status: "failed",
-      error: message
+      error: message,
+      ...failureClassification(category)
     };
   }
 }
@@ -27673,24 +27690,46 @@ var PipelineRunner = class {
     }
   }
   /**
-   * Retries a previous run that had failed or skipped steps by re-executing the
-   * pipeline with `continueOnFailure` enabled, returning the combined result.
-   * Returns `previousResult` unchanged when it has no `stepResults` or nothing
-   * failed/skipped.
+   * Retries a previous run's failures **selectively** (#3534): prior successful
+   * nodes are replayed (not re-executed) via `priorResults`, so only the failed
+   * nodes and their dependents run again.
    *
-   * NOTE: the underlying graph executor re-runs **all** nodes, not only the
-   * failed ones — selective per-step retry is not yet modeled. The failed/skipped
-   * ids are used only to decide *whether* to retry, not *which* steps run.
+   * Gated on retryability: retries only when at least one *failed* node is
+   * `isRetryable` (transient). If every failure is permanent
+   * (validation/permission/business/internal) it returns `previousResult`
+   * unchanged rather than looping on errors that won't clear.
+   *
+   * Back-compat: a `previousResult` without `nodeResults` (e.g. an older caller)
+   * falls back to the prior whole-pipeline retry gated on `stepResults`.
+   *
+   * NOTE: non-retryable failures that coexist with a retryable one still re-run
+   * (and re-fail) under `continueOnFailure`; pinning them as terminal is a
+   * future refinement.
    */
   async retryFailed(pipeline, previousResult, task, options) {
+    const nodeResults = previousResult.nodeResults;
+    if (nodeResults === void 0) {
+      return this.retryFailedLegacy(pipeline, previousResult, task, options);
+    }
+    const anyRetryableFailure = nodeResults.some(
+      (r) => r.status === "failed" && r.isRetryable === true
+    );
+    if (!anyRetryableFailure) {
+      return okResult(previousResult);
+    }
+    const priorResults = new Map(
+      nodeResults.filter((r) => r.status === "success").map((r) => [r.nodeId, r])
+    );
+    return this.execute(pipeline, task, { ...options, continueOnFailure: true, priorResults });
+  }
+  /** Pre-#3534 whole-pipeline retry, kept for results lacking `nodeResults`. */
+  async retryFailedLegacy(pipeline, previousResult, task, options) {
     const steps = previousResult.stepResults;
     if (steps === void 0 || steps.length === 0) {
       return okResult(previousResult);
     }
-    const failedIds = new Set(
-      steps.filter((s) => s.status === "failed" || s.status === "skipped").map((s) => s.stepId)
-    );
-    if (failedIds.size === 0) {
+    const anyFailed = steps.some((s) => s.status === "failed" || s.status === "skipped");
+    if (!anyFailed) {
       return okResult(previousResult);
     }
     return this.execute(pipeline, task, { ...options, continueOnFailure: true });
@@ -27702,23 +27741,31 @@ function okResult(value) {
 function failedResult(startTime, error) {
   return { success: false, stepsExecuted: 0, durationMs: Date.now() - startTime, error };
 }
-function buildGraphOptions(pipeline, options) {
-  const base = {
-    timeout: options?.timeout ?? pipeline.plan.timeoutMs
+function makeOnNodeComplete(onStage, bus, execId) {
+  return (r) => {
+    onStage?.(r.nodeId);
+    emitStageEvent(bus, execId, r);
   };
+}
+function optionalGraphFields(options) {
   const signal = options?.signal;
   const maxSteps = options?.maxSteps;
-  const onStage = options?.onStageComplete;
-  const bus = options?.eventBus;
-  const execId = pipeline.plan.taskId;
+  const priorResults = options?.priorResults;
   return {
-    ...base,
     ...signal !== void 0 ? { signal } : {},
     ...maxSteps !== void 0 ? { maxSteps } : {},
-    onNodeComplete: (r) => {
-      onStage?.(r.nodeId);
-      emitStageEvent(bus, execId, r);
-    }
+    ...priorResults !== void 0 ? { priorResults } : {}
+  };
+}
+function buildGraphOptions(pipeline, options) {
+  return {
+    timeout: options?.timeout ?? pipeline.plan.timeoutMs,
+    ...optionalGraphFields(options),
+    onNodeComplete: makeOnNodeComplete(
+      options?.onStageComplete,
+      options?.eventBus,
+      pipeline.plan.taskId
+    )
   };
 }
 function toResult(graphResult, startTime, continueOnFailure) {
@@ -27736,7 +27783,8 @@ function toResult(graphResult, startTime, continueOnFailure) {
       success: false,
       stepsExecuted: graphResult.stepsExecuted,
       durationMs,
-      error: failedNode?.error ?? "Stage execution failed"
+      error: failedNode?.error ?? "Stage execution failed",
+      nodeResults: graphResult.nodeResults
     };
   }
   const succeeded = stepResults.filter((s) => s.status === "succeeded").length;
@@ -27746,6 +27794,7 @@ function toResult(graphResult, startTime, continueOnFailure) {
     success: allOk,
     stepsExecuted: graphResult.stepsExecuted,
     durationMs,
+    nodeResults: graphResult.nodeResults,
     ...continueOnFailure ? { stepResults } : {},
     ...!allOk && continueOnFailure ? { error: `${String(succeeded)}/${String(total)} steps succeeded` } : {}
   };
@@ -36532,19 +36581,24 @@ async function discoverFromExtendedSource(source, topic, maxResults, logger56, s
   return { items: toDiscoveredItems(result.value), failed: false };
 }
 function computeRelevanceScore(item, topic) {
-  const keywords = topic.toLowerCase().split(/[\s,;+\-/]+/).filter((w) => w.length >= 3);
+  const keywords = [
+    ...new Set(
+      topic.toLowerCase().split(/[\s,;+\-/]+/).filter((w) => w.length >= 3)
+    )
+  ];
   if (keywords.length === 0) return 1;
   const titleLower = item.title.toLowerCase();
   const descLower = item.description.toLowerCase();
-  let titleMatches = 0;
-  let descMatches = 0;
+  let matched = 0;
+  let titleHits = 0;
   for (const keyword of keywords) {
-    if (titleLower.includes(keyword)) titleMatches++;
-    if (descLower.includes(keyword)) descMatches++;
+    const inTitle = titleLower.includes(keyword);
+    if (inTitle || descLower.includes(keyword)) matched++;
+    if (inTitle) titleHits++;
   }
-  const weightedMatches = titleMatches * 2 + descMatches;
-  const maxPossible = keywords.length * 3;
-  return Math.min(1, weightedMatches / maxPossible);
+  const coverage = matched / keywords.length;
+  const titleFraction = titleHits / keywords.length;
+  return Math.min(1, coverage * 0.8 + titleFraction * 0.2);
 }
 function filterByRelevance2(items, topic, threshold) {
   const scored = items.map((item) => ({
@@ -42065,7 +42119,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-YM4BVTDO.js");
+        const { executeVoting } = await import("./consensus-vote-ALLKZH6O.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -49080,4 +49134,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-LV26EF7E.js.map
+//# sourceMappingURL=chunk-4DUL5HKB.js.map