nexus-agents 2.46.0 → 2.48.0

package/dist/{chunk-KCOGC24K.js → chunk-CH722DBX.js}

@@ -4,7 +4,7 @@ import {
 import {
   VERSION,
   initDataDirectories
-} from "./chunk-5Y7QBD2H.js";
+} from "./chunk-M53BBBCB.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
   createLogger,
@@ -1580,4 +1580,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-KCOGC24K.js.map
+//# sourceMappingURL=chunk-CH722DBX.js.map

package/dist/{chunk-5Y7QBD2H.js → chunk-M53BBBCB.js}

@@ -24,7 +24,7 @@ import {
 } from "./chunk-CLYZ7FWP.js";
 
 // src/version.ts
-var VERSION = true ? "2.46.0" : "dev";
+var VERSION = true ? "2.48.0" : "dev";
 
 // src/cli/setup-data-dir.ts
 import { mkdirSync, existsSync as existsSync2 } from "fs";
@@ -758,7 +758,7 @@ async function runDoctorFix(result) {
   writeLine2("\u2500".repeat(40));
   let fixCount = 0;
   if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists || !d.writable)) {
-    const { runSetup } = await import("./setup-command-OF4QXTBF.js");
+    const { runSetup } = await import("./setup-command-PLGFVKLM.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -836,4 +836,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-5Y7QBD2H.js.map
+//# sourceMappingURL=chunk-M53BBBCB.js.map

package/dist/{chunk-GVK2Z7PV.js → chunk-UXRR7M6E.js}

@@ -66,7 +66,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-5Y7QBD2H.js";
+} from "./chunk-M53BBBCB.js";
 import {
   createSessionMemory
 } from "./chunk-ULDKSIS7.js";
@@ -31387,6 +31387,109 @@ function planAgentTeam(analysis, taskDescription, options) {
   };
 }
 
