nexus-agents 2.46.0 → 2.47.0

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

@@ -24,7 +24,7 @@ import {
 } from "./chunk-CLYZ7FWP.js";
 
 // src/version.ts
-var VERSION = true ? "2.46.0" : "dev";
+var VERSION = true ? "2.47.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-CRBMRREJ.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -836,4 +836,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-5Y7QBD2H.js.map
+//# sourceMappingURL=chunk-3YYS74BL.js.map

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

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

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

@@ -66,7 +66,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-5Y7QBD2H.js";
+} from "./chunk-3YYS74BL.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
@@ -54144,4 +54260,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-GVK2Z7PV.js.map
+//# sourceMappingURL=chunk-ZGKZIEUM.js.map