nexus-agents 4.14.0 → 4.14.2

package/dist/chunk-WMSWVHFZ.js

@@ -0,0 +1,1240 @@
+import {
+  readOpenAICompatEnv
+} from "./chunk-UZRVS7MK.js";
+import {
+  allOf
+} from "./chunk-OQB3XC5O.js";
+import {
+  capitalize
+} from "./chunk-6T3EPABN.js";
+import {
+  createAllAdapters,
+  probeCli
+} from "./chunk-GFCCNGI7.js";
+import {
+  getNexusTmpDir
+} from "./chunk-RQV5ZUXT.js";
+import {
+  DEFAULT_CAPABILITIES,
+  colors,
+  createLogger,
+  err,
+  getErrorMessage,
+  getInTreeCapabilitiesMatrix,
+  getTimeProvider,
+  ok,
+  symbols,
+  writeLine
+} from "./chunk-2RSNO5SP.js";
+import {
+  getLearningDir,
+  getOutcomesFile,
+  getRulesFile,
+  isPersistenceEnabled
+} from "./chunk-HHLCAWAV.js";
+import {
+  detectSandbox,
+  getNexusDataDir,
+  getNexusRepoDir,
+  getPerRepoSubdirs,
+  nexusDataPath
+} from "./chunk-NBMWONHE.js";
+
+// src/cli/setup-data-dir.ts
+import { mkdirSync, existsSync as existsSync3 } from "fs";
+
+// src/cli/doctor.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  accessSync,
+  constants as fsConstants
+} from "fs";
+
+// src/cli/doctor-scratch-space.ts
+import { statSync, statfsSync } from "fs";
+import { tmpdir } from "os";
+var MIB = 1024 * 1024;
+var GIB = 1024 * 1024 * 1024;
+var CRITICAL_FREE_BYTES = 512 * MIB;
+var WARN_FREE_BYTES = 2 * GIB;
+function formatBytes(bytes) {
+  if (bytes >= GIB) return `${(bytes / GIB).toFixed(1)} GiB`;
+  return `${(bytes / MIB).toFixed(0)} MiB`;
+}
+function grade(freeBytes) {
+  if (freeBytes < CRITICAL_FREE_BYTES) return "critical";
+  if (freeBytes < WARN_FREE_BYTES) return "warn";
+  return "ok";
+}
+function checkScratchSpace(root = getNexusTmpDir(), statfs = statfsSync, label = "nexus") {
+  let reading;
+  try {
+    reading = statfs(root);
+  } catch {
+    return {
+      label,
+      root,
+      available: false,
+      freeBytes: 0,
+      totalBytes: 0,
+      percentUsed: 0,
+      severity: "ok",
+      message: `Scratch filesystem at ${root} could not be read (statfs unavailable)`
+    };
+  }
+  const totalBytes = reading.blocks * reading.bsize;
+  const freeBytes = reading.bavail * reading.bsize;
+  const percentUsed = totalBytes > 0 ? Math.round((totalBytes - freeBytes) / totalBytes * 100) : 100;
+  const severity = grade(freeBytes);
+  return {
+    label,
+    root,
+    available: true,
+    freeBytes,
+    totalBytes,
+    percentUsed,
+    severity,
+    message: `${formatBytes(freeBytes)} free of ${formatBytes(totalBytes)} (${String(percentUsed)}% used)`
+  };
+}
+var SEVERITY_ORDER = ["ok", "warn", "critical"];
+function defaultRoots() {
+  return [
+    { label: "nexus", root: getNexusTmpDir() },
+    { label: "system", root: tmpdir() }
+  ];
+}
+function checkScratchFilesystems(options = {}) {
+  const roots = options.roots ?? defaultRoots();
+  const statfs = options.statfs ?? statfsSync;
+  const deviceOf = options.deviceOf ?? ((path) => statSync(path).dev);
+  const seen = /* @__PURE__ */ new Set();
+  const checks = [];
+  for (const { label, root } of roots) {
+    let device;
+    try {
+      device = deviceOf(root);
+    } catch {
+      continue;
+    }
+    if (seen.has(device)) continue;
+    seen.add(device);
+    checks.push(checkScratchSpace(root, statfs, label));
+  }
+  return checks;
+}
+function worstSeverity(checks) {
+  return checks.reduce(
+    (worst, check) => SEVERITY_ORDER.indexOf(check.severity) > SEVERITY_ORDER.indexOf(worst) ? check.severity : worst,
+    "ok"
+  );
+}
+function formatScratchFilesystems(checks) {
+  if (checks.length === 0) {
+    return "  \u26A0 Scratch space: no scratch filesystem could be identified";
+  }
+  return checks.map(formatScratchSpace).join("\n");
+}
+function formatScratchSpace(check) {
+  if (!check.available) {
+    return `  \u26A0 Scratch space [${check.label}]: ${check.message}`;
+  }
+  const icon = check.severity === "ok" ? "\u2713" : check.severity === "warn" ? "\u26A0" : "\u2717";
+  const line = `  ${icon} Scratch space [${check.label}] (${check.root}): ${check.message}`;
+  if (check.severity === "ok") return line;
+  return [
+    line,
+    "    A full scratch filesystem fails subprocesses at the write step, after",
+    "    they have done their work, so output is lost rather than refused.",
+    "    Free space, or point NEXUS_TMPDIR at a roomier filesystem."
+  ].join("\n");
+}
+function scratchSeverityIsAcceptable(severity) {
+  switch (severity) {
+    case "ok":
+    case "warn":
+      return true;
+    case "critical":
+      return false;
+    default: {
+      const exhaustive = severity;
+      throw new Error(`Unhandled scratch severity: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/version.ts
+var VERSION = true ? "4.14.2" : "dev";
+
+// 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 logger = 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 });
+    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) {
+    logger.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) => {
+      logger.debug("Failed to evict task", {
+        taskId: task.taskId,
+        error: String(err2)
+      });
+    });
+  }
+  logger.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 logger2 = config?.logger ?? createLogger({ component: "mcp-server" });
+  try {
+    initDataDirectories();
+    logger2.info("Creating MCP server", {
+      name: serverName,
+      version: serverVersion
+    });
+    const server = new McpServer(
+      {
+        name: serverName,
+        version: serverVersion
+      },
+      {
+        capabilities: {
+          logging: {},
+          prompts: {},
+          resources: {},
+          tasks: {}
+        },
+        taskStore: getTaskStore()
+      }
+    );
+    logger2.debug("MCP server created successfully");
+    return ok({ server, logger: logger2 });
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    logger2.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, logger2) {
+  const log = logger2 ?? 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: logger2 } = serverResult.value;
+  try {
+    logger2.setDestination?.("stderr");
+    logger2.info("Starting stdio transport");
+    const transport = new StdioServerTransport();
+    const connectResult = await connectTransport(server, transport, logger2);
+    if (!connectResult.ok) {
+      return connectResult;
+    }
+    logger2.info("MCP server running with stdio transport");
+    return ok({ server, logger: logger2 });
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    logger2.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, logger2) {
+  const log = logger2 ?? 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/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";
+  if (!capacity.observed) {
+    return `${colors.yellow}unknown (no usage observed this session)${colors.reset}`;
+  }
+  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.authState === "authenticated" ? `${colors.green}${cli.authMethod ?? "Authenticated"}${colors.reset}` : cli.authState === "unverified" ? `${colors.yellow}unverified (no non-interactive auth check)${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}Update with 'npm update -g nexus-agents' to pick up the latest registry,${colors.reset}`
+    );
+    writeLine(
+      `  ${colors.dim}or run 'nexus-agents registry refresh' to probe currently-installed models.${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 printDataDirGroup(label, rootHint, subdirs) {
+  if (subdirs.length === 0) return;
+  const existCount = subdirs.filter((d) => d.exists).length;
+  writeLine(
+    `  ${colors.dim}${label} \u2014 ${rootHint} (${String(existCount)}/${String(subdirs.length)})${colors.reset}`
+  );
+  for (const dir of subdirs) {
+    let marker;
+    if (!dir.exists) marker = `${colors.dim}\xB7${colors.reset}`;
+    else if (!dir.writable) marker = `${colors.yellow}!${colors.reset}`;
+    else marker = `${colors.green}\u2713${colors.reset}`;
+    const note = !dir.exists ? ` ${colors.dim}(missing \u2014 created on first use)${colors.reset}` : !dir.writable ? ` ${colors.yellow}(not writable)${colors.reset}` : "";
+    writeLine(`    ${marker} ${dir.name}  ${colors.dim}${dir.path}${colors.reset}${note}`);
+  }
+}
+function printDataDirectory(check) {
+  const allExist = allOf(check.subdirectories, (d) => d.exists, false);
+  const allWritable = allOf(check.subdirectories, (d) => !d.exists || d.writable, false);
+  const healthy = check.rootExists && allWritable;
+  writeLine(`${formatStatus(healthy, !healthy)} Data directory layout:`);
+  const perRepo = check.subdirectories.filter((d) => d.scope === "per-repo");
+  const crossRepo = check.subdirectories.filter((d) => d.scope === "cross-repo");
+  if (check.repoRoot !== null) {
+    printDataDirGroup("Per-repo", check.repoRoot, perRepo);
+  } else {
+    printDataDirGroup("Per-repo (homedir \u2014 repo-preferred off)", check.rootPath, perRepo);
+  }
+  printDataDirGroup("Cross-repo", check.rootPath, crossRepo);
+  if (!allExist) {
+    writeLine(`  ${colors.dim}Fix: nexus-agents setup${colors.reset}`);
+  }
+}
+function printSandboxHeader(check) {
+  if (check.active) {
+    writeLine(`${formatStatus(true)} Sandbox flavor: ${check.flavor ?? "(unknown)"}`);
+    writeLine(`  ${colors.dim}NEXUS_SANDBOX_ROOT: ${check.root ?? "(unset)"}${colors.reset}`);
+    return;
+  }
+  writeLine(
+    `${formatStatus(false, true)} Container detected (${check.heuristicMatch ?? "unknown"}) but ${colors.yellow}NEXUS_SANDBOX is unset${colors.reset}`
+  );
+  writeLine(
+    `  ${colors.dim}Set NEXUS_SANDBOX=<flavor> in the image to opt into sandbox-aware behaviour.${colors.reset}`
+  );
+}
+function printSandboxWarnings(check) {
+  if (check.mismatch && check.active) {
+    writeLine(
+      `  ${colors.yellow}Mismatch: NEXUS_SANDBOX is set but no container heuristic matched (heuristic=${String(check.heuristicMatch)}).${colors.reset}`
+    );
+  }
+  if (check.dataDirInsideRepo) {
+    writeLine(
+      `  ${colors.yellow}NEXUS_DATA_DIR resolves inside a single repo subfolder of NEXUS_SANDBOX_ROOT \u2014 state will be lost when switching repos. Set NEXUS_DATA_DIR at the multi-repo root.${colors.reset}`
+    );
+  }
+}
+function printSandbox(check) {
+  const heuristicSaysContainer = check.heuristicMatch === "docker" || check.heuristicMatch === "podman";
+  if (!check.active && !heuristicSaysContainer) {
+    return;
+  }
+  writeLine(`${colors.cyan}Checking sandbox awareness...${colors.reset}`);
+  writeLine("");
+  printSandboxHeader(check);
+  printSandboxWarnings(check);
+  writeLine("");
+}
+function printDoctorSummary(result) {
+  const unhealthyCount = result.clis.filter((c) => !c.installed || !c.authenticated).length;
+  const nodeIssue = result.nodeVersion.supported ? 0 : 1;
+  const scratchIssue = scratchSeverityIsAcceptable(worstSeverity(result.scratchSpace)) ? 0 : 1;
+  const totalIssues = unhealthyCount + nodeIssue + (result.mcpServerReady ? 0 : 1) + scratchIssue;
+  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 printVoterTransportCheck(check) {
+  if (check.configured) {
+    writeLine(`${formatStatus(true)} Voter transport: In-process gateway`);
+    return;
+  }
+  writeLine(`${formatStatus(true)} Voter transport: ${colors.dim}CLI subprocess${colors.reset}`);
+  writeLine(
+    `  ${colors.dim}Set NEXUS_OPENAI_COMPAT_URL and NEXUS_OPENAI_COMPAT_KEY for faster in-process voting${colors.reset}`
+  );
+}
+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)"}`
+  );
+  printVoterTransportCheck(result.voterTransport);
+  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(formatScratchFilesystems(result.scratchSpace));
+  writeLine("");
+  printSandbox(result.sandbox);
+  printHarnessAlignment(result.harnessAlignment);
+  printDoctorSummary(result);
+}
+function printHarnessAlignment(check) {
+  writeLine(`${colors.cyan}Checking agent-harness alignment...${colors.reset}`);
+  writeLine("");
+  writeLine(
+    `${formatStatus(check.agentsMdExists)} AGENTS.md: ${check.agentsMdExists ? "present (federated surface)" : "MISSING \u2014 federation invariant broken"}`
+  );
+  for (const f of check.files) {
+    if (!f.exists) {
+      writeLine(`  ${colors.gray}\u25CB${colors.reset} ${f.harness}: not present (${f.path})`);
+      continue;
+    }
+    if (f.error !== null) {
+      writeLine(`  ${colors.red}\u2717${colors.reset} ${f.harness}: ${f.error}`);
+      continue;
+    }
+    if (f.redirectsToAgentsMd) {
+      writeLine(`  ${colors.green}\u2713${colors.reset} ${f.harness}: aligned (${f.path})`);
+    } else {
+      writeLine(
+        `  ${colors.yellow}\u26A0${colors.reset} ${f.harness}: drift \u2014 ${f.path} exists but does NOT mention AGENTS.md`
+      );
+    }
+  }
+  writeLine("");
+  writeLine(
+    `  Summary: ${String(check.alignedCount)} aligned, ${String(check.driftCount)} drift, ${String(check.missingCount)} absent`
+  );
+  if (check.driftCount > 0) {
+    writeLine(
+      `  ${colors.yellow}Drift detected.${colors.reset} Per docs/architecture/AGENT_COMPATIBILITY.md, harness configs must redirect to AGENTS.md \u2014 never duplicate content.`
+    );
+  }
+  writeLine("");
+}
+
+// src/cli/doctor-harness-alignment.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var HARNESS_FILES = [
+  { harness: "Cursor", path: ".cursor/rules/agents.mdc" },
+  { harness: "Windsurf", path: ".windsurf/rules/agents.md" },
+  { harness: "Aider", path: ".aider.conf.yml" },
+  { harness: "Continue", path: ".continue/rules/agents.md" },
+  { harness: "Cline", path: ".clinerules/agents.md" },
+  // Gemini CLI reads a root-level GEMINI.md natively (unlike the .rules/-dir
+  // harnesses); it redirects to AGENTS.md per the federation (#3446 Phase 4).
+  { harness: "Gemini", path: "GEMINI.md" }
+];
+function checkHarnessAlignment(cwd = process.cwd()) {
+  const agentsMdPath = join(cwd, "AGENTS.md");
+  const agentsMdExists = existsSync(agentsMdPath);
+  const files = HARNESS_FILES.map(
+    ({ harness, path }) => inspectFile(harness, path, join(cwd, path))
+  );
+  const alignedCount = files.filter((f) => f.exists && f.redirectsToAgentsMd).length;
+  const driftCount = files.filter((f) => f.exists && !f.redirectsToAgentsMd).length;
+  const missingCount = files.filter((f) => !f.exists).length;
+  return {
+    agentsMdExists,
+    files,
+    alignedCount,
+    driftCount,
+    missingCount
+  };
+}
+function inspectFile(harness, relativePath, absolutePath) {
+  if (!existsSync(absolutePath)) {
+    return {
+      harness,
+      path: relativePath,
+      exists: false,
+      redirectsToAgentsMd: false,
+      error: null
+    };
+  }
+  try {
+    const content = readFileSync(absolutePath, "utf-8");
+    return {
+      harness,
+      path: relativePath,
+      exists: true,
+      redirectsToAgentsMd: content.includes("AGENTS.md"),
+      error: null
+    };
+  } catch (error) {
+    return {
+      harness,
+      path: relativePath,
+      exists: true,
+      redirectsToAgentsMd: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// 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/nexus-agents.yaml",
+  "./.nexus-agents/nexus-agents.yml",
+  "./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,
+    // Not installed, so auth was never probed. `not-authenticated` would claim
+    // a determination nobody made; the auth line is not printed for an
+    // uninstalled CLI anyway (#4661).
+    authState: "unverified",
+    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 resolveAuthState(authenticated, probeState) {
+  if (authenticated) return "authenticated";
+  return probeState === "unknown" ? "unverified" : "not-authenticated";
+}
+function createHealthyResult(name, health, authProbe, capacity) {
+  const versionOk = health.healthy;
+  const authenticated = versionOk && authProbe.state === "authenticated";
+  const authState = resolveAuthState(authenticated, authProbe.state);
+  const result = {
+    name,
+    installed: true,
+    version: health.version,
+    versionStatus: health.versionStatus,
+    authenticated,
+    authState,
+    ...authenticated && { authMethod: detectAuthMethod(name) },
+    ...capacity !== void 0 && { capacity }
+  };
+  if (health.message !== void 0 && health.message !== "") {
+    return { ...result, error: health.message };
+  }
+  if (!authenticated && authProbe.state === "needs-login") {
+    return {
+      ...result,
+      error: authProbe.reason,
+      fix: authProbe.fixCommand
+    };
+  }
+  if (authState === "not-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, authProbe] = await Promise.all([adapter.healthCheck(), probeCli(name)]);
+    let capacity;
+    try {
+      capacity = await adapter.getCapacity();
+    } catch (capErr) {
+      void capErr;
+    }
+    return createHealthyResult(name, health, authProbe, 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 (existsSync2(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 matrix = getInTreeCapabilitiesMatrix();
+  const models = matrix.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 = 90;
+  const updatedAt = new Date(matrix.updatedAt);
+  const nowMs = getTimeProvider().now();
+  const ageDays = Math.floor((nowMs - updatedAt.getTime()) / (1e3 * 60 * 60 * 24));
+  const isFreshInstall = !hasPriorUsage();
+  const exceedsThreshold = ageDays > STALE_THRESHOLD_DAYS;
+  return {
+    totalModels: models.length,
+    availableModels: models.filter((m) => m.available).length,
+    unavailableModels: models.filter((m) => !m.available).length,
+    models,
+    registryAgeDays: ageDays,
+    registryStale: exceedsThreshold && !isFreshInstall
+  };
+}
+function hasPriorUsage() {
+  try {
+    const root = getNexusDataDir();
+    if (!existsSync2(root)) return false;
+    for (const sub of ["audit", "learning", "sessions", "voting"]) {
+      const p = `${root}/${sub}`;
+      try {
+        if (existsSync2(p) && readdirSync(p).length > 0) return true;
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function countJsonlLines(filePath) {
+  if (!existsSync2(filePath)) return 0;
+  return readFileSync2(filePath, "utf-8").split("\n").filter((l) => l.trim().length > 0).length;
+}
+function readRulesMetadata(filePath) {
+  if (!existsSync2(filePath)) return { count: 0, savedAt: null };
+  try {
+    const raw = JSON.parse(readFileSync2(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 = existsSync2(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(getLearningDir());
+    const outcomeCount = countJsonlLines(getOutcomesFile());
+    const { count: ruleCount, savedAt: rulesLastSaved } = readRulesMetadata(getRulesFile());
+    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 = getNexusDataDir();
+  const rootExists = existsSync2(rootPath);
+  const repoRoot = getNexusRepoDir();
+  const perRepoSet = getPerRepoSubdirs();
+  const subdirectories = DATA_SUBDIRECTORIES.map((name) => {
+    const segments = name.split("/");
+    const fullPath = nexusDataPath(...segments);
+    const exists = existsSync2(fullPath);
+    const scope = perRepoSet.has(segments[0] ?? "") ? "per-repo" : "cross-repo";
+    return { name, path: fullPath, scope, exists, writable: exists && isWritable(fullPath) };
+  });
+  return { rootExists, rootPath, repoRoot, subdirectories };
+}
+function isWritable(dirPath) {
+  try {
+    accessSync(dirPath, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkSandbox() {
+  const info = detectSandbox();
+  const dataDir = getNexusDataDir();
+  const root = info.root;
+  const dataDirInsideRepo = info.active && root !== void 0 && dataDir.startsWith(`${root.replace(/\/$/, "")}/`) && // path segments BETWEEN root and `.nexus-agents/` indicate the data dir
+  // lives in a subfolder rather than at the multi-repo root.
+  dataDir.replace(`${root.replace(/\/$/, "")}/`, "").split("/").length > 1;
+  const heuristicSaysContainer = info.heuristicMatch === "docker" || info.heuristicMatch === "podman";
+  const mismatch = info.active && info.heuristicMatch === "unknown" || !info.active && heuristicSaysContainer;
+  return {
+    active: info.active,
+    flavor: info.flavor,
+    root: info.root,
+    heuristicMatch: info.heuristicMatch,
+    mismatch,
+    dataDirInsideRepo
+  };
+}
+function checkVoterTransport() {
+  return { configured: readOpenAICompatEnv() !== null };
+}
+function isAllHealthy(input) {
+  return input.nodeSupported && input.hasAuthMethod && input.mcpServerReady && scratchSeverityIsAcceptable(worstSeverity(input.scratchSpace)) && // whenEmpty = false: zero detected CLIs is not a healthy install (#4581).
+  allOf(
+    input.clis,
+    (c) => c.installed && c.authenticated && c.versionStatus !== "unsupported",
+    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 sandbox = checkSandbox();
+  const harnessAlignment = checkHarnessAlignment();
+  const voterTransport = checkVoterTransport();
+  const scratchSpace = checkScratchFilesystems();
+  const hasAuthMethod = apiKeys.some((k) => k.configured) || clis.some((c) => c.installed && c.authenticated);
+  const allHealthy = isAllHealthy({
+    nodeSupported: nodeVersion.supported,
+    hasAuthMethod,
+    mcpServerReady,
+    scratchSpace,
+    clis
+  });
+  return {
+    clis,
+    nodeVersion,
+    apiKeys,
+    configFile,
+    mcpServerReady,
+    mcpClientReady,
+    registryAdvisory,
+    learningPersistence,
+    sqliteCheck,
+    dataDirectory,
+    sandbox,
+    harnessAlignment,
+    voterTransport,
+    scratchSpace,
+    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 { initDataDirectories: initDataDirectories2, describeDataDirFix: describeDataDirFix2 } = await import("./setup-data-dir-EMXRXEFQ.js");
+    const outcome = describeDataDirFix2(initDataDirectories2());
+    writeLine2(outcome.line);
+    if (outcome.counted) fixCount++;
+  }
+  if (!result.configFile.found) {
+    const { runConfigInitSync } = await import("./setup-config-7SWEJXN4.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 = getNexusDataDir();
+var RESTRICTED_DIRS = /* @__PURE__ */ new Set(["auth"]);
+function initDataDirectories(dryRun = false) {
+  const created = [];
+  const alreadyExisted = [];
+  const failures = [];
+  for (const subdir of DATA_SUBDIRECTORIES) {
+    const mode = RESTRICTED_DIRS.has(subdir) ? 448 : void 0;
+    const target = nexusDataPath(...subdir.split("/"));
+    try {
+      ensureDir(target, dryRun, created, alreadyExisted, mode);
+    } catch (error) {
+      failures.push(`${target}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (failures.length > 0) {
+    return {
+      success: false,
+      rootPath: NEXUS_DATA_DIR,
+      created,
+      alreadyExisted,
+      error: `Failed to create ${String(failures.length)} dir(s): ${failures.join("; ")}`
+    };
+  }
+  return { success: true, rootPath: NEXUS_DATA_DIR, created, alreadyExisted, error: null };
+}
+function ensureDir(dirPath, dryRun, created, alreadyExisted, mode) {
+  if (existsSync3(dirPath)) {
+    alreadyExisted.push(dirPath);
+    return;
+  }
+  if (!dryRun) {
+    mkdirSync(dirPath, { recursive: true, ...mode !== void 0 ? { mode } : {} });
+  }
+  created.push(dirPath);
+}
+function describeDataDirFix(result) {
+  if (!result.success) {
+    return {
+      line: `\u2717 Could not create data directories: ${result.error ?? "unknown error"}`,
+      counted: false
+    };
+  }
+  if (result.created.length === 0) {
+    return {
+      line: "\u2717 Data directories already exist but are not writable \u2014 setup creates missing directories and cannot repair permissions. Fix them manually (chmod u+w).",
+      counted: false
+    };
+  }
+  return {
+    line: `\u2713 Created ${String(result.created.length)} missing data director${result.created.length === 1 ? "y" : "ies"}`,
+    counted: true
+  };
+}
+
+export {
+  VERSION,
+  DEFAULT_TASK_TTL_MS,
+  clampTaskTtl,
+  DATA_SUBDIRECTORIES,
+  checkApiKeys,
+  checkSqlite,
+  checkDataDirectory,
+  runDoctor,
+  doctorCommand,
+  NEXUS_DATA_DIR,
+  initDataDirectories,
+  describeDataDirFix,
+  createServer,
+  connectTransport,
+  startStdioServer,
+  closeServer
+};
+//# sourceMappingURL=chunk-WMSWVHFZ.js.map