+// src/orchestration/aorchestra/topological-wave.ts
+var CycleError = class extends Error {
+  constructor(message, cycleRoles) {
+    super(message);
+    this.cycleRoles = cycleRoles;
+  }
+  name = "CycleError";
+};
+var MissingDependencyError = class extends Error {
+  constructor(message, sourceRole, missingRole) {
+    super(message);
+    this.sourceRole = sourceRole;
+    this.missingRole = missingRole;
+  }
+  name = "MissingDependencyError";
+};
+function topologicalWaveAssign(entries) {
+  if (entries.length === 0) return ok([]);
+  const byRole = buildRoleIndex(entries);
+  const missing = findMissingDependency(entries, byRole);
+  if (missing !== null) return err(missing);
+  const cycle = detectCycle(entries, byRole);
+  if (cycle !== null) return err(cycle);
+  const waveByRole = computeWaves(entries, byRole);
+  return ok(entries.map((e) => ({ ...e, wave: waveByRole.get(e.role) ?? e.wave })));
+}
+function buildRoleIndex(entries) {
+  const byRole = /* @__PURE__ */ new Map();
+  for (const e of entries) byRole.set(e.role, e);
+  return byRole;
+}
+function findMissingDependency(entries, byRole) {
+  for (const e of entries) {
+    if (e.dependsOn === void 0) continue;
+    for (const dep of e.dependsOn) {
+      if (!byRole.has(dep)) {
+        return new MissingDependencyError(
+          `Entry for role "${e.role}" depends on unknown role "${dep}"`,
+          e.role,
+          dep
+        );
+      }
+    }
+  }
+  return null;
+}
+function detectCycle(entries, byRole) {
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  for (const e of entries) color.set(e.role, WHITE);
+  function visit(role, stack) {
+    const c = color.get(role);
+    if (c === BLACK) return null;
+    if (c === GRAY) {
+      const cycleStart = stack.indexOf(role);
+      return cycleStart >= 0 ? stack.slice(cycleStart).concat(role) : [role];
+    }
+    color.set(role, GRAY);
+    stack.push(role);
+    const entry = byRole.get(role);
+    if (entry?.dependsOn !== void 0) {
+      for (const dep of entry.dependsOn) {
+        const found = visit(dep, stack);
+        if (found !== null) return found;
+      }
+    }
+    stack.pop();
+    color.set(role, BLACK);
+    return null;
+  }
+  for (const e of entries) {
+    const found = visit(e.role, []);
+    if (found !== null) {
+      return new CycleError(`Dependency cycle detected: ${found.join(" \u2192 ")}`, found);
+    }
+  }
+  return null;
+}
+function computeWaves(entries, byRole) {
+  const computed = /* @__PURE__ */ new Map();
+  function waveOf(role) {
+    const cached = computed.get(role);
+    if (cached !== void 0) return cached;
+    const entry = byRole.get(role);
+    if (entry === void 0) return 1;
+    if (entry.dependsOn === void 0 || entry.dependsOn.length === 0) {
+      computed.set(role, entry.wave);
+      return entry.wave;
+    }
+    let maxDepWave = 0;
+    for (const dep of entry.dependsOn) {
+      maxDepWave = Math.max(maxDepWave, waveOf(dep));
+    }
+    const newWave = maxDepWave + 1;
+    computed.set(role, newWave);
+    return newWave;
+  }
+  for (const e of entries) waveOf(e.role);
+  return computed;
+}
+
 // src/orchestration/aorchestra/watchdog.ts
 var logger22 = createLogger({ component: "worker-watchdog" });
 var WATCHDOG_THRESHOLDS = {
@@ -31629,6 +31732,18 @@ var CONSECUTIVE_FAILURE_THRESHOLD = 3;
 var RECOVERY_COOLDOWN_MS = 3e4;
 var MAX_COOLDOWN_MS = 3e5;
 var RATE_LIMIT_SPACING_MS = 2e3;
+function applyDependencyWaves(entries) {
+  const hasDeps = entries.some((e) => e.dependsOn !== void 0 && e.dependsOn.length > 0);
+  if (!hasDeps) return entries;
+  const result = topologicalWaveAssign(entries);
+  if (!result.ok) {
+    logger24.warn("Topological wave assignment failed, falling back to priority-only", {
+      error: result.error.message
+    });
+    return entries;
+  }
+  return result.value;
+}
 function groupByWave(entries) {
   if (entries.length === 0) return [];
   const waveMap = /* @__PURE__ */ new Map();
@@ -31765,7 +31880,8 @@ async function executeWithConcurrencyLimit(tasks, limit) {
 async function dispatchWorkers(entries, options) {
   if (entries.length === 0) return [];
   const maxConcurrency = options.maxConcurrency ?? MAX_WORKERS_PER_WAVE;
-  const waves = groupByWave(entries);
+  const effectiveEntries = applyDependencyWaves(entries);
+  const waves = groupByWave(effectiveEntries);
   const allResults = [];
   const failureTracker = new RoleFailureTracker(
     options.consecutiveFailureThreshold ?? CONSECUTIVE_FAILURE_THRESHOLD
@@ -49338,6 +49454,124 @@ function buildSuccessResult(instance2, patch, modelName, startTime, state) {
   };
 }
 
+// src/swe-bench/verify-loop.ts
+var DEFAULT_MAX_VERIFY_RETRIES = 2;
+var FAILURE_PATTERNS = [
+  {
+    category: "patch_not_applicable",
+    regex: /patch .*?does not apply|hunk #\d+ FAILED|Reversed .*patch detected/i,
+    summarizer: (m) => `Patch did not apply cleanly: ${m[0]}`
+  },
+  {
+    category: "syntax_error",
+    regex: /SyntaxError: (.*?)(?:\n|$)|IndentationError: (.*?)(?:\n|$)/,
+    summarizer: (m) => `Syntax error in generated patch: ${m[1] ?? m[2] ?? m[0]}`.trim()
+  },
+  {
+    category: "timeout",
+    regex: /Timeout\b|timed out after \d+\s?s\b|TIMEOUT_EXCEEDED/i,
+    summarizer: (m) => `Test run exceeded timeout: ${m[0]}`
+  },
+  {
+    category: "missing_dependency",
+    regex: /ModuleNotFoundError: No module named '([^']+)'|ImportError: cannot import name '([^']+)'|No module named "([^"]+)"/,
+    summarizer: (m) => `Missing dependency: ${m[1] ?? m[2] ?? m[3] ?? "unknown"}. Patch may need an import.`
+  },
+  {
+    category: "runtime_error",
+    regex: /([A-Z][a-zA-Z]+Error): (.*?)(?:\n|$)/,
+    summarizer: (m) => `Runtime error ${m[1] ?? ""}: ${m[2] ?? ""}`.trim()
+  },
+  {
+    category: "test_failure",
+    regex: /FAILED .*?::(\S+)|AssertionError|FAIL: (\S+)/,
+    summarizer: (_m, stderr, stdout) => {
+      const failed = extractFailedTests(stderr, stdout);
+      return failed.length > 0 ? `Tests still failing: ${failed.slice(0, 5).join(", ")}` : "One or more tests failed after patch";
+    }
+  }
+];
+function classifyPatchFailure(stderr, stdout) {
+  const haystack = `${stderr}
+${stdout}`;
+  for (const pattern of FAILURE_PATTERNS) {
+    const match = pattern.regex.exec(haystack);
+    if (match !== null) {
+      return {
+        category: pattern.category,
+        summary: pattern.summarizer(match, stderr, stdout),
+        affectedTests: extractFailedTests(stderr, stdout)
+      };
+    }
+  }
+  return {
+    category: "unknown",
+    summary: haystack.trim().slice(0, 200) || "No failure details captured",
+    affectedTests: extractFailedTests(stderr, stdout)
+  };
+}
+function extractFailedTests(stderr, stdout) {
+  const combined = `${stderr}
+${stdout}`;
+  const results = /* @__PURE__ */ new Set();
+  const pytestPattern = /FAILED (\S+::\S+)/g;
+  let match;
+  while ((match = pytestPattern.exec(combined)) !== null) {
+    if (match[1] !== void 0) results.add(match[1]);
+  }
+  const unittestPattern = /FAIL: (\S+) \(/g;
+  while ((match = unittestPattern.exec(combined)) !== null) {
+    if (match[1] !== void 0) results.add(match[1]);
+  }
+  return Array.from(results);
+}
+var ALWAYS_RETRYABLE = /* @__PURE__ */ new Set([
+  "patch_not_applicable",
+  "syntax_error",
+  "missing_dependency",
+  "test_failure",
+  "runtime_error",
+  "incomplete_fix"
+]);
+var NEVER_RETRYABLE = /* @__PURE__ */ new Set(["timeout"]);
+function shouldRetry(category, iteration, maxRetries = DEFAULT_MAX_VERIFY_RETRIES) {
+  if (iteration >= maxRetries) return false;
+  if (NEVER_RETRYABLE.has(category)) return false;
+  if (ALWAYS_RETRYABLE.has(category)) return true;
+  return iteration < 1;
+}
+function buildRetryHint(classification, iteration, maxRetries = DEFAULT_MAX_VERIFY_RETRIES) {
+  const header = `Verification attempt ${String(iteration + 1)}/${String(maxRetries + 1)} failed.`;
+  const bodyLines = [
+    header,
+    `Category: ${classification.category}`,
+    `Summary: ${classification.summary}`
+  ];
+  if (classification.affectedTests.length > 0) {
+    const count = String(classification.affectedTests.length);
+    const names = classification.affectedTests.slice(0, 5).join(", ");
+    const overflow = classification.affectedTests.length > 5 ? ", ..." : "";
+    bodyLines.push(`Affected tests (${count}): ${names}${overflow}`);
+  }
+  bodyLines.push("Fix the root cause, not the symptom. Re-emit the full patch.");
+  return bodyLines.join("\n");
+}
+function buildVerifyOutcome(params) {
+  const maxRetries = params.maxRetries ?? DEFAULT_MAX_VERIFY_RETRIES;
+  if (params.passed) {
+    return { ok: true, iteration: params.iteration, willRetry: false };
+  }
+  const classification = classifyPatchFailure(params.stderr, params.stdout);
+  const willRetry = shouldRetry(classification.category, params.iteration, maxRetries);
+  return {
+    ok: false,
+    iteration: params.iteration,
+    classification,
+    retryHint: buildRetryHint(classification, params.iteration, maxRetries),
+    willRetry
+  };
+}
+
 // src/swe-bench/agent-runner.ts
 async function runIteration(opts) {
   const { executor, context, previousError, previousPatch, systemPromptOverride, contextSummary } = opts;
@@ -49442,7 +49676,10 @@ async function runAgentOnInstance(instance2, options) {
     startTime,
     onMessage,
     systemPrompt: options.systemPrompt,
-    iterationContext: createEmptyContext()
+    iterationContext: createEmptyContext(),
+    verifyAttempts: 0,
+    ...options.verifyAdapter !== void 0 ? { verifyAdapter: options.verifyAdapter } : {},
+    ...options.maxVerifyRetries !== void 0 ? { maxVerifyRetries: options.maxVerifyRetries } : {}
   };
   const result = await runIterationLoop(executor, context, state, loopOptions);
   return { ok: true, value: result };
@@ -49493,6 +49730,54 @@ function buildDuplicateResult(instanceId, startTime, state, onMessage) {
   onMessage?.("Duplicate patch detected, terminating early");
   return buildFailedResult(instanceId, "Duplicate patch \u2014 agent is stuck", startTime, state);
 }
+async function invokeVerifyAdapter(adapter, patch, context, options) {
+  const { passed, stderr, stdout } = await adapter.verify(context.instance, patch, context.workDir);
+  return buildVerifyOutcome({
+    passed,
+    iteration: options.verifyAttempts - 1,
+    stderr,
+    stdout,
+    ...options.maxVerifyRetries !== void 0 ? { maxRetries: options.maxVerifyRetries } : {}
+  });
+}
+function applyVerifyRetry(outcome, state, onMessage) {
+  const category = outcome.classification?.category ?? "unknown";
+  onMessage?.(`Verify failed (${category}); retrying with hint`);
+  state.lastError = outcome.retryHint ?? "Verification failed; re-emit the patch";
+  state.lastPatch = state.finalPatch;
+  state.finalPatch = void 0;
+}
+async function runPostPatchVerify(context, state, options) {
+  const adapter = options.verifyAdapter;
+  if (adapter === void 0 || state.finalPatch === void 0) return true;
+  options.verifyAttempts += 1;
+  options.onMessage?.(`Verifying patch (attempt ${String(options.verifyAttempts)})`);
+  const outcome = await invokeVerifyAdapter(adapter, state.finalPatch, context, options);
+  if (outcome.ok) return true;
+  if (!outcome.willRetry) {
+    const category = outcome.classification?.category ?? "unknown";
+    options.onMessage?.(`Verify failed (${category}); no more retries`);
+    return true;
+  }
+  applyVerifyRetry(outcome, state, options.onMessage);
+  return false;
+}
+async function handleIterationDone(context, state, options, seenPatches) {
+  if (isDuplicatePatch(state.finalPatch, seenPatches)) {
+    state.finalPatch = void 0;
+    return {
+      result: buildDuplicateResult(
+        context.instance.instance_id,
+        options.startTime,
+        state,
+        options.onMessage
+      )
+    };
+  }
+  options.onMessage?.("Patch applies successfully");
+  const verifyOk = await runPostPatchVerify(context, state, options);
+  return verifyOk ? "break" : "continue";
+}
 async function runIterationLoop(executor, context, state, options) {
   const { config, startTime, onMessage } = options;
   const seenPatches = /* @__PURE__ */ new Set();
@@ -49503,12 +49788,10 @@ async function runIterationLoop(executor, context, state, options) {
     onMessage?.(`Iteration ${state.iterations.toString()}/${config.max_iterations.toString()}`);
     const done = await executeOneIteration(executor, context, state, options);
     if (done) {
-      if (isDuplicatePatch(state.finalPatch, seenPatches)) {
-        state.finalPatch = void 0;
-        return buildDuplicateResult(context.instance.instance_id, startTime, state, onMessage);
-      }
-      onMessage?.("Patch applies successfully");
-      break;
+      const control = await handleIterationDone(context, state, options, seenPatches);
+      if (control === "break") break;
+      if (control === "continue") continue;
+      return control.result;
     }
     if (isDuplicatePatch(state.lastPatch, seenPatches)) {
       return buildDuplicateResult(context.instance.instance_id, startTime, state, onMessage);
@@ -54144,4 +54427,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-GVK2Z7PV.js.map
+//# sourceMappingURL=chunk-UXRR7M6E.js.map