nexus-agents 2.26.1 → 2.28.0

package/dist/{chunk-ARNVVQ5W.js → chunk-LKSTILEE.js}

@@ -2,30 +2,37 @@ import {
   BACKOFF_CONFIG,
   CLI_SUBPROCESS_TIMEOUTS,
   CLI_TIMEOUTS,
-  CODEX_MCP_TIMEOUTS,
-  getCliTimeout
-} from "./chunk-LCDOP543.js";
-import {
   CLI_VERSION_REQUIREMENTS,
+  CODEX_MCP_TIMEOUTS,
   DEFAULT_CAPABILITIES,
   DEFAULT_MODEL_CAPABILITIES,
   DEFAULT_MODEL_PER_CLI,
   ErrorCode,
+  LEARNING_DIR,
   NexusError,
+  OUTCOMES_FILE,
+  RULES_FILE,
   buildModelInfo,
   clampPercent,
+  colors,
   createLogger,
+  detectTaskCategory,
   err,
   getCliModelName,
+  getCliTimeout,
   getDefaultModelForCli,
   getErrorMessage,
+  getOutcomeStore,
   getRandomProvider,
   getTimeProvider,
-  ok
-} from "./chunk-BOWNZMPH.js";
+  isPersistenceEnabled,
+  ok,
+  symbols,
+  writeLine
+} from "./chunk-L2SHSW4T.js";
 
 // src/version.ts
