nexus-agents 2.28.0 → 2.29.1

package/dist/{chunk-LKSTILEE.js → chunk-4AGPR6XZ.js}

@@ -1,5 +1,8 @@
 import {
-  BACKOFF_CONFIG,
+  CliCircuitBreaker,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG
+} from "./chunk-LLGUX44Z.js";
+import {
   CLI_SUBPROCESS_TIMEOUTS,
   CLI_TIMEOUTS,
   CLI_VERSION_REQUIREMENTS,
@@ -7,14 +10,8 @@ import {
   DEFAULT_CAPABILITIES,
   DEFAULT_MODEL_CAPABILITIES,
   DEFAULT_MODEL_PER_CLI,
-  ErrorCode,
-  LEARNING_DIR,
-  NexusError,
-  OUTCOMES_FILE,
-  RULES_FILE,
   buildModelInfo,
   clampPercent,
-  colors,
   createLogger,
   detectTaskCategory,
   err,
@@ -25,36 +22,17 @@ import {
   getOutcomeStore,
   getRandomProvider,
   getTimeProvider,
-  isPersistenceEnabled,
-  ok,
-  symbols,
-  writeLine
-} from "./chunk-L2SHSW4T.js";
+  isRateLimitText,
+  ok
+} from "./chunk-ELIFTCYM.js";
 
-// src/version.ts
-var VERSION = true ? "2.28.0" : "dev";
+// src/cli-adapters/subprocess-adapter.ts
+import { spawn } from "child_process";
 
-// src/utils/async-utils.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-var delay = sleep;
-async function withTimeout(promise, timeoutMs, errorMessage) {
-  let timeoutId;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(errorMessage));
-    }, timeoutMs);
-  });
-  try {
-    const result = await Promise.race([promise, timeoutPromise]);
-    if (timeoutId !== void 0) clearTimeout(timeoutId);
-    return { ok: true, value: result };
-  } catch (error) {
-    if (timeoutId !== void 0) clearTimeout(timeoutId);
-    return { ok: false, error: getErrorMessage(error) };
-  }
-}
+// src/cli-adapters/base-adapter.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import semver from "semver";
 
 // src/cli-adapters/cli-timeout-helpers.ts
 function estimateTaskComplexity(taskDescription) {
@@ -75,7 +53,19 @@ function estimateTaskComplexity(taskDescription) {
   if (complexIndicators.some((indicator) => lower.includes(indicator))) {
     return "complex";
   }
-  const simpleIndicators = ["single", "quick", "one function", "simple", "small", "brief", "short"];
+  const simpleIndicators = [
+    "single",
+    "quick",
+    "one function",
+    "simple",
+    "small",
+    "brief",
+    "short",
+    "run tests",
+    "test suite",
+    "exploration",
+    "explore"
+  ];
   if (simpleIndicators.some((indicator) => lower.includes(indicator))) {
     return "simple";
   }
@@ -123,11 +113,6 @@ function getTimeoutForTaskAuto(cli, taskDescription) {
   return getAdaptiveTimeout(cli, taskDescription);
 }
 
-// src/cli-adapters/base-adapter.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import semver from "semver";
-
 // src/cli-adapters/capacity-tracker.ts
 var DEFAULT_TOKEN_LIMITS = {
   claude: 1e5,
@@ -258,6 +243,98 @@ function createCapacityTracker(cli) {
   return new CapacityTracker(getDefaultConfig(cli));
 }
 
+// src/utils/async-utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var delay = sleep;
+async function withTimeout(promise, timeoutMs, errorMessage) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(errorMessage));
+    }, timeoutMs);
+  });
+  try {
+    const result = await Promise.race([promise, timeoutPromise]);
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+    return { ok: true, value: result };
+  } catch (error) {
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+    return { ok: false, error: getErrorMessage(error) };
+  }
+}
+
+// src/cli-adapters/cli-retry-loop.ts
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "TIMEOUT",
+  "RATE_LIMITED",
+  "CONNECTION_ERROR"
+]);
+function calculateBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt - 1);
+  const jitter = getRandomProvider().random() * 0.3 * exponentialDelay;
+  const delayMs = exponentialDelay + jitter;
+  return Math.min(delayMs, maxDelayMs);
+}
+function isRetryableError(code) {
+  return RETRYABLE_ERROR_CODES.has(code);
+}
+function categorizeError(error) {
+  switch (error.code) {
+    case "TIMEOUT":
+      return "timeout";
+    case "RATE_LIMITED":
+      return "rate_limit";
+    case "NOT_AUTHENTICATED":
+      return "authentication";
+    case "CONNECTION_ERROR":
+      return "connection";
+    default:
+      return "unknown";
+  }
+}
+async function executeCliRetryLoop(executeFn, config) {
+  const maxAttempts = config.allowRetry ? config.maxRetries + 1 : 1;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await executeFn();
+    if (result.ok) {
+      return ok({ response: result.value, retryCount: attempt - 1 });
+    }
+    lastError = result.error;
+    if (config.circuitBreaker !== void 0 && config.circuitBreaker !== null) {
+      config.circuitBreaker.recordFailure(categorizeError(lastError));
+    }
+    if (!shouldRetry(lastError, attempt, maxAttempts, config.circuitBreaker)) {
+      return err(lastError);
+    }
+    const delayMs = calculateBackoffDelay(attempt, config.baseDelayMs, config.maxDelayMs);
+    config.logger.debug("Retrying CLI execution", {
+      cli: config.cli,
+      attempt,
+      nextAttempt: attempt + 1,
+      delayMs: Math.round(delayMs)
+    });
+    await delay(delayMs);
+  }
+  return err(
+    lastError ?? {
+      code: "UNKNOWN",
+      message: "Max retries exceeded",
+      cli: config.cli,
+      retryable: false
+    }
+  );
+}
+function shouldRetry(error, attempt, maxAttempts, circuitBreaker) {
+  if (attempt >= maxAttempts) return false;
+  if (!error.retryable) return false;
+  if (!isRetryableError(error.code)) return false;
+  if (circuitBreaker?.getState() === "open") return false;
+  return true;
+}
+
 // src/cli-adapters/base-adapter.ts
 var execAsync = promisify(exec);
 var DEFAULT_CAPACITY_FALLBACK = 1e5;
