nexus-agents 2.47.0 → 2.48.0

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

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

package/dist/{chunk-3YYS74BL.js → chunk-M53BBBCB.js}

@@ -24,7 +24,7 @@ import {
 } from "./chunk-CLYZ7FWP.js";
 
 // src/version.ts
-var VERSION = true ? "2.47.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-CRBMRREJ.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-3YYS74BL.js.map
+//# sourceMappingURL=chunk-M53BBBCB.js.map

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

@@ -66,7 +66,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-3YYS74BL.js";
+} from "./chunk-M53BBBCB.js";
 import {
   createSessionMemory
 } from "./chunk-ULDKSIS7.js";
@@ -49454,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;
@@ -49558,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 };
@@ -49609,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();
@@ -49619,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);
@@ -54260,4 +54427,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-ZGKZIEUM.js.map
+//# sourceMappingURL=chunk-UXRR7M6E.js.map