-var VERSION = true ? "2.26.1" : "dev";
+var VERSION = true ? "2.28.0" : "dev";
 
 // src/utils/async-utils.ts
 function sleep(ms) {
@@ -60,7 +67,10 @@ function estimateTaskComplexity(taskDescription) {
     "entire",
     "comprehensive",
     "deep analysis",
-    "system-wide"
+    "system-wide",
+    "security",
+    "audit",
+    "vulnerability"
   ];
   if (complexIndicators.some((indicator) => lower.includes(indicator))) {
     return "complex";
@@ -71,6 +81,30 @@ function estimateTaskComplexity(taskDescription) {
   }
   return "standard";
 }
+var ADAPTIVE_TIMEOUT_MIN_SAMPLES = 10;
+var ADAPTIVE_TIMEOUT_MARGIN = 1.2;
+function computeP95(sorted) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(sorted.length * 0.95) - 1;
+  return sorted[Math.min(idx, sorted.length - 1)];
+}
+function getAdaptiveTimeout(cli, taskDescription, options) {
+  const complexity = estimateTaskComplexity(taskDescription);
+  const staticTimeout = getCliTimeout(cli, complexity);
+  const match = detectTaskCategory(taskDescription);
+  if (match === null) return staticTimeout;
+  const store = options?.store ?? getOutcomeStore();
+  const outcomes = store.query({
+    cli,
+    category: match.category,
+    success: true
+  });
+  if (outcomes.length < ADAPTIVE_TIMEOUT_MIN_SAMPLES) return staticTimeout;
+  const durations = outcomes.map((o) => o.durationMs).sort((a, b) => a - b);
+  const p95 = computeP95(durations);
+  const adaptiveTimeout = Math.round(p95 * ADAPTIVE_TIMEOUT_MARGIN);
+  return Math.max(staticTimeout, adaptiveTimeout);
+}
 
 // src/cli-adapters/cli-timeout-profiles.ts
 var CLI_TIMEOUT_PROFILES = {
@@ -86,8 +120,7 @@ function estimateTaskComplexity2(taskDescription) {
   return estimateTaskComplexity(taskDescription);
 }
 function getTimeoutForTaskAuto(cli, taskDescription) {
-  const complexity = estimateTaskComplexity(taskDescription);
-  return getCliTimeout(cli, complexity);
+  return getAdaptiveTimeout(cli, taskDescription);
 }
 
 // src/cli-adapters/base-adapter.ts
@@ -227,6 +260,7 @@ function createCapacityTracker(cli) {
 
 // src/cli-adapters/base-adapter.ts
 var execAsync = promisify(exec);
+var DEFAULT_CAPACITY_FALLBACK = 1e5;
 var DEFAULT_OPTIONS = {
   timeoutMs: 6e4,
   // 1 minute (reduced from 2 minutes per Issue #280)
@@ -242,8 +276,8 @@ var BaseCliAdapter = class {
   initialized = false;
   lastHealthCheck;
   cachedVersion;
-  constructor(logger2) {
-    this.logger = logger2 ?? createLogger({ component: "cli-adapter" });
+  constructor(logger6) {
+    this.logger = logger6 ?? createLogger({ component: "cli-adapter" });
   }
   /**
    * Initializes the capacity tracker.
@@ -385,9 +419,13 @@ var BaseCliAdapter = class {
    */
   getCapacity() {
     if (this.capacityTracker === null) {
+      this.logger.warn("Capacity tracker uninitialized, returning default fallback", {
+        cli: this.name,
+        fallbackTokens: DEFAULT_CAPACITY_FALLBACK
+      });
       return Promise.resolve({
-        remainingTokens: Number.MAX_SAFE_INTEGER,
-        remainingRequests: Number.MAX_SAFE_INTEGER,
+        remainingTokens: DEFAULT_CAPACITY_FALLBACK,
+        remainingRequests: DEFAULT_CAPACITY_FALLBACK,
         resetTime: new Date(getTimeProvider().now() + 36e5),
         utilizationPercent: 0,
         exhausted: false
@@ -493,19 +531,145 @@ function isRateLimitOutput(stdout) {
   const lower = stdout.toLowerCase();
   return RATE_LIMIT_PATTERNS.some((pattern) => lower.includes(pattern));
 }
+var PLAINTEXT_FALLBACK_MIN_LENGTH = 30;
+function tryPlaintextFallback(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length < PLAINTEXT_FALLBACK_MIN_LENGTH) return null;
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return null;
+  return trimmed;
+}
+var STDERR_ERROR_PATTERNS = [
+  "error:",
+  "fatal:",
+  "panic:",
+  "unhandled",
+  "not found",
+  "invalid model",
+  "authentication",
+  "unauthorized",
+  "permission denied",
+  "connection refused",
+  "econnrefused",
+  "enotfound",
+  "timeout",
+  "failed to connect",
+  "invalid api key",
+  "rate limit",
+  "quota exceeded",
+  "service unavailable"
+];
+function looksLikeErrorStderr(stderr) {
+  const lower = stderr.toLowerCase();
+  return STDERR_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+}
+var STDERR_CONNECTION_PATTERNS = [
+  "connection refused",
+  "econnrefused",
+  "enotfound",
+  "econnreset",
+  "failed to connect",
+  "service unavailable",
+  "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 (STDERR_TIMEOUT_PATTERNS.some((p) => lower.includes(p))) return "TIMEOUT";
+  return "EXECUTION_ERROR";
+}
+var subprocessLogger = createLogger({ component: "subprocess-adapter" });
+var MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "TIMEOUT",
+  "RATE_LIMITED",
+  "CONNECTION_ERROR",
+  "PARSE_ERROR"
+]);
+var TRANSIENT_RETRY_DELAYS_MS = [500, 1e3];
+var MAX_TRANSIENT_RETRIES = TRANSIENT_RETRY_DELAYS_MS.length;
+var MAX_PARSE_RETRIES = 1;
+var TIMEOUT_RETRY_MULTIPLIER = 1.5;
+function isTransientError(code) {
+  return TRANSIENT_ERROR_CODES.has(code);
+}
+var TRANSIENT_EXIT_CODES = /* @__PURE__ */ new Set([137, 143]);
+var EXIT_CODE_SIGNAL_NAMES = {
+  137: "SIGKILL (OOM or killed)",
+  143: "SIGTERM (terminated)"
+};
+function buildSignalExitMessage(code) {
+  const signalName = EXIT_CODE_SIGNAL_NAMES[code];
+  if (signalName !== void 0) return `Process killed by ${signalName}, exit code ${String(code)}`;
+  return `Process exited with code ${String(code)}`;
+}
+function isTransientExitCode(code) {
+  return code !== null && TRANSIENT_EXIT_CODES.has(code);
+}
+function appendBuffered(state, stream, data) {
+  const bytesKey = stream === "stdout" ? "stdoutBytes" : "stderrBytes";
+  const truncKey = stream === "stdout" ? "stdoutTruncated" : "stderrTruncated";
+  if (state[bytesKey] < MAX_BUFFER_BYTES) {
+    state[stream] += data.toString();
+    state[bytesKey] += data.length;
+  } else if (!state[truncKey]) {
+    state[truncKey] = true;
+    subprocessLogger.warn(`${stream} buffer exceeded 10 MB, truncating`);
+  }
+}
 var SubprocessCliAdapter = class extends BaseCliAdapter {
   transport = "subprocess";
+  /** Transient-error retry config. Override in subclass to enable. */
+  transientRetry = { enabled: true };
   /**
-   * Executes a task via subprocess using spawn for proper argument handling.
-   * Using spawn avoids shell escaping issues with multi-line content.
-   * If stdin is provided in command config, it is written to process stdin.
+   * Executes a task via subprocess, with optional transient-error retry.
+   * When `transientRetry.enabled` is true, transient errors (timeout,
+   * rate_limit, connection, parse) are retried with exponential backoff
+   * (500ms, 1000ms). Parse errors get max 1 retry (#1533); others get 2.
    */
   async executeTask(task, options) {
+    const result = await this.spawnSubprocess(task, options);
+    if (result.ok || !this.transientRetry.enabled) return result;
+    if (!isTransientError(result.error.code)) return result;
+    return this.retryTransient(task, options, result, 0);
+  }
+  /**
+   * Retries a transient error with bounded exponential backoff.
+   */
+  async retryTransient(task, options, lastResult, attempt) {
+    const isParseError = !lastResult.ok && lastResult.error.code === "PARSE_ERROR";
+    const maxRetries = isParseError ? MAX_PARSE_RETRIES : MAX_TRANSIENT_RETRIES;
+    if (attempt >= maxRetries) return lastResult;
+    const delayMs = TRANSIENT_RETRY_DELAYS_MS[attempt];
+    const isTimeout = !lastResult.ok && lastResult.error.code === "TIMEOUT";
+    subprocessLogger.debug("Retrying transient error", {
+      cli: this.name,
+      attempt: attempt + 1,
+      delayMs,
+      errorCode: !lastResult.ok ? lastResult.error.code : void 0
+    });
+    await this.delay(delayMs);
+    const retryOptions = isTimeout ? { ...options, timeoutMs: Math.round(options.timeoutMs * TIMEOUT_RETRY_MULTIPLIER) } : options;
+    const result = await this.spawnSubprocess(task, retryOptions);
+    if (result.ok) return result;
+    if (!isTransientError(result.error.code)) return result;
+    return this.retryTransient(task, retryOptions, result, attempt + 1);
+  }
+  /**
+   * Spawns a single subprocess execution (no retry).
+   */
+  spawnSubprocess(task, options) {
     const cmdConfig = this.getCommand(task);
     const startTime = getTimeProvider().now();
     return new Promise((resolve) => {
+      const childEnv = { ...process.env };
+      delete childEnv["CLAUDECODE"];
       const child = spawn(cmdConfig.command, cmdConfig.args, {
-        stdio: ["pipe", "pipe", "pipe"]
+        stdio: ["pipe", "pipe", "pipe"],
+        env: childEnv
       });
       const onProgress = options.onProgress;
       const state = this.setupChildProcessHandlers(
@@ -526,7 +690,15 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
    * Sets up child process event handlers for output collection and error handling.
    */
   setupChildProcessHandlers(child, startTime, timeoutMs, resolve, onProgress) {
-    const state = { stdout: "", stderr: "", resolved: false };
+    const state = {
+      stdout: "",
+      stderr: "",
+      resolved: false,
+      stdoutBytes: 0,
+      stderrBytes: 0,
+      stdoutTruncated: false,
+      stderrTruncated: false
+    };
     const resolveOnce = (result) => {
       if (!state.resolved) {
         state.resolved = true;
@@ -535,35 +707,47 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
     };
     if (child.stdout !== null) {
       child.stdout.on("data", (data) => {
-        state.stdout += data.toString();
+        appendBuffered(state, "stdout", data);
         onProgress?.();
       });
     }
     if (child.stderr !== null) {
       child.stderr.on("data", (data) => {
-        state.stderr += data.toString();
+        appendBuffered(state, "stderr", data);
       });
     }
     child.on("error", (error) => {
       resolveOnce(this.handleSubprocessError(error));
     });
-    child.on("close", (code) => {
-      if (code !== 0 && state.stdout === "") {
-        const msg = state.stderr !== "" ? state.stderr : `Process exited with code ${String(code)}`;
-        resolveOnce(err(this.createError("EXECUTION_ERROR", msg)));
-        return;
-      }
-      resolveOnce(this.handleSubprocessOutput(state.stdout, state.stderr, startTime));
-    });
     const timeoutId = setTimeout(() => {
       child.kill("SIGTERM");
       resolveOnce(err(this.createError("TIMEOUT", "Execution timed out")));
     }, timeoutMs);
-    child.on("close", () => {
+    child.on("close", (code) => {
       clearTimeout(timeoutId);
+      resolveOnce(this.classifyCloseResult(code, state, startTime));
     });
     return state;
   }
+  /** Classify a subprocess close event into a Result. */
+  classifyCloseResult(code, state, startTime) {
+    if (code !== 0 && state.stdout === "") {
+      if (state.stderr !== "") {
+        const msg2 = state.stderr;
+        return err(this.createError(classifyStderrError(state.stderr), msg2));
+      }
+      const msg = code !== null ? buildSignalExitMessage(code) : "Process exited with unknown code";
+      if (isTransientExitCode(code)) {
+        return err(this.createError("CONNECTION_ERROR", msg));
+      }
+      return err(this.createError("EXECUTION_ERROR", msg));
+    }
+    if (code !== 0 && state.stderr !== "" && looksLikeErrorStderr(state.stderr)) {
+      const msg = `Exit code ${String(code)}: ${state.stderr.slice(0, 500).trim()}`;
+      return err(this.createError(classifyStderrError(state.stderr), msg));
+    }
+    return this.handleSubprocessOutput(state.stdout, state.stderr, startTime);
+  }
   /**
    * Handles successful subprocess output.
    */
@@ -574,11 +758,24 @@ var SubprocessCliAdapter = class extends BaseCliAdapter {
     const text = this.parser.extractResponse(stdout);
     if (text === null) {
       if (isRateLimitOutput(stdout)) {
-        const snippet2 = stdout.slice(0, 200).trim();
+        const snippet2 = stdout.slice(0, 500).trim();
         return err(this.createError("RATE_LIMITED", snippet2));
       }
-      const snippet = stdout.slice(0, 200).trim();
-      return err(this.createError("PARSE_ERROR", `Failed to parse response: ${snippet}`));
+      const plaintext = tryPlaintextFallback(stdout);
+      if (plaintext !== null) {
+        subprocessLogger.debug("Using plaintext fallback for unparseable output");
+        return ok(
+          this.normalizeResponse(plaintext, void 0, {
+            durationMs: getTimeProvider().now() - startTime,
+            raw: stdout
+          })
+        );
+      }
+      const snippet = stdout.slice(0, 500).trim();
+      const stderrHint = stderr !== "" ? ` [stderr: ${stderr.slice(0, 300).trim()}]` : "";
+      return err(
+        this.createError("PARSE_ERROR", `Failed to parse response: ${snippet}${stderrHint}`)
+      );
     }
     const usage = this.parser.extractUsage(stdout);
     const sessionId = this.parser.extractSessionId(stdout);
@@ -642,6 +839,7 @@ function extractNumberField(record, key) {
 }
 
 // src/cli-adapters/parsers/claude-parser.ts
+var logger = createLogger({ component: "claude-parser" });
 var ClaudeResponseParser = class {
   name = "claude-parser";
   supportedVersionRange = ">=2.0.0 <3.0.0";
@@ -656,6 +854,7 @@ var ClaudeResponseParser = class {
       }
       return data;
     } catch {
+      logger.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -677,6 +876,7 @@ var ClaudeResponseParser = class {
       }
       return null;
     } catch {
+      logger.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -703,6 +903,7 @@ var ClaudeResponseParser = class {
         ...cachedInputTokens !== null && { cachedInputTokens }
       };
     } catch {
+      logger.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -720,6 +921,7 @@ var ClaudeResponseParser = class {
       }
       return null;
     } catch {
+      logger.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -743,6 +945,7 @@ function buildClaudeAliasMap() {
     }
   }
   map["claude-sonnet-4"] = "sonnet";
+  map["claude-sonnet-4-6"] = "sonnet";
   map["claude-sonnet-4-5-20250929"] = "sonnet";
   map["claude-opus-4"] = "opus";
   map["claude-opus-4-6"] = "opus";
@@ -808,6 +1011,20 @@ var ClaudeCliAdapter = class extends SubprocessCliAdapter {
       costPerMillionOutput: CLAUDE_LEGACY_DEFAULTS.outputCosts[this.model] ?? CLAUDE_LEGACY_DEFAULTS.outputCost
     };
   }
+  /** Appends optional string-type task options to CLI args. */
+  appendTaskOptions(args, task) {
+    const workDir = task.options?.["workDir"];
+    if (typeof workDir === "string" && workDir.length > 0) {
+      args.push("--add-dir", workDir);
+    }
+    const mcpConfigPath = task.options?.["mcpConfigPath"];
+    if (typeof mcpConfigPath === "string" && mcpConfigPath.length > 0) {
+      args.push("--mcp-config", mcpConfigPath);
+    }
+    if (task.options?.["skipPermissions"] === true) {
+      args.push("--dangerously-skip-permissions");
+    }
+  }
   /**
    * Gets CLI command and arguments for execution.
    * Uses stdin for the prompt to avoid argument escaping issues,
@@ -824,10 +1041,7 @@ var ClaudeCliAdapter = class extends SubprocessCliAdapter {
     if (task.sessionId !== void 0 && task.sessionId !== "") {
       args.push("--resume", task.sessionId);
     }
-    const workDir = task.options?.["workDir"];
-    if (typeof workDir === "string" && workDir.length > 0) {
-      args.push("--add-dir", workDir);
-    }
+    this.appendTaskOptions(args, task);
     return { command: "claude", args, stdin: task.content };
   }
 };
@@ -1133,12 +1347,20 @@ var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
   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"];
+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));
@@ -1325,6 +1547,7 @@ var CliCircuitBreaker = class {
   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) {
@@ -1678,6 +1901,7 @@ var GeminiCliAdapter = class extends SubprocessCliAdapter {
 };
 
 // src/cli-adapters/parsers/codex-parser.ts
+var logger2 = createLogger({ component: "codex-parser" });
 var CodexResponseParser = class {
   name = "codex-parser";
   supportedVersionRange = ">=0.70.0 <1.0.0";
@@ -1728,8 +1952,8 @@ var CodexResponseParser = class {
         const usage = this.extractUsageFromEvent(record);
         if (usage !== null) setUsage(usage);
       }
-    } catch (lineErr) {
-      void lineErr;
+    } catch {
+      logger2.debug("Skipped malformed NDJSON line", { snippet: line.slice(0, 100) });
     }
   }
   /**
@@ -1758,6 +1982,7 @@ var CodexResponseParser = class {
           return this.extractUsageFromEvent(record);
         }
       } catch {
+        logger2.debug("Skipped malformed NDJSON line", { snippet: line.slice(0, 100) });
         continue;
       }
     }
@@ -1781,6 +2006,7 @@ var CodexResponseParser = class {
           }
         }
       } catch {
+        logger2.debug("Skipped malformed NDJSON line", { snippet: line.slice(0, 100) });
         continue;
       }
     }
@@ -2073,7 +2299,18 @@ var CodexMcpAdapter = class extends BaseCliAdapter {
   }
 };
 
+// src/cli-adapters/adapters/opencode-adapter.ts
+import { execFile } from "child_process";
+
 // src/cli-adapters/parsers/opencode-parser.ts
+var logger3 = createLogger({ component: "opencode-parser" });
+var PLAINTEXT_MIN_LENGTH = 10;
+function looksLikeNdjson(text) {
+  const lines = text.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length === 0) return false;
+  const jsonLineCount = lines.filter((l) => l.trimStart().startsWith("{")).length;
+  return jsonLineCount > lines.length / 2;
+}
 var OpenCodeResponseParser = class {
   name = "opencode-parser";
   supportedVersionRange = ">=1.0.0 <2.0.0";
@@ -2082,22 +2319,53 @@ var OpenCodeResponseParser = class {
    */
   parse(raw) {
     const lines = raw.trim().split("\n");
+    const state = this.processAllLines(lines);
+    if (state.contentParts.length === 0) {
+      return this.handleEmptyContent(raw, lines.length, state);
+    }
+    return this.buildResponse(state.contentParts.join(""), state.sessionId, state.usage);
+  }
+  /** Processes all NDJSON lines and returns aggregated state. */
+  processAllLines(lines) {
     let sessionId;
     const contentParts = [];
     let usage;
-    for (const line of lines) {
-      if (line.trim() === "") continue;
-      this.processLine(
+    let hasStepEvents = false;
+    let hasAnyRecognizedEvent = false;
+    for (let idx = 0; idx < lines.length; idx++) {
+      const line = lines[idx];
+      if (line === void 0 || line.trim() === "") continue;
+      const hadEvent = this.processLine(
         line,
         contentParts,
         (id) => sessionId = id,
-        (u) => usage = u
+        (u) => usage = u,
+        idx
+      );
+      if (hadEvent) hasStepEvents = true;
+      if (hadEvent || this.isRecognizedLegacyEvent(line)) hasAnyRecognizedEvent = true;
+    }
+    return { sessionId, contentParts, usage, hasStepEvents, hasAnyRecognizedEvent };
+  }
+  /** Handles the case where no text content was extracted from NDJSON. */
+  handleEmptyContent(raw, lineCount, state) {
+    if (state.hasStepEvents) {
+      return this.buildResponse(
+        "[Tool-only response \u2014 no text output]",
+        state.sessionId,
+        state.usage
       );
     }
-    if (contentParts.length === 0) {
-      return this.parsePlainJson(raw);
-    }
-    const content = contentParts.join("");
+    logger3.debug("No NDJSON content extracted, trying JSON fallback", {
+      rawLength: raw.length,
+      lineCount,
+      hasStepEvents: state.hasStepEvents,
+      hasAnyRecognizedEvent: state.hasAnyRecognizedEvent
+    });
+    return this.parsePlainJson(raw, state.hasAnyRecognizedEvent);
+  }
+  /** Builds an OpenCodeCliResponse from parsed components. */
+  buildResponse(content, sessionId, usage) {
     return {
       content,
       ...sessionId !== void 0 && { sessionId },
@@ -2110,6 +2378,11 @@ var OpenCodeResponseParser = class {
   extractResponse(raw) {
     const parsed = this.parse(raw);
     if (parsed === null || parsed.content === "") {
+      logger3.debug("extractResponse returned null", {
+        rawLength: raw.length,
+        snippet: raw.slice(0, 100),
+        parsedNull: parsed === null
+      });
       return null;
     }
     return parsed.content;
@@ -2167,41 +2440,73 @@ var OpenCodeResponseParser = class {
   /**
    * Processes a single NDJSON line.
    * Handles both real v1.2.x format and legacy assumed format.
+   * Returns true if a real v1.2.x step event was processed (step_start/text/tool_use/step_finish).
+   * Legacy events return false since they don't indicate tool-only responses.
    */
-  processLine(line, contentParts, setSessionId, setUsage) {
+  processLine(line, contentParts, setSessionId, setUsage, lineIndex) {
     try {
       const record = asRecord(JSON.parse(line));
-      if (record === null) return;
-      switch (record.type) {
-        // --- Real opencode v1.2.x event types ---
-        case "step_start":
-          this.handleRealSessionId(record, setSessionId);
-          break;
-        case "text":
-          this.handleRealSessionId(record, setSessionId);
-          this.pushRealTextContent(record, contentParts);
-          break;
-        case "step_finish":
-          this.handleRealSessionId(record, setSessionId);
-          this.emitRealUsage(record, setUsage);
-          break;
-        // --- Legacy assumed event types ---
-        case "session.start":
-          this.handleLegacySessionStart(record, setSessionId);
-          break;
-        case "message.delta":
-          this.pushLegacyTextContent(record, contentParts);
-          break;
-        case "message.complete":
-          this.pushLegacyTextContent(record, contentParts);
-          this.emitLegacyUsage(record, setUsage);
-          break;
-        case "session.complete":
-          this.emitLegacyUsage(record, setUsage);
-          break;
-      }
-    } catch (lineErr) {
-      void lineErr;
+      if (record === null) return false;
+      const isReal = this.processRealEvent(record, contentParts, setSessionId, setUsage);
+      if (isReal) return true;
+      this.processLegacyEvent(record, contentParts, setSessionId, setUsage);
+      return false;
+    } catch {
+      logger3.debug("Skipped malformed NDJSON line", {
+        lineNumber: lineIndex + 1,
+        snippet: line.slice(0, 100)
+      });
+      return false;
+    }
+  }
+  /** Processes real opencode v1.2.x event types. Returns true if handled. */
+  processRealEvent(record, contentParts, setSessionId, setUsage) {
+    switch (record.type) {
+      case "step_start":
+      case "tool_use":
+        this.handleRealSessionId(record, setSessionId);
+        return true;
+      case "text":
+        this.handleRealSessionId(record, setSessionId);
+        this.pushRealTextContent(record, contentParts);
+        return true;
+      case "step_finish":
+        this.handleRealSessionId(record, setSessionId);
+        this.emitRealUsage(record, setUsage);
+        return true;
+      case "error":
+        this.handleRealSessionId(record, setSessionId);
+        this.pushErrorContent(record, contentParts);
+        return true;
+      default:
+        return false;
+    }
+  }
+  /** Extracts error message from error event (#1402). */
+  pushErrorContent(record, parts) {
+    const errorObj = asRecord(record.error);
+    if (errorObj === null) return;
+    const data = asRecord(errorObj.data);
+    const message = data !== null && typeof data.message === "string" ? data.message : typeof errorObj.name === "string" ? errorObj.name : "Unknown error";
+    logger3.warn("OpenCode returned error event", { message });
+    parts.push(`[OpenCode error: ${message}]`);
+  }
+  /** Processes legacy assumed event types. */
+  processLegacyEvent(record, contentParts, setSessionId, setUsage) {
+    switch (record.type) {
+      case "session.start":
+        this.handleLegacySessionStart(record, setSessionId);
+        break;
+      case "message.delta":
+        this.pushLegacyTextContent(record, contentParts);
+        break;
+      case "message.complete":
+        this.pushLegacyTextContent(record, contentParts);
+        this.emitLegacyUsage(record, setUsage);
+        break;
+      case "session.complete":
+        this.emitLegacyUsage(record, setUsage);
+        break;
     }
   }
   // --- Real v1.2.x format handlers ---
@@ -2251,26 +2556,65 @@ var OpenCodeResponseParser = class {
     const usage = this.extractUsageFromRecord(record);
     if (usage !== null) setUsage(usage);
   }
+  /** Checks if a line contains a recognized legacy event type (without full parsing). */
+  isRecognizedLegacyEvent(line) {
+    try {
+      const record = asRecord(JSON.parse(line));
+      if (record === null) return false;
+      const t = record.type;
+      return t === "session.start" || t === "message.start" || t === "message.delta" || t === "message.complete" || t === "session.complete";
+    } catch {
+      return false;
+    }
+  }
   /**
    * Fallback parser for plain JSON output (non-streaming).
+   * Falls back to raw plaintext if JSON parsing fails and content is substantial (#1402).
+   * When hasAnyRecognizedEvent is true, NDJSON-like plaintext is rejected (it was
+   * recognized NDJSON that simply had no content — not malformed output).
    */
-  parsePlainJson(raw) {
+  parsePlainJson(raw, hasAnyRecognizedEvent) {
     try {
       const data = JSON.parse(raw);
       const record = asRecord(data);
-      if (record === null) return null;
+      if (record === null) return this.parsePlaintext(raw, hasAnyRecognizedEvent);
       const content = record.content ?? record.result ?? record.text ?? record.output;
       if (typeof content !== "string") return null;
       const usage = this.extractUsageFromRecord(record);
       const sid = record.session_id ?? record.sessionId;
       return {
         content,
-        ...typeof sid === "string" && { sessionId: sid },
-        ...usage !== null && { usage }
+        ...typeof sid === "string" ? { sessionId: sid } : {},
+        ...usage !== null ? { usage } : {}
       };
     } catch {
+      return this.parsePlaintext(raw, hasAnyRecognizedEvent);
+    }
+  }
+  /**
+   * Last-resort plaintext fallback for non-JSON CLI output (#1402).
+   * Returns raw text as content when it has substantial length.
+   * Accepts NDJSON-like content only when no recognized events were found
+   * (meaning it's truly unrecognized/malformed output, not valid NDJSON with no text).
+   */
+  parsePlaintext(raw, hasAnyRecognizedEvent) {
+    const trimmed = raw.trim();
+    if (trimmed.length < PLAINTEXT_MIN_LENGTH) {
+      logger3.debug("Plaintext fallback rejected: too short", { length: trimmed.length });
       return null;
     }
+    if (looksLikeNdjson(trimmed)) {
+      if (hasAnyRecognizedEvent) {
+        logger3.debug("Plaintext fallback rejected: recognized NDJSON with no content", {
+          length: trimmed.length
+        });
+        return null;
+      }
+      logger3.debug("Plaintext fallback: accepting malformed NDJSON as text", {
+        length: trimmed.length
+      });
+    }
+    return { content: trimmed };
   }
   /**
    * Extracts usage from a record with usage/token fields (legacy format).
@@ -2290,11 +2634,72 @@ var OpenCodeResponseParser = class {
 };
 
 // src/cli-adapters/adapters/opencode-adapter.ts
+var logger4 = createLogger({ component: "opencode-adapter" });
 var ALLOWED_VARIANTS = ["high", "max", "minimal"];
+var MODEL_TO_CLI_NAME = buildOpenCodeAliasMap();
+function buildOpenCodeAliasMap() {
+  const map = {};
+  for (const model of DEFAULT_MODEL_CAPABILITIES.models) {
+    if (model.cliName === "opencode" && model.cliModelName !== void 0) {
+      map[model.id] = model.cliModelName;
+      if (model.cliAlias !== void 0) {
+        map[model.cliAlias] = model.cliModelName;
+      }
+      map[model.cliModelName] = model.cliModelName;
+    }
+  }
+  return map;
+}
+function resolveOpenCodeModel(model) {
+  return MODEL_TO_CLI_NAME[model] ?? model;
+}
+var PROBE_TIMEOUT_MS = 1e4;
+var cachedModels;
+var probePromise;
+function probeAvailableModels() {
+  if (cachedModels !== void 0) return Promise.resolve(cachedModels);
+  if (probePromise !== void 0) return probePromise;
+  probePromise = new Promise((resolve) => {
+    execFile("opencode", ["models"], { timeout: PROBE_TIMEOUT_MS }, (error, stdout) => {
+      if (error !== null || stdout.trim() === "") {
+        logger4.debug("Failed to probe OpenCode models, will omit --model flag", {
+          error: error?.message
+        });
+        cachedModels = /* @__PURE__ */ new Set();
+        resolve(cachedModels);
+        return;
+      }
+      const models = new Set(
+        stdout.trim().split("\n").map((l) => l.trim()).filter((l) => l.length > 0)
+      );
+      logger4.debug("Probed OpenCode models", { count: models.size });
+      cachedModels = models;
+      resolve(cachedModels);
+    });
+  }).finally(() => {
+    probePromise = void 0;
+  });
+  return probePromise;
+}
+var ANTHROPIC_MODEL_PATTERNS = ["anthropic/", "custom/claude"];
+function warnIfAnthropicProvider(models) {
+  const anthropicModels = [...models].filter(
+    (m) => ANTHROPIC_MODEL_PATTERNS.some((p) => m.toLowerCase().includes(p))
+  );
+  if (anthropicModels.length > 0) {
+    logger4.warn(
+      "OpenCode has Anthropic/Claude models configured. Ensure these use a SEPARATE API key from console.anthropic.com, NOT a Claude Code subscription key (which is restricted to Claude Code only).",
+      { detectedModels: anthropicModels }
+    );
+  }
+}
 var OpenCodeCliAdapter = class extends SubprocessCliAdapter {
   name = "opencode";
   parser = new OpenCodeResponseParser();
+  /** Enable transient-error retry for OpenCode (#1456). */
+  transientRetry = { enabled: true };
   model;
+  availableModels;
   constructor(options) {
     super(options?.logger);
     this.model = options?.model ?? getCliModelName(getDefaultModelForCli("opencode"));
@@ -2315,13 +2720,34 @@ var OpenCodeCliAdapter = class extends SubprocessCliAdapter {
     };
   }
   /**
-   * Gets CLI command and arguments for execution.
-   * Uses `opencode run` with JSON format for stable parsing.
+   * Initializes the adapter — probes available models.
+   * Warns if Anthropic provider is configured (#1429 — API key boundaries).
    */
-  getCommand(task) {
-    const args = ["run", "--format", "json"];
+  async initialize() {
+    this.availableModels = await probeAvailableModels();
+    warnIfAnthropicProvider(this.availableModels);
+    await super.initialize();
+  }
+  /** Returns true if the model is available in the OpenCode installation. */
+  isModelAvailable(cliModel) {
+    if (this.availableModels === void 0 || this.availableModels.size === 0) return false;
+    return this.availableModels.has(cliModel);
+  }
+  /** Appends --model if the resolved model is available (#1402). */
+  appendModelArg(args, task) {
     const internalModel = task.model ?? this.model;
-    args.push("--model", internalModel);
+    const cliModel = resolveOpenCodeModel(internalModel);
+    if (this.isModelAvailable(cliModel)) {
+      args.push("--model", cliModel);
+    } else {
+      logger4.debug("Model not available, using OpenCode default", {
+        requested: cliModel,
+        available: this.availableModels?.size ?? 0
+      });
+    }
+  }
+  /** Appends optional task flags (workDir, variant, thinking). */
+  appendTaskFlags(args, task) {
     const workDir = task.options?.["workDir"];
     if (typeof workDir === "string" && workDir.length > 0) {
       args.push("--dir", workDir);
@@ -2333,8 +2759,17 @@ var OpenCodeCliAdapter = class extends SubprocessCliAdapter {
     if (task.options?.["thinking"] === true) {
       args.push("--thinking");
     }
-    args.push(task.content);
-    return { command: "opencode", args };
+  }
+  /**
+   * Gets CLI command and arguments for execution.
+   * Uses `opencode run` with JSON format for stable parsing.
+   * Omits --model when the requested model isn't available (#1402).
+   */
+  getCommand(task) {
+    const args = ["run", "--format", "json"];
+    this.appendModelArg(args, task);
+    this.appendTaskFlags(args, task);
+    return { command: "opencode", args, stdin: task.content };
   }
 };
 
@@ -2344,13 +2779,19 @@ var CliDetectionCacheConfigSchema = z.object({
   ttlMs: z.number().min(1e3).max(36e5).default(3e5)
 });
 var DEFAULT_CACHE_CONFIG = {
-  ttlMs: 3e5
+  ttlMs: 3e5,
   // 5 minutes
+  adaptiveTtl: true
 };
+var ADAPTIVE_MULTIPLIER_HEALTHY = 2;
+var ADAPTIVE_MULTIPLIER_UNHEALTHY = 0.25;
+var ADAPTIVE_STREAK_THRESHOLD = 2;
 var CliDetectionCache = class {
   config;
   logger;
   cache = /* @__PURE__ */ new Map();
+  /** Consecutive same-health-status count per CLI (for adaptive TTL). */
+  streaks = /* @__PURE__ */ new Map();
   hits = 0;
   misses = 0;
   lastReset = new Date(getTimeProvider().now());
@@ -2358,7 +2799,11 @@ var CliDetectionCache = class {
     const validated = CliDetectionCacheConfigSchema.parse({
       ttlMs: config?.ttlMs ?? DEFAULT_CACHE_CONFIG.ttlMs
     });
-    this.config = { ...validated, logger: config?.logger };
+    this.config = {
+      ...validated,
+      adaptiveTtl: config?.adaptiveTtl ?? DEFAULT_CACHE_CONFIG.adaptiveTtl,
+      logger: config?.logger
+    };
     this.logger = config?.logger ?? createLogger({ component: "CliDetectionCache" });
     this.logger.debug("CliDetectionCache initialized", { ttlMs: this.config.ttlMs });
   }
@@ -2380,6 +2825,7 @@ var CliDetectionCache = class {
   }
   set(cli, result) {
     this.cache.set(cli, result);
+    this.updateStreak(cli, result.healthy);
     this.logger.debug("Cache updated", {
       cli,
       healthy: result.healthy,
@@ -2390,14 +2836,34 @@ var CliDetectionCache = class {
     const result = this.cache.get(cli);
     if (result === void 0) return true;
     const age = getTimeProvider().now() - result.checkedAt.getTime();
-    return age > this.config.ttlMs;
+    return age > this.getEffectiveTtl(cli);
+  }
+  /** Returns the effective TTL for a CLI, applying adaptive multiplier if enabled. */
+  getEffectiveTtl(cli) {
+    if (this.config.adaptiveTtl === false) return this.config.ttlMs;
+    const streak = this.streaks.get(cli);
+    if (streak === void 0 || streak.count < ADAPTIVE_STREAK_THRESHOLD) {
+      return this.config.ttlMs;
+    }
+    const multiplier = streak.healthy ? ADAPTIVE_MULTIPLIER_HEALTHY : ADAPTIVE_MULTIPLIER_UNHEALTHY;
+    return this.config.ttlMs * multiplier;
+  }
+  updateStreak(cli, healthy) {
+    const prev = this.streaks.get(cli);
+    if (prev?.healthy === healthy) {
+      this.streaks.set(cli, { healthy, count: prev.count + 1 });
+    } else {
+      this.streaks.set(cli, { healthy, count: 1 });
+    }
   }
   invalidate(cli) {
     if (cli !== void 0) {
       this.cache.delete(cli);
+      this.streaks.delete(cli);
       this.logger.info("Cache invalidated", { cli });
     } else {
       this.cache.clear();
+      this.streaks.clear();
       this.logger.info("Cache cleared");
     }
   }
@@ -2467,9 +2933,9 @@ function createCodexAdapter(transport, options) {
   }
   return new CodexMcpAdapter(options);
 }
-function createAllAdapters(logger2, codexTransport = "mcp") {
+function createAllAdapters(logger6, codexTransport = "mcp") {
   const adapters = /* @__PURE__ */ new Map();
-  const options = logger2 !== void 0 ? { logger: logger2 } : void 0;
+  const options = logger6 !== void 0 ? { logger: logger6 } : void 0;
   adapters.set("claude", new ClaudeCliAdapter(options));
   adapters.set("gemini", new GeminiCliAdapter(options));
   adapters.set("codex", createCodexAdapter(codexTransport, options ?? {}));
@@ -2513,6 +2979,16 @@ 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";
@@ -2523,13 +2999,13 @@ var MAX_TASK_TTL_MS = 6e5;
 var DEFAULT_TASK_TTL_MS = 3e5;
 var MAX_TASK_CAPACITY = 50;
 var CLEANUP_INTERVAL_MS = 6e4;
-var logger = createLogger({ component: "task-store" });
+var logger5 = createLogger({ component: "task-store" });
 var singletonStore;
 var cleanupTimer;
 function getTaskStore() {
   if (singletonStore === void 0) {
     singletonStore = new InMemoryTaskStore();
-    logger.info("Task store created", { maxCapacity: MAX_TASK_CAPACITY });
+    logger5.info("Task store created", { maxCapacity: MAX_TASK_CAPACITY });
     cleanupTimer = setInterval(() => {
       evictExcessTasks();
     }, CLEANUP_INTERVAL_MS);
@@ -2544,7 +3020,7 @@ function clampTaskTtl(requestedTtl) {
     return DEFAULT_TASK_TTL_MS;
   }
   if (requestedTtl > MAX_TASK_TTL_MS) {
-    logger.warn("Task TTL clamped to maximum", {
+    logger5.warn("Task TTL clamped to maximum", {
       requested: requestedTtl,
       max: MAX_TASK_TTL_MS
     });
@@ -2564,13 +3040,13 @@ function evictExcessTasks() {
     const task = sorted[i];
     if (task === void 0) continue;
     singletonStore.updateTaskStatus(task.taskId, "cancelled", "Evicted: capacity exceeded").catch((err2) => {
-      logger.debug("Failed to evict task", {
+      logger5.debug("Failed to evict task", {
         taskId: task.taskId,
         error: String(err2)
       });
     });
   }
-  logger.info("Evicted excess tasks", { evicted: evictCount, total: sorted.length });
+  logger5.info("Evicted excess tasks", { evicted: evictCount, total: sorted.length });
 }
 
 // src/mcp/server.ts
@@ -2585,9 +3061,10 @@ function createServerError(code, message, error) {
 function createServer(config) {
   const serverName = config?.name ?? DEFAULT_SERVER_NAME;
   const serverVersion = config?.version ?? VERSION;
-  const logger2 = config?.logger ?? createLogger({ component: "mcp-server" });
+  const logger6 = config?.logger ?? createLogger({ component: "mcp-server" });
   try {
-    logger2.info("Creating MCP server", {
+    initDataDirectories();
+    logger6.info("Creating MCP server", {
       name: serverName,
       version: serverVersion
     });
@@ -2606,11 +3083,11 @@ function createServer(config) {
         taskStore: getTaskStore()
       }
     );
-    logger2.debug("MCP server created successfully");
-    return ok({ server, logger: logger2 });
+    logger6.debug("MCP server created successfully");
+    return ok({ server, logger: logger6 });
   } catch (error) {
     const errorMessage = getErrorMessage(error);
-    logger2.error("Failed to create MCP server", error instanceof Error ? error : void 0);
+    logger6.error("Failed to create MCP server", error instanceof Error ? error : void 0);
     return err(
       createServerError(
         "SERVER_CREATION_FAILED",
@@ -2620,8 +3097,8 @@ function createServer(config) {
     );
   }
 }
-async function connectTransport(server, transport, logger2) {
-  const log = logger2 ?? createLogger({ component: "mcp-server" });
+async function connectTransport(server, transport, logger6) {
+  const log = logger6 ?? createLogger({ component: "mcp-server" });
   try {
     log.info("Connecting server to transport");
     await server.connect(transport);
@@ -2644,19 +3121,19 @@ async function startStdioServer(config) {
   if (!serverResult.ok) {
     return serverResult;
   }
-  const { server, logger: logger2 } = serverResult.value;
+  const { server, logger: logger6 } = serverResult.value;
   try {
-    logger2.info("Starting stdio transport");
+    logger6.info("Starting stdio transport");
     const transport = new StdioServerTransport();
-    const connectResult = await connectTransport(server, transport, logger2);
+    const connectResult = await connectTransport(server, transport, logger6);
     if (!connectResult.ok) {
       return connectResult;
     }
-    logger2.info("MCP server running with stdio transport");
-    return ok({ server, logger: logger2 });
+    logger6.info("MCP server running with stdio transport");
+    return ok({ server, logger: logger6 });
   } catch (error) {
     const errorMessage = getErrorMessage(error);
-    logger2.error("Failed to start stdio server", error instanceof Error ? error : void 0);
+    logger6.error("Failed to start stdio server", error instanceof Error ? error : void 0);
     return err(
       createServerError(
         "SERVER_START_FAILED",
@@ -2666,8 +3143,8 @@ async function startStdioServer(config) {
     );
   }
 }
-async function closeServer(server, logger2) {
-  const log = logger2 ?? createLogger({ component: "mcp-server" });
+async function closeServer(server, logger6) {
+  const log = logger6 ?? createLogger({ component: "mcp-server" });
   try {
     log.info("Closing MCP server");
     await server.close();
@@ -2797,6 +3274,623 @@ function truncateSentence(text, maxLength = 150) {
   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,
@@ -2841,9 +3935,11 @@ export {
   truncateSentence,
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl,
+  doctorCommand,
+  initDataDirectories,
   createServer,
   connectTransport,
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-ARNVVQ5W.js.map
+//# sourceMappingURL=chunk-LKSTILEE.js.map