@@ -276,8 +353,8 @@ var BaseCliAdapter = class {
   initialized = false;
   lastHealthCheck;
   cachedVersion;
-  constructor(logger6) {
-    this.logger = logger6 ?? createLogger({ component: "cli-adapter" });
+  constructor(logger5) {
+    this.logger = logger5 ?? createLogger({ component: "cli-adapter" });
   }
   /**
    * Initializes the capacity tracker.
@@ -323,47 +400,33 @@ var BaseCliAdapter = class {
     return getTimeoutForTaskAuto(this.name, task.content);
   }
   /**
-   * Executes task with retry logic.
+   * Executes task with retry logic via shared retry loop.
    */
   async executeWithRetry(task, opts) {
-    let lastError;
-    const maxAttempts = opts.allowRetry ? opts.maxRetries + 1 : 1;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const result = await this.executeTask(task, opts);
-      if (result.ok) {
-        this.recordUsage(result.value);
-        this.logger.info("Task executed successfully", {
-          cli: this.name,
-          attempt,
-          durationMs: result.value.durationMs,
-          tokensUsed: result.value.usage?.totalTokens
-        });
-        return result;
-      }
-      lastError = result.error;
-      if (this.isTerminalAttempt(result.error, attempt, maxAttempts)) {
-        this.logger.warn("Task execution failed", {
-          cli: this.name,
-          attempt,
-          error: result.error.message,
-          retryable: result.error.retryable
-        });
-        return result;
-      }
-      this.logger.debug("Retrying task execution", {
+    const result = await executeCliRetryLoop(() => this.executeTask(task, opts), {
+      maxRetries: opts.maxRetries,
+      allowRetry: opts.allowRetry,
+      baseDelayMs: 1e3,
+      maxDelayMs: 16e3,
+      cli: this.name,
+      logger: this.logger
+    });
+    if (result.ok) {
+      this.recordUsage(result.value.response);
+      this.logger.info("Task executed successfully", {
         cli: this.name,
-        attempt,
-        nextAttempt: attempt + 1
+        attempt: result.value.retryCount + 1,
+        durationMs: result.value.response.durationMs,
+        tokensUsed: result.value.response.usage?.totalTokens
       });
-      await this.delay(Math.pow(BACKOFF_CONFIG.exponentBase, attempt) * BACKOFF_CONFIG.baseDelayMs);
+      return { ok: true, value: result.value.response };
     }
-    return err(lastError ?? this.createError("UNKNOWN", "Unknown error"));
-  }
-  /**
-   * Checks if this attempt should be the final one.
-   */
-  isTerminalAttempt(error, attempt, maxAttempts) {
-    return !error.retryable || attempt === maxAttempts;
+    this.logger.warn("Task execution failed", {
+      cli: this.name,
+      error: result.error.message,
+      retryable: result.error.retryable
+    });
+    return result;
   }
   /**
    * Performs a health check.
@@ -518,19 +581,39 @@ var BaseCliAdapter = class {
   }
 };
 
-// src/cli-adapters/subprocess-adapter.ts
-import { spawn } from "child_process";
-var RATE_LIMIT_PATTERNS = [
-  "rate limit",
-  "429",
-  "too many requests",
-  "quota exceeded",
-  "usage limit"
+// src/security/output-sanitizer.ts
+var REDACTED_KEY_PLACEHOLDER = "[REDACTED_KEY]";
+var KEY_PATTERNS = [
+  // Anthropic: sk-ant-api03-... (at least 20 chars after prefix)
+  /sk-ant-[A-Za-z0-9_-]{20,}/g,
+  // OpenAI project: sk-proj-... (at least 20 chars after prefix)
+  /sk-proj-[A-Za-z0-9_-]{20,}/g,
+  // Generic OpenAI: sk-... (at least 20 chars after prefix)
+  /sk-[A-Za-z0-9_-]{20,}/g,
+  // Google AI / Gemini: AIzaSy... (at least 30 chars total)
+  /AIzaSy[A-Za-z0-9_-]{24,}/g,
+  // GitHub PAT: ghp_...
+  /ghp_[A-Za-z0-9]{20,}/g,
+  // GitHub OAuth: gho_...
+  /gho_[A-Za-z0-9]{20,}/g,
+  // GitLab PAT: glpat-...
+  /glpat-[A-Za-z0-9_-]{10,}/g,
+  // npm token: npm_...
+  /npm_[A-Za-z0-9]{20,}/g,
+  // PyPI token: pypi-...
+  /pypi-[A-Za-z0-9_-]{20,}/g
 ];
-function isRateLimitOutput(stdout) {
-  const lower = stdout.toLowerCase();
-  return RATE_LIMIT_PATTERNS.some((pattern) => lower.includes(pattern));
+function sanitizeOutput(text) {
+  if (text === "") return text;
+  let result = text;
+  for (const pattern of KEY_PATTERNS) {
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, REDACTED_KEY_PLACEHOLDER);
+  }
+  return result;
 }
+
+// src/cli-adapters/subprocess-adapter.ts
 var PLAINTEXT_FALLBACK_MIN_LENGTH = 30;
 function tryPlaintextFallback(stdout) {
   const trimmed = stdout.trim();
@@ -572,12 +655,11 @@ var STDERR_CONNECTION_PATTERNS = [
   "eaddrinuse",
   "address already in use"
 ];
-var STDERR_RATE_LIMIT_PATTERNS = ["rate limit", "quota exceeded", "429", "too many requests"];
 var STDERR_TIMEOUT_PATTERNS = ["timeout", "timed out", "etimedout"];
 function classifyStderrError(stderr) {
   const lower = stderr.toLowerCase();
   if (STDERR_CONNECTION_PATTERNS.some((p) => lower.includes(p))) return "CONNECTION_ERROR";
-  if (STDERR_RATE_LIMIT_PATTERNS.some((p) => lower.includes(p))) return "RATE_LIMITED";
+  if (isRateLimitText(stderr)) return "RATE_LIMITED";
   if (STDERR_TIMEOUT_PATTERNS.some((p) => lower.includes(p))) return "TIMEOUT";
   return "EXECUTION_ERROR";
 }
@@ -731,6 +813,8 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
   }
   /** Classify a subprocess close event into a Result. */
   classifyCloseResult(code, state, startTime) {
+    state.stdout = sanitizeOutput(state.stdout);
+    state.stderr = sanitizeOutput(state.stderr);
     if (code !== 0 && state.stdout === "") {
       if (state.stderr !== "") {
         const msg2 = state.stderr;
@@ -757,7 +841,7 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
     }
     const text = this.parser.extractResponse(stdout);
     if (text === null) {
-      if (isRateLimitOutput(stdout)) {
+      if (isRateLimitText(stdout)) {
         const snippet2 = stdout.slice(0, 500).trim();
         return err(this.createError("RATE_LIMITED", snippet2));
       }
@@ -800,7 +884,7 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
     if (error.message.includes("ENOENT")) {
       return err(this.createError("NOT_FOUND", `${this.name} CLI not found`, error));
     }
-    return err(this.createError("EXECUTION_ERROR", error.message, error));
+    return err(this.createError("EXECUTION_ERROR", sanitizeOutput(error.message), error));
   }
   /**
    * Initializes the adapter and capacity tracker.
@@ -1305,345 +1389,6 @@ var ResilientGeminiParser = class {
   }
 };
 
-// src/cli-adapters/circuit-breaker-types.ts
-var CircuitErrorCode = {
-  CIRCUIT_OPEN: "CIRCUIT_OPEN",
-  CIRCUIT_HALF_OPEN_REJECTED: "CIRCUIT_HALF_OPEN_REJECTED",
-  EXECUTION_FAILED: "EXECUTION_FAILED"
-};
-var CircuitError = class extends NexusError {
-  circuitErrorCode;
-  cliName;
-  circuitState;
-  failureCategory;
-  constructor(message, options) {
-    const baseOptions = {
-      code: ErrorCode.INTERNAL_ERROR,
-      context: {
-        circuitErrorCode: options.circuitErrorCode,
-        cliName: options.cliName,
-        circuitState: options.circuitState
-      }
-    };
-    if (options.cause !== void 0) {
-      baseOptions.cause = options.cause;
-    }
-    if (options.failureCategory !== void 0) {
-      baseOptions.context["failureCategory"] = options.failureCategory;
-    }
-    super(message, baseOptions);
-    this.name = "CircuitError";
-    this.circuitErrorCode = options.circuitErrorCode;
-    this.cliName = options.cliName;
-    this.circuitState = options.circuitState;
-    if (options.failureCategory !== void 0) {
-      this.failureCategory = options.failureCategory;
-    }
-  }
-};
-var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
-  failureThreshold: 5,
-  resetTimeoutMs: 3e4,
-  halfOpenSuccessThreshold: 2,
-  countTimeoutsAsFailures: true,
-  countAuthFailuresAsFailures: false,
-  countRateLimitsAsFailures: true,
-  halfOpenMaxRequests: 3
-};
-var TIMEOUT_PATTERNS = ["timeout", "timed out"];
-var AUTH_PATTERNS = ["auth", "unauthorized", "forbidden", "oauth"];
-var RATE_LIMIT_PATTERNS2 = ["rate limit", "too many requests", "429"];
-var CONNECTION_PATTERNS = [
-  "connection",
-  "econnrefused",
-  "enotfound",
-  "mcp",
-  "eaddrinuse",
-  "address already in use"
-];
-var CRASH_PATTERNS = ["crash", "exited", "killed", "sigterm", "sigkill"];
-function matchesPatterns(text, patterns) {
-  return patterns.some((pattern) => text.includes(pattern));
-}
-function categorizeError(error) {
-  if (!(error instanceof Error)) {
-    return "unknown";
-  }
-  const message = error.message.toLowerCase();
-  const name = error.name.toLowerCase();
-  const combined = `${message} ${name}`;
-  if (matchesPatterns(combined, TIMEOUT_PATTERNS)) return "timeout";
-  if (matchesPatterns(combined, AUTH_PATTERNS)) return "authentication";
-  if (matchesPatterns(combined, RATE_LIMIT_PATTERNS2)) return "rate_limit";
-  if (matchesPatterns(combined, CONNECTION_PATTERNS)) return "connection";
-  if (matchesPatterns(combined, CRASH_PATTERNS)) return "crash";
-  return "unknown";
-}
-
-// src/cli-adapters/circuit-breaker.ts
-var CliCircuitBreaker = class {
-  constructor(cliName, config = DEFAULT_CIRCUIT_BREAKER_CONFIG) {
-    this.cliName = cliName;
-    this.config = config;
-    this.lastStateChange = getTimeProvider().now();
-  }
-  state = "closed";
-  failureCount = 0;
-  successCount = 0;
-  lastFailureTime = null;
-  lastStateChange;
-  halfOpenRequests = 0;
-  listeners = /* @__PURE__ */ new Set();
-  /**
-   * Executes a function with circuit breaker protection.
-   */
-  async execute(fn) {
-    const canExecute = this.canExecute();
-    if (!canExecute.ok) {
-      return canExecute;
-    }
-    try {
-      const result = await fn();
-      this.onSuccess();
-      return ok(result);
-    } catch (error) {
-      const category = categorizeError(error);
-      if (this.shouldCountFailure(category)) {
-        this.onFailure(category);
-      }
-      return err(this.createExecutionError(error, category));
-    }
-  }
-  getState() {
-    this.checkStateTransition();
-    return this.state;
-  }
-  getSnapshot() {
-    this.checkStateTransition();
-    return {
-      state: this.state,
-      failureCount: this.failureCount,
-      successCount: this.successCount,
-      lastFailureTime: this.lastFailureTime,
-      lastStateChange: this.lastStateChange,
-      halfOpenRequests: this.halfOpenRequests,
-      config: this.config
-    };
-  }
-  reset() {
-    const previousState = this.state;
-    this.state = "closed";
-    this.failureCount = 0;
-    this.successCount = 0;
-    this.lastFailureTime = null;
-    this.halfOpenRequests = 0;
-    this.lastStateChange = getTimeProvider().now();
-    if (previousState !== "closed") {
-      this.emitStateChange(previousState, "closed", "Manual reset");
-    }
-  }
-  recordFailure(category) {
-    if (this.shouldCountFailure(category)) {
-      this.onFailure(category);
-    }
-  }
-  recordSuccess() {
-    this.onSuccess();
-  }
-  addStateChangeListener(listener) {
-    this.listeners.add(listener);
-  }
-  removeStateChangeListener(listener) {
-    this.listeners.delete(listener);
-  }
-  // -------------------------------------------------------------------------
-  // Private Methods
-  // -------------------------------------------------------------------------
-  canExecute() {
-    this.checkStateTransition();
-    if (this.state === "closed") {
-      return ok(true);
-    }
-    if (this.state === "open") {
-      return err(
-        new CircuitError(`Circuit is open for CLI: ${this.cliName}`, {
-          circuitErrorCode: CircuitErrorCode.CIRCUIT_OPEN,
-          cliName: this.cliName,
-          circuitState: this.state
-        })
-      );
-    }
-    if (this.halfOpenRequests >= this.config.halfOpenMaxRequests) {
-      return err(
-        new CircuitError(`Circuit half-open request limit reached for CLI: ${this.cliName}`, {
-          circuitErrorCode: CircuitErrorCode.CIRCUIT_HALF_OPEN_REJECTED,
-          cliName: this.cliName,
-          circuitState: this.state
-        })
-      );
-    }
-    this.halfOpenRequests++;
-    return ok(true);
-  }
-  checkStateTransition() {
-    if (this.state === "open" && this.lastFailureTime !== null) {
-      const elapsed = getTimeProvider().now() - this.lastFailureTime;
-      if (elapsed >= this.config.resetTimeoutMs) {
-        this.transitionTo("half-open", "Reset timeout elapsed");
-      }
-    }
-  }
-  onSuccess() {
-    if (this.state === "closed") {
-      this.failureCount = 0;
-    } else if (this.state === "half-open") {
-      this.successCount++;
-      if (this.successCount >= this.config.halfOpenSuccessThreshold) {
-        const reason = `${String(this.successCount)} consecutive successes in half-open state`;
-        this.transitionTo("closed", reason);
-      }
-    }
-  }
-  onFailure(category) {
-    this.failureCount++;
-    this.lastFailureTime = getTimeProvider().now();
-    if (this.state === "closed" && this.failureCount >= this.config.failureThreshold) {
-      const reason = `Failure threshold (${String(this.config.failureThreshold)}) exceeded`;
-      this.transitionTo("open", reason);
-    } else if (this.state === "half-open") {
-      this.transitionTo("open", `Failure during half-open recovery (category: ${category})`);
-    }
-  }
-  transitionTo(newState, reason) {
-    const previousState = this.state;
-    this.state = newState;
-    this.lastStateChange = getTimeProvider().now();
-    if (newState === "closed") {
-      this.failureCount = 0;
-      this.successCount = 0;
-      this.halfOpenRequests = 0;
-    } else if (newState === "half-open") {
-      this.successCount = 0;
-      this.halfOpenRequests = 0;
-    }
-    this.emitStateChange(previousState, newState, reason);
-  }
-  emitStateChange(previousState, newState, reason) {
-    const event = {
-      cliName: this.cliName,
-      previousState,
-      newState,
-      timestamp: this.lastStateChange,
-      failureCount: this.failureCount,
-      reason
-    };
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch {
-      }
-    }
-  }
-  shouldCountFailure(category) {
-    if (category === "timeout") return this.config.countTimeoutsAsFailures;
-    if (category === "authentication") return this.config.countAuthFailuresAsFailures;
-    if (category === "rate_limit") return this.config.countRateLimitsAsFailures;
-    return true;
-  }
-  createExecutionError(error, category) {
-    const message = getErrorMessage(error);
-    const cause = error instanceof Error ? error : new Error(String(error));
-    return new CircuitError(`CLI execution failed: ${message}`, {
-      circuitErrorCode: CircuitErrorCode.EXECUTION_FAILED,
-      cliName: this.cliName,
-      circuitState: this.state,
-      failureCategory: category,
-      cause
-    });
-  }
-};
-var CircuitBreakerRegistry = class {
-  constructor(defaultConfig = {}) {
-    this.defaultConfig = defaultConfig;
-  }
-  breakers = /* @__PURE__ */ new Map();
-  globalListeners = /* @__PURE__ */ new Set();
-  getBreaker(cliName, config) {
-    let breaker = this.breakers.get(cliName);
-    if (!breaker) {
-      const mergedConfig = {
-        ...DEFAULT_CIRCUIT_BREAKER_CONFIG,
-        ...this.defaultConfig,
-        ...config
-      };
-      breaker = new CliCircuitBreaker(cliName, mergedConfig);
-      for (const listener of this.globalListeners) {
-        breaker.addStateChangeListener(listener);
-      }
-      this.breakers.set(cliName, breaker);
-    }
-    return breaker;
-  }
-  isOpen(cliName) {
-    return this.breakers.get(cliName)?.getState() === "open";
-  }
-  getAllSnapshots() {
-    const snapshots = /* @__PURE__ */ new Map();
-    for (const [name, breaker] of this.breakers) {
-      snapshots.set(name, breaker.getSnapshot());
-    }
-    return snapshots;
-  }
-  resetAll() {
-    for (const breaker of this.breakers.values()) {
-      breaker.reset();
-    }
-  }
-  reset(cliName) {
-    this.breakers.get(cliName)?.reset();
-  }
-  addGlobalStateChangeListener(listener) {
-    this.globalListeners.add(listener);
-    for (const breaker of this.breakers.values()) {
-      breaker.addStateChangeListener(listener);
-    }
-  }
-  removeGlobalStateChangeListener(listener) {
-    this.globalListeners.delete(listener);
-    for (const breaker of this.breakers.values()) {
-      breaker.removeStateChangeListener(listener);
-    }
-  }
-  getHealthyClis() {
-    const healthy = [];
-    for (const [name, breaker] of this.breakers) {
-      if (breaker.getState() === "closed") {
-        healthy.push(name);
-      }
-    }
-    return healthy;
-  }
-  getUnhealthyClis() {
-    const unhealthy = [];
-    for (const [name, breaker] of this.breakers) {
-      const state = breaker.getState();
-      if (state === "open" || state === "half-open") {
-        unhealthy.push(name);
-      }
-    }
-    return unhealthy;
-  }
-};
-function mapCliErrorToCategory(errorCode) {
-  const mapping = {
-    TIMEOUT: "timeout",
-    NOT_AUTHENTICATED: "authentication",
-    RATE_LIMITED: "rate_limit",
-    CONNECTION_ERROR: "connection"
-  };
-  return mapping[errorCode] ?? "unknown";
-}
-
 // src/cli-adapters/adapters/gemini-adapter-helpers.ts
 var GEMINI_LEGACY_DEFAULTS = {
   displayNames: {},
@@ -1654,34 +1399,6 @@ var GEMINI_LEGACY_DEFAULTS = {
   inputCost: 0.15,
   outputCost: 0.6
 };
-var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
-  "TIMEOUT",
-  "RATE_LIMITED",
-  "CONNECTION_ERROR"
-]);
-function calculateBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
-  const exponentialDelay = baseDelayMs * Math.pow(2, attempt - 1);
-  const jitter = getRandomProvider().random() * 0.3 * exponentialDelay;
-  const delay2 = exponentialDelay + jitter;
-  return Math.min(delay2, maxDelayMs);
-}
-function isRetryableError(code) {
-  return RETRYABLE_ERROR_CODES.has(code);
-}
-function categorizeError2(error) {
-  switch (error.code) {
-    case "TIMEOUT":
-      return "timeout";
-    case "RATE_LIMITED":
-      return "rate_limit";
-    case "NOT_AUTHENTICATED":
-      return "authentication";
-    case "CONNECTION_ERROR":
-      return "connection";
-    default:
-      return "unknown";
-  }
-}
 function createCircuitOpenError(cli) {
   return {
     code: "EXECUTION_ERROR",
@@ -1833,69 +1550,14 @@ var GeminiCliAdapter = class extends SubprocessCliAdapter {
     return err(result.error);
   }
   async executeWithRetryTracking(task, options) {
-    const maxAttempts = options.allowRetry ? options.maxRetries + 1 : 1;
-    let retryContext = {
-      attempt: 0,
-      maxAttempts,
-      totalDelayMs: 0
-    };
-    while (retryContext.attempt < maxAttempts) {
-      retryContext = { ...retryContext, attempt: retryContext.attempt + 1 };
-      this.logRetryAttempt(retryContext, task);
-      const result = await this.executeTask(task, options);
-      if (result.ok) {
-        return ok({ response: result.value, retryCount: retryContext.attempt - 1 });
-      }
-      const error = result.error;
-      retryContext = { ...retryContext, lastError: error };
-      if (this.circuitBreaker !== null) {
-        this.circuitBreaker.recordFailure(categorizeError2(error));
-      }
-      if (!this.shouldRetry(error, retryContext)) {
-        return err(error);
-      }
-      const delayMs = calculateBackoffDelay(
-        retryContext.attempt,
-        this.baseDelayMs,
-        this.maxDelayMs
-      );
-      retryContext = { ...retryContext, totalDelayMs: retryContext.totalDelayMs + delayMs };
-      this.logRetryDelay(retryContext, delayMs);
-      await delay(delayMs);
-    }
-    return err(retryContext.lastError ?? this.createError("UNKNOWN", "Max retries exceeded"));
-  }
-  shouldRetry(error, context) {
-    if (context.attempt >= context.maxAttempts) {
-      return false;
-    }
-    if (!error.retryable) {
-      return false;
-    }
-    if (this.circuitBreaker?.getState() === "open") {
-      return false;
-    }
-    return isRetryableError(error.code);
-  }
-  logRetryAttempt(context, task) {
-    if (context.attempt === 1) {
-      this.adapterLogger.debug("Executing Gemini task", {
-        contentLength: task.content.length,
-        model: task.model ?? this.model
-      });
-    } else {
-      this.adapterLogger.info("Retrying Gemini task", {
-        attempt: context.attempt,
-        maxAttempts: context.maxAttempts,
-        lastError: context.lastError?.code
-      });
-    }
-  }
-  logRetryDelay(context, delayMs) {
-    this.adapterLogger.debug("Backoff delay before retry", {
-      attempt: context.attempt,
-      delayMs: Math.round(delayMs),
-      totalDelayMs: Math.round(context.totalDelayMs)
+    return executeCliRetryLoop(() => this.executeTask(task, options), {
+      maxRetries: options.maxRetries,
+      allowRetry: options.allowRetry,
+      baseDelayMs: this.baseDelayMs,
+      maxDelayMs: this.maxDelayMs,
+      circuitBreaker: this.circuitBreaker,
+      cli: this.name,
+      logger: this.adapterLogger
     });
   }
 };
@@ -2933,9 +2595,9 @@ function createCodexAdapter(transport, options) {
   }
   return new CodexMcpAdapter(options);
 }
-function createAllAdapters(logger6, codexTransport = "mcp") {
+function createAllAdapters(logger5, codexTransport = "mcp") {
   const adapters = /* @__PURE__ */ new Map();
-  const options = logger6 !== void 0 ? { logger: logger6 } : void 0;
+  const options = logger5 !== void 0 ? { logger: logger5 } : void 0;
   adapters.set("claude", new ClaudeCliAdapter(options));
   adapters.set("gemini", new GeminiCliAdapter(options));
   adapters.set("codex", createCodexAdapter(codexTransport, options ?? {}));
@@ -2979,920 +2641,7 @@ async function getAvailableClis(cache) {
   ).map((r) => r.value.cli);
 }
 
-// src/cli/setup-data-dir.ts
-import { mkdirSync, existsSync as existsSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-
-// src/cli/doctor.ts
-import { existsSync, readFileSync, accessSync, constants as fsConstants } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-
-// src/mcp/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/mcp/task-store.ts
-import { InMemoryTaskStore } from "@modelcontextprotocol/sdk/experimental/tasks";
-var MAX_TASK_TTL_MS = 6e5;
-var DEFAULT_TASK_TTL_MS = 3e5;
-var MAX_TASK_CAPACITY = 50;
-var CLEANUP_INTERVAL_MS = 6e4;
-var logger5 = createLogger({ component: "task-store" });
-var singletonStore;
-var cleanupTimer;
-function getTaskStore() {
-  if (singletonStore === void 0) {
-    singletonStore = new InMemoryTaskStore();
-    logger5.info("Task store created", { maxCapacity: MAX_TASK_CAPACITY });
-    cleanupTimer = setInterval(() => {
-      evictExcessTasks();
-    }, CLEANUP_INTERVAL_MS);
-    if (typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
-      cleanupTimer.unref();
-    }
-  }
-  return singletonStore;
-}
-function clampTaskTtl(requestedTtl) {
-  if (requestedTtl === void 0 || requestedTtl === null) {
-    return DEFAULT_TASK_TTL_MS;
-  }
-  if (requestedTtl > MAX_TASK_TTL_MS) {
-    logger5.warn("Task TTL clamped to maximum", {
-      requested: requestedTtl,
-      max: MAX_TASK_TTL_MS
-    });
-    return MAX_TASK_TTL_MS;
-  }
-  return requestedTtl;
-}
-function evictExcessTasks() {
-  if (singletonStore === void 0) return;
-  const allTasks = singletonStore.getAllTasks();
-  if (allTasks.length <= MAX_TASK_CAPACITY) return;
-  const sorted = [...allTasks].sort(
-    (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
-  );
-  const evictCount = sorted.length - MAX_TASK_CAPACITY;
-  for (let i = 0; i < evictCount; i++) {
-    const task = sorted[i];
-    if (task === void 0) continue;
-    singletonStore.updateTaskStatus(task.taskId, "cancelled", "Evicted: capacity exceeded").catch((err2) => {
-      logger5.debug("Failed to evict task", {
-        taskId: task.taskId,
-        error: String(err2)
-      });
-    });
-  }
-  logger5.info("Evicted excess tasks", { evicted: evictCount, total: sorted.length });
-}
-
-// src/mcp/server.ts
-var DEFAULT_SERVER_NAME = "nexus-agents";
-function createServerError(code, message, error) {
-  const serverError = { code, message };
-  if (error instanceof Error) {
-    serverError.cause = error;
-  }
-  return serverError;
-}
-function createServer(config) {
-  const serverName = config?.name ?? DEFAULT_SERVER_NAME;
-  const serverVersion = config?.version ?? VERSION;
-  const logger6 = config?.logger ?? createLogger({ component: "mcp-server" });
-  try {
-    initDataDirectories();
-    logger6.info("Creating MCP server", {
-      name: serverName,
-      version: serverVersion
-    });
-    const server = new McpServer(
-      {
-        name: serverName,
-        version: serverVersion
-      },
-      {
-        capabilities: {
-          logging: {},
-          prompts: {},
-          resources: {},
-          tasks: {}
-        },
-        taskStore: getTaskStore()
-      }
-    );
-    logger6.debug("MCP server created successfully");
-    return ok({ server, logger: logger6 });
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    logger6.error("Failed to create MCP server", error instanceof Error ? error : void 0);
-    return err(
-      createServerError(
-        "SERVER_CREATION_FAILED",
-        `Failed to create MCP server: ${errorMessage}`,
-        error
-      )
-    );
-  }
-}
-async function connectTransport(server, transport, logger6) {
-  const log = logger6 ?? createLogger({ component: "mcp-server" });
-  try {
-    log.info("Connecting server to transport");
-    await server.connect(transport);
-    log.debug("Server connected to transport successfully");
-    return ok(void 0);
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    log.error("Failed to connect to transport", error instanceof Error ? error : void 0);
-    return err(
-      createServerError(
-        "SERVER_START_FAILED",
-        `Failed to connect to transport: ${errorMessage}`,
-        error
-      )
-    );
-  }
-}
-async function startStdioServer(config) {
-  const serverResult = createServer(config);
-  if (!serverResult.ok) {
-    return serverResult;
-  }
-  const { server, logger: logger6 } = serverResult.value;
-  try {
-    logger6.info("Starting stdio transport");
-    const transport = new StdioServerTransport();
-    const connectResult = await connectTransport(server, transport, logger6);
-    if (!connectResult.ok) {
-      return connectResult;
-    }
-    logger6.info("MCP server running with stdio transport");
-    return ok({ server, logger: logger6 });
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    logger6.error("Failed to start stdio server", error instanceof Error ? error : void 0);
-    return err(
-      createServerError(
-        "SERVER_START_FAILED",
-        `Failed to start stdio server: ${errorMessage}`,
-        error
-      )
-    );
-  }
-}
-async function closeServer(server, logger6) {
-  const log = logger6 ?? createLogger({ component: "mcp-server" });
-  try {
-    log.info("Closing MCP server");
-    await server.close();
-    log.info("MCP server closed successfully");
-    return ok(void 0);
-  } catch (error) {
-    const errorMessage = getErrorMessage(error);
-    log.error("Failed to close server", error instanceof Error ? error : void 0);
-    return err(
-      createServerError("SERVER_STOP_FAILED", `Failed to close server: ${errorMessage}`, error)
-    );
-  }
-}
-
-// src/utils/text-utils.ts
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "are",
-  "as",
-  "at",
-  "be",
-  "by",
-  "for",
-  "from",
-  "has",
-  "he",
-  "in",
-  "is",
-  "it",
-  "its",
-  "of",
-  "on",
-  "or",
-  "that",
-  "the",
-  "to",
-  "was",
-  "were",
-  "will",
-  "with",
-  "this",
-  "but",
-  "they",
-  "have",
-  "had",
-  "what",
-  "when",
-  "where",
-  "who",
-  "which",
-  "why",
-  "how",
-  "all",
-  "each",
-  "every",
-  "both",
-  "few",
-  "more",
-  "most",
-  "other",
-  "some",
-  "such",
-  "no",
-  "nor",
-  "not",
-  "only",
-  "own",
-  "same",
-  "so",
-  "than",
-  "too",
-  "very",
-  "can",
-  "just",
-  "should",
-  "now",
-  "i",
-  "you",
-  "we",
-  "me",
-  "my",
-  "your",
-  "our",
-  "their",
-  "him",
-  "her",
-  "them",
-  "his",
-  "hers",
-  "able"
-]);
-function tokenize(text, minLength = 2) {
-  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= minLength);
-}
-function tokenizeFiltered(text, minLength = 2) {
-  return tokenize(text, minLength).filter((t) => !STOPWORDS.has(t));
-}
-function stringifyValue(value) {
-  if (typeof value === "string") return value;
-  if (value === null || value === void 0) return "";
-  return JSON.stringify(value);
-}
-function capitalize(str) {
-  if (str.length === 0) return str;
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function capitalizeWords(str) {
-  return str.split(" ").map((word) => capitalize(word)).join(" ");
-}
-function capitalizeKebab(str) {
-  return str.split("-").map((word) => capitalize(word)).join(" ");
-}
-function truncateWithInfo(text, maxLength) {
-  if (text.length <= maxLength) return text;
-  const truncatedBytes = text.length - maxLength;
-  return `${text.slice(0, maxLength)}
-... [truncated ${String(truncatedBytes)} bytes]`;
-}
-function truncateSentence(text, maxLength = 150) {
-  const sentenceEnd = text.search(/[.!?](?:\s|$)/);
-  if (sentenceEnd !== -1 && sentenceEnd < maxLength) {
-    return text.slice(0, sentenceEnd + 1).trim();
-  }
-  if (text.length <= maxLength) return text;
-  return text.slice(0, maxLength).trim() + "...";
-}
-
-// src/cli/doctor-formatting.ts
-var REQUIRED_NODE_MAJOR = 22;
-function formatStatus(healthy, warn = false) {
-  if (healthy) return `${colors.green}${symbols.check}${colors.reset}`;
-  if (warn) return `${colors.yellow}${symbols.warn}${colors.reset}`;
-  return `${colors.red}${symbols.cross}${colors.reset}`;
-}
-function formatVersionStatus(status) {
-  switch (status) {
-    case "supported":
-      return `${colors.green}supported${colors.reset}`;
-    case "outdated":
-      return `${colors.yellow}outdated${colors.reset}`;
-    case "unsupported":
-    case "breaking":
-      return `${colors.red}${status}${colors.reset}`;
-    default:
-      return status;
-  }
-}
-function formatCapacity(capacity) {
-  if (capacity === void 0) return "Unknown";
-  const remaining = 100 - capacity.utilizationPercent;
-  const remainingStr = String(remaining);
-  if (remaining > 80) return `${colors.green}${remainingStr}% remaining${colors.reset}`;
-  if (remaining > 20) return `${colors.yellow}${remainingStr}% remaining${colors.reset}`;
-  return `${colors.red}${remainingStr}% remaining${colors.reset}`;
-}
-function printInstalledCliDetails(cli) {
-  writeLine(`  Version: ${cli.version} (${formatVersionStatus(cli.versionStatus)})`);
-  const authText = cli.authenticated ? `${colors.green}${cli.authMethod ?? "Authenticated"}${colors.reset}` : `${colors.red}Not authenticated${colors.reset}`;
-  writeLine(`  Auth: ${authText}`);
-  if (cli.capacity !== void 0) {
-    writeLine(`  Capacity: ${formatCapacity(cli.capacity)}`);
-  }
-}
-function printCliResult(cli) {
-  const status = cli.installed && cli.authenticated;
-  const warn = cli.installed && (!cli.authenticated || cli.versionStatus === "outdated");
-  writeLine(
-    `${formatStatus(status, warn)} ${colors.bold}${capitalize(cli.name)} CLI${colors.reset}`
-  );
-  if (cli.installed) {
-    printInstalledCliDetails(cli);
-  } else {
-    const errorText = cli.error ?? "Not installed";
-    writeLine(`  ${colors.red}Error: ${errorText}${colors.reset}`);
-  }
-  if (cli.fix !== void 0 && cli.fix !== "") {
-    writeLine(`  ${colors.dim}Fix: ${cli.fix}${colors.reset}`);
-  }
-  writeLine("");
-}
-function printCapabilities(clis) {
-  const installedClis = clis.filter((c) => c.installed);
-  if (installedClis.length === 0) {
-    writeLine(`${formatStatus(false)} No CLIs installed`);
-    return;
-  }
-  const caps = DEFAULT_CAPABILITIES;
-  const bestReasoning = installedClis.reduce(
-    (best, c) => caps[c.name].reasoning > caps[best.name].reasoning ? c : best
-  );
-  const bestContext = installedClis.reduce(
-    (best, c) => caps[c.name].contextWindow > caps[best.name].contextWindow ? c : best
-  );
-  const bestSpeed = installedClis.reduce(
-    (best, c) => caps[c.name].speed > caps[best.name].speed ? c : best
-  );
-  const contextTokensK = (caps[bestContext.name].contextWindow / 1e3).toFixed(0);
-  writeLine(
-    `${formatStatus(true)} Complex reasoning: ${colors.bold}${capitalize(bestReasoning.name)}${colors.reset}`
-  );
-  writeLine(
-    `${formatStatus(true)} Large context: ${colors.bold}${capitalize(bestContext.name)}${colors.reset} (${contextTokensK}K tokens)`
-  );
-  writeLine(
-    `${formatStatus(true)} Fast execution: ${colors.bold}${capitalize(bestSpeed.name)}${colors.reset}`
-  );
-}
-function printNodeVersionCheck(check) {
-  const versionText = check.supported ? `${colors.green}${check.version}${colors.reset}` : `${colors.yellow}${check.version}${colors.reset}`;
-  writeLine(`${formatStatus(check.supported, !check.supported)} Node.js version: ${versionText}`);
-  if (!check.supported) {
-    writeLine(
-      `  ${colors.dim}Warning: Node.js ${String(REQUIRED_NODE_MAJOR)}.x LTS required${colors.reset}`
-    );
-  }
-}
-function printApiKeysCheck(keys) {
-  const configuredCount = keys.filter((k) => k.configured).length;
-  const configuredNames = keys.filter((k) => k.configured).map((k) => k.name);
-  const hasAny = configuredCount > 0;
-  writeLine(
-    `${formatStatus(hasAny, !hasAny)} API keys configured: ${String(configuredCount)} of ${String(keys.length)}`
-  );
-  if (hasAny) {
-    writeLine(`  ${colors.dim}Keys: ${configuredNames.join(", ")}${colors.reset}`);
-  } else {
-    writeLine(
-      `  ${colors.dim}Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_API_KEY${colors.reset}`
-    );
-  }
-}
-function printConfigFileCheck(check) {
-  if (check.found && check.path !== null) {
-    writeLine(`${formatStatus(true)} Configuration loaded: ${check.path}`);
-  } else {
-    writeLine(`${formatStatus(false, true)} Configuration file: Not found`);
-    writeLine(`  ${colors.dim}Run: nexus-agents config init${colors.reset}`);
-  }
-}
-function printRegistryAdvisory(advisory) {
-  const allAvailable = advisory.unavailableModels === 0;
-  const countText = `${String(advisory.availableModels)} of ${String(advisory.totalModels)}`;
-  writeLine(`${formatStatus(allAvailable, !allAvailable)} Models available: ${countText}`);
-  if (advisory.unavailableModels > 0) {
-    const missing = advisory.models.filter((m) => !m.available);
-    for (const m of missing) {
-      writeLine(`  ${colors.dim}${m.displayName} \u2014 ${m.reason}${colors.reset}`);
-    }
-  }
-  const ageText = `${String(advisory.registryAgeDays)} days old`;
-  if (advisory.registryStale) {
-    writeLine(
-      `${colors.yellow}${symbols.warn}${colors.reset} Model registry is ${ageText} \u2014 may have stale model data`
-    );
-    writeLine(`  ${colors.dim}Run: npx tsx scripts/probe-models.ts${colors.reset}`);
-  } else {
-    writeLine(`${formatStatus(true)} Model registry: ${ageText}`);
-  }
-}
-function printLearningPersistence(check) {
-  if (!check.enabled) {
-    writeLine(`${formatStatus(true)} Learning persistence: ${colors.dim}Disabled${colors.reset}`);
-    writeLine(`  ${colors.dim}Set NEXUS_PERSIST_LEARNING=true to enable${colors.reset}`);
-    return;
-  }
-  const healthy = check.dirExists && check.dirWritable && check.error === null;
-  writeLine(`${formatStatus(healthy, !healthy)} Learning persistence: Enabled`);
-  if (check.error !== null) {
-    writeLine(`  ${colors.red}Error: ${check.error}${colors.reset}`);
-    return;
-  }
-  const dirStatus = check.dirExists ? check.dirWritable ? `${colors.green}writable${colors.reset}` : `${colors.red}not writable${colors.reset}` : `${colors.yellow}not created yet${colors.reset}`;
-  writeLine(`  Data directory: ${dirStatus}`);
-  writeLine(`  Outcomes: ${String(check.outcomeCount)} recorded`);
-  writeLine(`  Distilled rules: ${String(check.ruleCount)} active`);
-  if (check.rulesLastSaved !== null) {
-    writeLine(`  Rules last saved: ${check.rulesLastSaved}`);
-  }
-}
-function printSqliteCheck(check) {
-  if (check.available) {
-    writeLine(
-      `${formatStatus(true)} SQLite (better-sqlite3): ${colors.green}Available${colors.reset}`
-    );
-  } else {
-    writeLine(
-      `${formatStatus(false, true)} SQLite (better-sqlite3): ${colors.yellow}Not available${colors.reset}`
-    );
-    writeLine(
-      `  ${colors.dim}Memory backends (agentic, adaptive, typed) require it${colors.reset}`
-    );
-    writeLine(`  ${colors.dim}Fix: npm install -g better-sqlite3${colors.reset}`);
-  }
-}
-function printDataDirectory(check) {
-  if (check.rootExists) {
-    const existCount = check.subdirectories.filter((d) => d.exists).length;
-    const totalCount = check.subdirectories.length;
-    const allExist = existCount === totalCount;
-    const allWritable = check.subdirectories.every((d) => !d.exists || d.writable);
-    const healthy = allExist && allWritable;
-    writeLine(
-      `${formatStatus(healthy, !healthy)} Data directory: ${check.rootPath} (${String(existCount)}/${String(totalCount)} subdirs)`
-    );
-    if (!allExist) {
-      const missing = check.subdirectories.filter((d) => !d.exists);
-      for (const dir of missing) {
-        writeLine(`  ${colors.dim}Missing: ${dir.name}/${colors.reset}`);
-      }
-      writeLine(`  ${colors.dim}Fix: nexus-agents setup${colors.reset}`);
-    }
-    if (!allWritable) {
-      const readonly_ = check.subdirectories.filter((d) => d.exists && !d.writable);
-      for (const dir of readonly_) {
-        writeLine(`  ${colors.yellow}Not writable: ${dir.name}/${colors.reset}`);
-      }
-    }
-  } else {
-    writeLine(
-      `${formatStatus(false, true)} Data directory: ${colors.yellow}Not created${colors.reset}`
-    );
-    writeLine(`  ${colors.dim}Run: nexus-agents setup${colors.reset}`);
-  }
-}
-function printDoctorSummary(result) {
-  const unhealthyCount = result.clis.filter((c) => !c.installed || !c.authenticated).length;
-  const nodeIssue = result.nodeVersion.supported ? 0 : 1;
-  const totalIssues = unhealthyCount + nodeIssue + (result.mcpServerReady ? 0 : 1);
-  const summary = result.allHealthy ? `${colors.green}${colors.bold}Status: Ready${colors.reset}` : `${colors.yellow}${colors.bold}Summary: ${String(totalIssues)} issue(s) found${colors.reset}`;
-  writeLine(summary);
-  writeLine("");
-}
-function printDoctorResults(result) {
-  writeLine("");
-  writeLine(`${colors.bold}Nexus Agents Doctor${colors.reset}`);
-  writeLine("===================");
-  writeLine("");
-  writeLine(`${colors.cyan}Checking environment...${colors.reset}`);
-  writeLine("");
-  printNodeVersionCheck(result.nodeVersion);
-  printApiKeysCheck(result.apiKeys);
-  printConfigFileCheck(result.configFile);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking CLI installations...${colors.reset}`);
-  writeLine("");
-  for (const cli of result.clis) {
-    printCliResult(cli);
-  }
-  writeLine(`${colors.cyan}Checking MCP configuration...${colors.reset}`);
-  writeLine("");
-  writeLine(
-    `${formatStatus(result.mcpServerReady)} MCP Server mode: ${result.mcpServerReady ? "Ready" : "Not ready"}`
-  );
-  writeLine(
-    `${formatStatus(result.mcpClientReady)} MCP Client mode: ${result.mcpClientReady ? "Ready (Codex mcp-server)" : "Not ready (Codex not installed)"}`
-  );
-  writeLine("");
-  writeLine(`${colors.cyan}Checking capabilities...${colors.reset}`);
-  writeLine("");
-  printCapabilities(result.clis);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking model registry...${colors.reset}`);
-  writeLine("");
-  printRegistryAdvisory(result.registryAdvisory);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking learning subsystem...${colors.reset}`);
-  writeLine("");
-  printLearningPersistence(result.learningPersistence);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking data storage...${colors.reset}`);
-  writeLine("");
-  printSqliteCheck(result.sqliteCheck);
-  printDataDirectory(result.dataDirectory);
-  writeLine("");
-  printDoctorSummary(result);
-}
-
-// src/cli/doctor.ts
-var REQUIRED_NODE_MAJOR2 = 22;
-var API_KEY_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GOOGLE_AI_API_KEY"];
-var CONFIG_FILE_PATHS = ["./nexus-agents.yaml", "./nexus-agents.yml"];
-var DATA_SUBDIRECTORIES = [
-  "memory",
-  "memory/beliefs",
-  "learning",
-  "sessions",
-  "audit",
-  "voting",
-  "auth",
-  "research",
-  "checkpoints"
-];
-function getFixCommand(name, issue) {
-  const commands = {
-    claude: {
-      install: "npm install -g @anthropic-ai/claude-code",
-      upgrade: "npm update -g @anthropic-ai/claude-code",
-      auth: "claude auth login"
-    },
-    gemini: {
-      install: "npm install -g @google/gemini-cli",
-      upgrade: "npm update -g @google/gemini-cli",
-      auth: "gemini auth login"
-    },
-    codex: {
-      install: "npm install -g @openai/codex",
-      upgrade: "npm update -g @openai/codex",
-      auth: "codex auth login"
-    },
-    opencode: {
-      install: "npm install -g opencode-ai",
-      upgrade: "npm update -g opencode-ai",
-      auth: "opencode auth login"
-    }
-  };
-  return commands[name][issue] ?? "";
-}
-function createNotFoundResult(name, errorMsg) {
-  return {
-    name,
-    installed: false,
-    version: "N/A",
-    versionStatus: "unsupported",
-    authenticated: false,
-    error: errorMsg,
-    fix: getFixCommand(name, "install")
-  };
-}
-function detectAuthMethod(name) {
-  const authMethods = {
-    claude: "CLI auth",
-    gemini: "ADC/CLI auth",
-    codex: "CLI auth",
-    opencode: "CLI auth"
-  };
-  return authMethods[name];
-}
-function createHealthyResult(name, health, capacity) {
-  const authenticated = health.healthy;
-  const result = {
-    name,
-    installed: true,
-    version: health.version,
-    versionStatus: health.versionStatus,
-    authenticated,
-    ...authenticated && { authMethod: detectAuthMethod(name) },
-    ...capacity !== void 0 && { capacity }
-  };
-  if (health.message !== void 0 && health.message !== "") {
-    return { ...result, error: health.message };
-  }
-  if (!authenticated) {
-    return { ...result, fix: getFixCommand(name, "auth") };
-  }
-  if (health.versionStatus === "outdated") {
-    return { ...result, fix: getFixCommand(name, "upgrade") };
-  }
-  return result;
-}
-async function checkCli(name) {
-  const adapters = createAllAdapters();
-  const adapter = adapters.get(name);
-  if (!adapter) {
-    return createNotFoundResult(name, "Adapter not available");
-  }
-  try {
-    const health = await adapter.healthCheck();
-    let capacity;
-    try {
-      capacity = await adapter.getCapacity();
-    } catch (capErr) {
-      void capErr;
-    }
-    return createHealthyResult(name, health, capacity);
-  } catch (error) {
-    const message = getErrorMessage(error);
-    const isNotFound = message.includes("ENOENT") || message.includes("not found");
-    return createNotFoundResult(name, isNotFound ? "Not found in PATH" : message);
-  }
-}
-function checkNodeVersion() {
-  const version = process.version;
-  const major = Number(version.slice(1).split(".")[0]);
-  return {
-    version,
-    major,
-    supported: major >= REQUIRED_NODE_MAJOR2
-  };
-}
-function checkApiKeys() {
-  return API_KEY_VARS.map((name) => ({
-    name,
-    configured: typeof process.env[name] === "string" && process.env[name] !== ""
-  }));
-}
-function checkConfigFile() {
-  for (const configPath of CONFIG_FILE_PATHS) {
-    if (existsSync(configPath)) {
-      return { found: true, path: configPath };
-    }
-  }
-  return { found: false, path: null };
-}
-function checkMcpServerReady() {
-  try {
-    const result = createServer({ name: "nexus-agents-doctor-check" });
-    return result.ok;
-  } catch {
-    return false;
-  }
-}
-function buildRegistryAdvisory(cliResults) {
-  const installedClis = new Set(cliResults.filter((c) => c.installed).map((c) => c.name));
-  const models = DEFAULT_MODEL_CAPABILITIES.models.filter((m) => m.cliName !== void 0).map((m) => {
-    const cliName = m.cliName ?? "";
-    const available = cliName.length > 0 && installedClis.has(cliName);
-    const reason = available ? `${cliName} CLI is installed` : `${cliName} CLI is not installed`;
-    return { modelId: m.id, displayName: m.displayName, cliName, available, reason };
-  });
-  const STALE_THRESHOLD_DAYS = 30;
-  const updatedAt = new Date(DEFAULT_MODEL_CAPABILITIES.updatedAt);
-  const nowMs = getTimeProvider().now();
-  const ageDays = Math.floor((nowMs - updatedAt.getTime()) / (1e3 * 60 * 60 * 24));
-  return {
-    totalModels: models.length,
-    availableModels: models.filter((m) => m.available).length,
-    unavailableModels: models.filter((m) => !m.available).length,
-    models,
-    registryAgeDays: ageDays,
-    registryStale: ageDays > STALE_THRESHOLD_DAYS
-  };
-}
-function countJsonlLines(filePath) {
-  if (!existsSync(filePath)) return 0;
-  return readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim().length > 0).length;
-}
-function readRulesMetadata(filePath) {
-  if (!existsSync(filePath)) return { count: 0, savedAt: null };
-  try {
-    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
-    const rules = raw["rules"];
-    const saved = raw["savedAt"];
-    return {
-      count: Array.isArray(rules) ? rules.length : 0,
-      savedAt: typeof saved === "string" ? saved : null
-    };
-  } catch {
-    return { count: 0, savedAt: null };
-  }
-}
-function checkDirAccess(dir) {
-  const exists = existsSync(dir);
-  if (!exists) return { exists: false, writable: false };
-  try {
-    accessSync(dir, fsConstants.W_OK);
-    return { exists: true, writable: true };
-  } catch {
-    return { exists: true, writable: false };
-  }
-}
-var DISABLED_CHECK = {
-  enabled: false,
-  dirExists: false,
-  dirWritable: false,
-  outcomeCount: 0,
-  ruleCount: 0,
-  rulesLastSaved: null,
-  error: null
-};
-function checkLearningPersistence() {
-  if (!isPersistenceEnabled()) return DISABLED_CHECK;
-  try {
-    const { exists: dirExists, writable: dirWritable } = checkDirAccess(LEARNING_DIR);
-    const outcomeCount = countJsonlLines(OUTCOMES_FILE);
-    const { count: ruleCount, savedAt: rulesLastSaved } = readRulesMetadata(RULES_FILE);
-    return {
-      enabled: true,
-      dirExists,
-      dirWritable,
-      outcomeCount,
-      ruleCount,
-      rulesLastSaved,
-      error: null
-    };
-  } catch (error) {
-    return {
-      enabled: true,
-      dirExists: false,
-      dirWritable: false,
-      outcomeCount: 0,
-      ruleCount: 0,
-      rulesLastSaved: null,
-      error: getErrorMessage(error)
-    };
-  }
-}
-async function checkSqlite() {
-  try {
-    await import("better-sqlite3");
-    return { available: true, error: null };
-  } catch (error) {
-    const msg = getErrorMessage(error);
-    const isNotFound = msg.includes("Cannot find") || msg.includes("MODULE_NOT_FOUND");
-    return {
-      available: false,
-      error: isNotFound ? "better-sqlite3 not installed \u2014 5 memory backends unavailable" : `better-sqlite3 load error: ${msg}`
-    };
-  }
-}
-function checkDataDirectory() {
-  const rootPath = join(homedir(), ".nexus-agents");
-  const rootExists = existsSync(rootPath);
-  const subdirectories = DATA_SUBDIRECTORIES.map((name) => {
-    const fullPath = join(rootPath, name);
-    const exists = existsSync(fullPath);
-    return { name, path: fullPath, exists, writable: exists && isWritable(fullPath) };
-  });
-  return { rootExists, rootPath, subdirectories };
-}
-function isWritable(dirPath) {
-  try {
-    accessSync(dirPath, fsConstants.W_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function runDoctor() {
-  const clis = await Promise.all([
-    checkCli("claude"),
-    checkCli("gemini"),
-    checkCli("codex"),
-    checkCli("opencode")
-  ]);
-  const nodeVersion = checkNodeVersion();
-  const apiKeys = checkApiKeys();
-  const configFile = checkConfigFile();
-  const mcpServerReady = checkMcpServerReady();
-  const codexCheck = clis.find((c) => c.name === "codex");
-  const mcpClientReady = codexCheck?.installed ?? false;
-  const registryAdvisory = buildRegistryAdvisory(clis);
-  const learningPersistence = checkLearningPersistence();
-  const sqliteCheck = await checkSqlite();
-  const dataDirectory = checkDataDirectory();
-  const hasAuthMethod = apiKeys.some((k) => k.configured) || clis.some((c) => c.installed && c.authenticated);
-  const allHealthy = nodeVersion.supported && hasAuthMethod && mcpServerReady && clis.every((c) => c.installed && c.authenticated && c.versionStatus !== "unsupported");
-  return {
-    clis,
-    nodeVersion,
-    apiKeys,
-    configFile,
-    mcpServerReady,
-    mcpClientReady,
-    registryAdvisory,
-    learningPersistence,
-    sqliteCheck,
-    dataDirectory,
-    allHealthy,
-    timestamp: new Date(getTimeProvider().now())
-  };
-}
-async function doctorCommand(options = {}) {
-  const result = await runDoctor();
-  printDoctorResults(result);
-  if (options.fix === true) {
-    await runDoctorFix(result);
-  }
-  return result.allHealthy ? 0 : 1;
-}
-async function runDoctorFix(result) {
-  const writeLine2 = (text) => {
-    process.stdout.write(text + "\n");
-  };
-  writeLine2("");
-  writeLine2("\x1B[1mAuto-fix\x1B[0m");
-  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-SS7LMN7Y.js");
-    const setupResult = runSetup({
-      skipMcp: true,
-      skipRules: true,
-      skipHooks: true,
-      skipConfig: true,
-      skipOpencode: true
-    });
-    if (setupResult.success) {
-      writeLine2("\u2713 Created missing data directories");
-      fixCount++;
-    }
-  }
-  if (!result.configFile.found) {
-    const { runConfigInitSync } = await import("./setup-config-DSMOOLVW.js");
-    const configResult = runConfigInitSync(process.cwd(), false, false);
-    if (configResult.success && configResult.created) {
-      writeLine2(`\u2713 Generated config: ${configResult.path}`);
-      fixCount++;
-    }
-  }
-  if (!result.sqliteCheck.available) {
-    writeLine2("");
-    writeLine2("\u26A0 better-sqlite3 not installed (manual step required):");
-    writeLine2("  npm install -g better-sqlite3");
-  }
-  if (fixCount > 0) {
-    writeLine2("");
-    writeLine2(
-      `\x1B[32m${String(fixCount)} issue(s) fixed.\x1B[0m Re-run \x1B[1mnexus-agents doctor\x1B[0m to verify.`
-    );
-  } else {
-    writeLine2("No auto-fixable issues found.");
-  }
-  writeLine2("");
-}
-
-// src/cli/setup-data-dir.ts
-var NEXUS_DATA_DIR = join2(homedir2(), ".nexus-agents");
-var RESTRICTED_DIRS = /* @__PURE__ */ new Set(["auth"]);
-function initDataDirectories(dryRun = false) {
-  const created = [];
-  const alreadyExisted = [];
-  try {
-    ensureDir(NEXUS_DATA_DIR, dryRun, created, alreadyExisted);
-    for (const subdir of DATA_SUBDIRECTORIES) {
-      const mode = RESTRICTED_DIRS.has(subdir) ? 448 : void 0;
-      ensureDir(join2(NEXUS_DATA_DIR, subdir), dryRun, created, alreadyExisted, mode);
-    }
-    return { success: true, rootPath: NEXUS_DATA_DIR, created, alreadyExisted, error: null };
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    return { success: false, rootPath: NEXUS_DATA_DIR, created, alreadyExisted, error: msg };
-  }
-}
-function ensureDir(dirPath, dryRun, created, alreadyExisted, mode) {
-  if (existsSync2(dirPath)) {
-    alreadyExisted.push(dirPath);
-    return;
-  }
-  if (!dryRun) {
-    mkdirSync(dirPath, { recursive: true, ...mode !== void 0 ? { mode } : {} });
-  }
-  created.push(dirPath);
-}
-
 export {
-  VERSION,
   sleep,
   delay,
   withTimeout,
@@ -3901,6 +2650,10 @@ export {
   getTimeoutForTask,
   estimateTaskComplexity2 as estimateTaskComplexity,
   getTimeoutForTaskAuto,
+  calculateBackoffDelay,
+  isRetryableError,
+  categorizeError,
+  executeCliRetryLoop,
   BaseCliAdapter,
   SubprocessCliAdapter,
   asRecord,
@@ -3908,9 +2661,6 @@ export {
   extractNumberField,
   ClaudeResponseParser,
   ClaudeCliAdapter,
-  CircuitError,
-  CircuitBreakerRegistry,
-  mapCliErrorToCategory,
   GeminiCliAdapter,
   CodexResponseParser,
   CodexCliAdapter,
@@ -3923,23 +2673,6 @@ export {
   createCliAdapter,
   createAllAdapters,
   isCliAvailable,
-  getAvailableClis,
-  STOPWORDS,
-  tokenize,
-  tokenizeFiltered,
-  stringifyValue,
-  capitalize,
-  capitalizeWords,
-  capitalizeKebab,
-  truncateWithInfo,
-  truncateSentence,
-  DEFAULT_TASK_TTL_MS,
-  clampTaskTtl,
-  doctorCommand,
-  initDataDirectories,
-  createServer,
-  connectTransport,
-  startStdioServer,
-  closeServer
+  getAvailableClis
 };
-//# sourceMappingURL=chunk-LKSTILEE.js.map
+//# sourceMappingURL=chunk-4AGPR6XZ.js.map