nexus-agents 2.167.1 → 2.169.0

package/dist/cli.js

@@ -13,13 +13,13 @@ import {
   generateSummary,
   parseFindings,
   sumFindings
-} from "./chunk-JKUX73VD.js";
-import "./chunk-O6VL6LA4.js";
+} from "./chunk-ZXFIBDT3.js";
+import "./chunk-5O4JRXNQ.js";
 import {
   setupCommandAsync,
   verifyCommand
-} from "./chunk-3T6KLPGT.js";
-import "./chunk-XUMLVCFL.js";
+} from "./chunk-WB33EPTV.js";
+import "./chunk-CD2NZFAI.js";
 import {
   AuthHandler,
   DEFAULT_EXPERTS,
@@ -119,6 +119,7 @@ import {
   registerRunTool,
   registerRunWorkflowTool,
   registerSearchCodebaseTool,
+  registerSearchUsagesTool,
   registerSuggestResearchTasksTool,
   registerSupplyChainTradeoffPanelTool,
   registerSurveyOssLandscapeTool,
@@ -138,10 +139,10 @@ import {
   validateCommand,
   validateWorkflow,
   wrapInMarkdownFence
-} from "./chunk-2S7T66IQ.js";
-import "./chunk-VNVGGM73.js";
+} from "./chunk-N7FIUFQL.js";
+import "./chunk-HNNSCTOI.js";
 import "./chunk-HFOQKCD2.js";
-import "./chunk-AO4X3BMP.js";
+import "./chunk-YF35FKKD.js";
 import {
   CATEGORY_DISPLAY_NAMES,
   DEFAULT_PR_REVIEW_CONFIG
@@ -165,15 +166,15 @@ import {
   loadConfig,
   runDoctor,
   validateNexusEnv
-} from "./chunk-EUQNHT7O.js";
+} from "./chunk-ROCNXZBC.js";
 import {
   buildOpenAICompatAdapters,
   readOpenAICompatEnv
-} from "./chunk-6KCZA3IO.js";
-import "./chunk-COIZLMGV.js";
+} from "./chunk-3ON2P4WL.js";
+import "./chunk-PZF67XDY.js";
 import {
   shutdownExpertBridge
-} from "./chunk-GRWHPG72.js";
+} from "./chunk-4G5W5EPU.js";
 import {
   ConsensusVoteInputSchema,
   DEFAULT_VOTE_TIMEOUT_MS,
@@ -183,25 +184,25 @@ import {
   executeVoting,
   mapOutcomeToDecision,
   registerConsensusVoteTool
-} from "./chunk-TGAVZ2ZL.js";
+} from "./chunk-F6HJJG3E.js";
 import {
   loadUsageEvents,
   rollupByModel
-} from "./chunk-ZAPCPHGZ.js";
+} from "./chunk-TB26XNJH.js";
 import {
   synthesizeResearch
-} from "./chunk-7K5LSUEU.js";
+} from "./chunk-7S43YASS.js";
 import {
   classifyTrust,
   createFullGitHubProvider,
   evaluatePolicy,
   parsePRUrl
-} from "./chunk-RKIPSMCN.js";
-import "./chunk-BB7KSLNA.js";
+} from "./chunk-R46SBPLH.js";
+import "./chunk-RO23OT47.js";
 import {
   ReputationCache,
   sanitizeInput
-} from "./chunk-SRNAXDOT.js";
+} from "./chunk-SX4E2W3Z.js";
 import {
   ImprovementReviewInputSchema,
   calculateFitnessScore,
@@ -215,13 +216,15 @@ import {
   registerImprovementReviewTool,
   runImprovementReview,
   scanForSecrets
-} from "./chunk-ZIC6ZZFU.js";
+} from "./chunk-EQRN5FRZ.js";
 import {
   createDefaultPolicyFirewall
-} from "./chunk-STMW5BSR.js";
-import "./chunk-QV52AXTF.js";
+} from "./chunk-IQC2K3KY.js";
+import "./chunk-BWG54OJS.js";
 import {
+  CodebaseIndexSchema,
   PaperStatusSchema,
+  buildIndex,
   createResearchIssue,
   discoverDeepMind,
   discoverGitHubRepos,
@@ -231,6 +234,7 @@ import {
   discoverOpenAlex,
   discoverPapersWithCode,
   discoverSemanticScholar,
+  extractProject,
   findOverlaps,
   formatOverlapResult,
   formatResearchIssueBody,
@@ -242,32 +246,31 @@ import {
   loadSourcesRegistry,
   rankDiscoveredItems,
   saveSourcesRegistry
-} from "./chunk-ZSUN7BHE.js";
+} from "./chunk-XGNB7LQB.js";
 import {
   resolveToken
-} from "./chunk-UNIDAVVR.js";
+} from "./chunk-3JH3FMEJ.js";
 import {
   loadPapersRegistry,
   loadTechniquesRegistry,
   savePapersRegistry
-} from "./chunk-PC4Y4VPX.js";
+} from "./chunk-HAVBBSYN.js";
 import "./chunk-NUBSJGQZ.js";
 import {
   MemoryError,
   shutdownToolMemory
-} from "./chunk-KM3YEIEN.js";
+} from "./chunk-Q3UMNYV2.js";
 import {
   capitalize,
-  capitalizeKebab,
-  truncateSentence
+  capitalizeKebab
 } from "./chunk-6T3EPABN.js";
-import "./chunk-QPSYBHK6.js";
+import "./chunk-W76DOL27.js";
 import "./chunk-ZM4O442V.js";
 import "./chunk-PINS44XA.js";
 import "./chunk-KSQSWEFH.js";
 import {
   createUnifiedRegistry
-} from "./chunk-GGYQTV2Y.js";
+} from "./chunk-P7MYTCE6.js";
 import {
   NEXUS_SUBPROCESS_DEPTH_ENV,
   createAllAdapters,
@@ -275,15 +278,15 @@ import {
   isRecord,
   probeAllClis,
   readSubprocessDepth
-} from "./chunk-S6HCREYY.js";
-import "./chunk-IFSIKGHI.js";
+} from "./chunk-NT3KCLT6.js";
+import "./chunk-MCT7JJF6.js";
 import {
   DEFAULTS
-} from "./chunk-2NU774CB.js";
-import "./chunk-GVNY4ZB6.js";
-import "./chunk-ZTTUXPBQ.js";
+} from "./chunk-JCJHQSAY.js";
+import "./chunk-DSMSYENI.js";
+import "./chunk-T3VD32JY.js";
 import "./chunk-QZUG667L.js";
-import "./chunk-7USEQLMS.js";
+import "./chunk-OOFPDA3B.js";
 import {
   API_TIMEOUTS,
   AgentCapability,
@@ -357,7 +360,7 @@ import {
   validateTimeout,
   writeEmptyLine,
   writeLine
-} from "./chunk-CURHM4TH.js";
+} from "./chunk-QXSR5KPG.js";
 import "./chunk-AXTD4TFK.js";
 import {
   applyPortableMode,
@@ -645,8 +648,8 @@ function resolveOutputPath(output2) {
   }
   return resolve(process.cwd(), DEFAULT_CONFIG_REL_PATH);
 }
-function fileExists(path21) {
-  return existsSync(path21);
+function fileExists(path18) {
+  return existsSync(path18);
 }
 async function ensureDirectory(filePath) {
   const dir = dirname(filePath);
@@ -654,9 +657,9 @@ async function ensureDirectory(filePath) {
     await mkdir(dir, { recursive: true });
   }
 }
-async function writeConfigFile(path21) {
-  await ensureDirectory(path21);
-  await writeFile(path21, renderConfigTemplate() + CONFIG_TEMPLATE_TAIL, "utf-8");
+async function writeConfigFile(path18) {
+  await ensureDirectory(path18);
+  await writeFile(path18, renderConfigTemplate() + CONFIG_TEMPLATE_TAIL, "utf-8");
 }
 async function runConfigInit(options = {}) {
   const outputPath = resolveOutputPath(options.output);
@@ -1636,14 +1639,14 @@ ${colors.dim}Session ended.${colors.reset}
     });
   });
   rl.prompt();
-  return new Promise((resolve14) => {
+  return new Promise((resolve13) => {
     rl.on("line", (line) => {
       void (async () => {
         try {
           const shouldExit = await processLine(line, session, logger19);
           if (shouldExit) {
             rl.close();
-            resolve14();
+            resolve13();
             return;
           }
         } catch (error) {
@@ -1655,7 +1658,7 @@ ${colors.dim}Session ended.${colors.reset}
       })();
     });
     rl.on("close", () => {
-      resolve14();
+      resolve13();
     });
   });
 }
@@ -2701,9 +2704,9 @@ async function evaluateDirectory(target, timeoutMs, store = getOutcomeStore()) {
   }
   const aggregator = createAggregator();
   const results = [];
-  for (const [path21, evaluations] of evaluationsByComponent) {
+  for (const [path18, evaluations] of evaluationsByComponent) {
     if (evaluations.length > 0) {
-      results.push(aggregator.aggregate(path21, evaluations));
+      results.push(aggregator.aggregate(path18, evaluations));
     }
   }
   const priority = { deprecate: 0, refactor: 1, review: 2, retain: 3 };
@@ -4035,7 +4038,7 @@ ${file.patch}
         violations: policyResult.violations
       });
     }
-    const { formatReviewComment: formatReviewComment2 } = await import("./pr-reviewer-helpers-SAMOVLNJ.js");
+    const { formatReviewComment: formatReviewComment2 } = await import("./pr-reviewer-helpers-TKXJBDT6.js");
     const body = formatReviewComment2(result);
     const postResult = await provider.createReview(pr.prNumber, body, result.decision);
     if (!postResult.ok) {
@@ -5081,27 +5084,27 @@ var CliAdapterAgent = class {
 };
 
 // src/cli/orchestrate-puppeteer.ts
-function loadPolicyParameters(path21, logger19) {
+function loadPolicyParameters(path18, logger19) {
   try {
-    if (fs2.existsSync(path21)) {
-      const content = fs2.readFileSync(path21, "utf-8");
+    if (fs2.existsSync(path18)) {
+      const content = fs2.readFileSync(path18, "utf-8");
       const params = JSON.parse(content);
-      logger19.info("Loaded policy parameters", { path: path21 });
+      logger19.info("Loaded policy parameters", { path: path18 });
       return params;
     }
   } catch (error) {
     const message = getErrorMessage(error);
-    logger19.warn("Failed to load policy parameters", { path: path21, error: message });
+    logger19.warn("Failed to load policy parameters", { path: path18, error: message });
   }
   return void 0;
 }
-function savePolicyParameters(path21, params, logger19) {
+function savePolicyParameters(path18, params, logger19) {
   try {
-    fs2.writeFileSync(path21, JSON.stringify(params, null, 2));
-    logger19.info("Saved policy parameters", { path: path21 });
+    fs2.writeFileSync(path18, JSON.stringify(params, null, 2));
+    logger19.info("Saved policy parameters", { path: path18 });
   } catch (error) {
     const message = getErrorMessage(error);
-    logger19.warn("Failed to save policy parameters", { path: path21, error: message });
+    logger19.warn("Failed to save policy parameters", { path: path18, error: message });
   }
 }
 function createAgentsFromAdapters(adapters) {
@@ -9800,515 +9803,12 @@ async function researchCommand(subcommand, args, options) {
 
 // src/cli/index-command.ts
 import * as fs13 from "fs/promises";
-import * as path17 from "path";
+import * as path14 from "path";
 import * as yaml6 from "yaml";
 
-// src/indexer/types.ts
-import { z as z4 } from "zod";
-var SCHEMA_VERSION = "1.0";
-var ExportEntrySchema = z4.object({
-  name: z4.string(),
-  kind: z4.enum(["type", "interface", "class", "function", "const", "enum", "unknown"]),
-  isReExport: z4.boolean(),
-  sourceModule: z4.string().optional()
-});
-var DependencyEntrySchema = z4.object({
-  specifier: z4.string(),
-  isExternal: z4.boolean(),
-  imports: z4.array(z4.string()).readonly()
-});
-var FileEntrySchema = z4.object({
-  path: z4.string(),
-  lines: z4.number().int().nonnegative(),
-  category: z4.enum(["types", "implementation", "test", "config", "cli", "util", "index"]),
-  exports: z4.array(ExportEntrySchema).readonly(),
-  dependencies: z4.array(DependencyEntrySchema).readonly(),
-  description: z4.string().optional()
-});
-var ModuleStatsSchema = z4.object({
-  fileCount: z4.number().int().nonnegative(),
-  totalLines: z4.number().int().nonnegative(),
-  exportCount: z4.number().int().nonnegative(),
-  internalDeps: z4.number().int().nonnegative(),
-  externalDeps: z4.number().int().nonnegative()
-});
-var ModuleEntrySchema = z4.object({
-  name: z4.string(),
-  path: z4.string(),
-  purpose: z4.string(),
-  files: z4.array(FileEntrySchema).readonly(),
-  stats: ModuleStatsSchema,
-  dependsOn: z4.array(z4.string()).readonly()
-});
-var IndexStatsSchema = z4.object({
-  totalFiles: z4.number().int().nonnegative(),
-  totalLines: z4.number().int().nonnegative(),
-  totalExports: z4.number().int().nonnegative(),
-  moduleCount: z4.number().int().nonnegative(),
-  externalPackages: z4.array(z4.string()).readonly()
-});
-var CodebaseIndexSchema = z4.object({
-  schemaVersion: z4.literal(SCHEMA_VERSION),
-  generatedAt: z4.string(),
-  stats: IndexStatsSchema,
-  modules: z4.record(z4.string(), ModuleEntrySchema)
-});
-var DEFAULT_EXTRACTOR_OPTIONS = {
-  rootDir: "src",
-  include: ["**/*.ts"],
-  exclude: ["**/*.test.ts", "**/*.d.ts", "**/node_modules/**"],
-  extractDescriptions: true
-};
-
-// src/indexer/category-detection.ts
-import * as path8 from "path";
-var FILE_SUFFIX_PATTERNS = [
-  [".test.ts", "test"],
-  [".spec.ts", "test"],
-  ["-types.ts", "types"],
-  [".types.ts", "types"],
-  ["-command.ts", "cli"]
-];
-var FILE_PATH_PATTERNS = [
-  { test: (f) => f === "index.ts", category: "index" },
-  { test: (_, d) => d.includes("/cli"), category: "cli" },
-  { test: (f, d) => d.includes("config") || f.includes("config"), category: "config" },
-  { test: (f) => f.includes("helper") || f.includes("util"), category: "util" }
-];
-function detectCategoryFromPath(fileName, dirName) {
-  for (const [suffix, category] of FILE_SUFFIX_PATTERNS) {
-    if (fileName.endsWith(suffix)) return category;
-  }
-  for (const { test, category } of FILE_PATH_PATTERNS) {
-    if (test(fileName, dirName)) return category;
-  }
-  return void 0;
-}
-function isTypesOnlyFile(sourceFile) {
-  const typeCount = sourceFile.getTypeAliases().length + sourceFile.getInterfaces().length;
-  const implCount = sourceFile.getFunctions().length + sourceFile.getClasses().length + sourceFile.getVariableDeclarations().length;
-  return typeCount > 0 && implCount === 0;
-}
-function detectFileCategory(filePath, sourceFile) {
-  const pathCategory = detectCategoryFromPath(path8.basename(filePath), path8.dirname(filePath));
-  if (pathCategory !== void 0) return pathCategory;
-  if (isTypesOnlyFile(sourceFile)) return "types";
-  return "implementation";
-}
-
-// src/indexer/export-extraction.ts
-function addExport(state, name, kind, reExportInfo) {
-  if (state.seenNames.has(name)) return;
-  state.seenNames.add(name);
-  const entry = { name, kind, isReExport: reExportInfo !== void 0 };
-  if (reExportInfo !== void 0)
-    entry.sourceModule = reExportInfo.sourceModule;
-  state.exports.push(entry);
-}
-function extractFunctionClassExports(sourceFile, state) {
-  for (const fn of sourceFile.getFunctions()) {
-    if (fn.isExported()) {
-      const name = fn.getName();
-      if (name !== void 0) addExport(state, name, "function");
-    }
-  }
-  for (const cls of sourceFile.getClasses()) {
-    if (cls.isExported()) {
-      const name = cls.getName();
-      if (name !== void 0) addExport(state, name, "class");
-    }
-  }
-}
-function extractTypeExports(sourceFile, state) {
-  for (const iface of sourceFile.getInterfaces()) {
-    if (iface.isExported()) addExport(state, iface.getName(), "interface");
-  }
-  for (const typeAlias of sourceFile.getTypeAliases()) {
-    if (typeAlias.isExported()) addExport(state, typeAlias.getName(), "type");
-  }
-  for (const enumDecl of sourceFile.getEnums()) {
-    if (enumDecl.isExported()) addExport(state, enumDecl.getName(), "enum");
-  }
-}
-function extractVariableExports(sourceFile, state) {
-  for (const varStmt of sourceFile.getVariableStatements()) {
-    if (varStmt.isExported()) {
-      for (const decl of varStmt.getDeclarations()) addExport(state, decl.getName(), "const");
-    }
-  }
-}
-function extractReExports(sourceFile, state) {
-  for (const exportDecl of sourceFile.getExportDeclarations()) {
-    const moduleSpecifier = exportDecl.getModuleSpecifierValue();
-    const namedExports = exportDecl.getNamedExports();
-    const reExportInfo = moduleSpecifier !== void 0 ? { sourceModule: moduleSpecifier } : void 0;
-    for (const namedExport of namedExports) {
-      const name = namedExport.getAliasNode()?.getText() ?? namedExport.getName();
-      addExport(state, name, "unknown", reExportInfo);
-    }
-    if (namedExports.length === 0 && reExportInfo !== void 0) {
-      addExport(state, "*", "unknown", reExportInfo);
-    }
-  }
-}
-function extractExports(sourceFile) {
-  const state = { exports: [], seenNames: /* @__PURE__ */ new Set() };
-  extractFunctionClassExports(sourceFile, state);
-  extractTypeExports(sourceFile, state);
-  extractVariableExports(sourceFile, state);
-  extractReExports(sourceFile, state);
-  return state.exports;
-}
-
-// src/indexer/dependency-extraction.ts
-function isExternalImport(specifier) {
-  if (specifier.startsWith(".") || specifier.startsWith("/")) {
-    return false;
-  }
-  if (specifier.startsWith("node:")) {
-    return true;
-  }
-  return true;
-}
-function extractDependencies(sourceFile) {
-  const deps = [];
-  const seenSpecifiers = /* @__PURE__ */ new Set();
-  for (const importDecl of sourceFile.getImportDeclarations()) {
-    const specifier = importDecl.getModuleSpecifierValue();
-    if (seenSpecifiers.has(specifier)) continue;
-    seenSpecifiers.add(specifier);
-    const imports = [];
-    const namedImports = importDecl.getNamedImports();
-    for (const namedImport of namedImports) {
-      imports.push(namedImport.getName());
-    }
-    const defaultImport = importDecl.getDefaultImport();
-    if (defaultImport !== void 0) {
-      imports.push(defaultImport.getText());
-    }
-    const namespaceImport = importDecl.getNamespaceImport();
-    if (namespaceImport !== void 0) {
-      imports.push(`* as ${namespaceImport.getText()}`);
-    }
-    deps.push({
-      specifier,
-      isExternal: isExternalImport(specifier),
-      imports
-    });
-  }
-  return deps;
-}
-
-// src/indexer/description-extraction.ts
-function isPlainBlockComment(trimmed) {
-  return trimmed.startsWith("/*") && trimmed.endsWith("*/");
-}
-function classifyOutsideComment(trimmed) {
-  if (isPlainBlockComment(trimmed)) return "skip";
-  if (trimmed.length > 0 && !trimmed.startsWith("//")) return "stop";
-  return "skip";
-}
-function classifyInsideComment(trimmed) {
-  if (trimmed.endsWith("*/")) return "end";
-  if (trimmed.startsWith("* @") || trimmed.startsWith("@")) return "skip";
-  return "content";
-}
-function classifyJsDocLine(trimmed, inComment) {
-  if (trimmed.startsWith("/**")) {
-    return trimmed.endsWith("*/") ? "startEnd" : "start";
-  }
-  return inComment ? classifyInsideComment(trimmed) : classifyOutsideComment(trimmed);
-}
-function extractJsDocLineContent(trimmed) {
-  return trimmed.startsWith("*") ? trimmed.slice(1).trim() : trimmed;
-}
-function extractInlineJsDocContent(trimmed) {
-  return trimmed.slice(3, -2).trim();
-}
-function truncateDescription(full) {
-  return truncateSentence(full, 150);
-}
-function extractDescription(sourceFile) {
-  const lines = sourceFile.getFullText().split("\n");
-  let inComment = false;
-  const description = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const result = classifyJsDocLine(trimmed, inComment);
-    if (result === "start") {
-      inComment = true;
-      continue;
-    }
-    if (result === "startEnd") {
-      const inline = extractInlineJsDocContent(trimmed);
-      if (inline.length > 0) description.push(inline);
-      break;
-    }
-    if (result === "end" || result === "stop") break;
-    if (result === "skip") continue;
-    const content = extractJsDocLineContent(trimmed);
-    if (content.length > 0) description.push(content);
-  }
-  if (description.length === 0) return void 0;
-  return truncateDescription(description.join(" "));
-}
-
-// src/indexer/project-extraction.ts
-import { Project } from "ts-morph";
-import * as path9 from "path";
-function extractFileEntry(sourceFile, rootDir, extractDescriptions) {
-  const absolutePath = sourceFile.getFilePath();
-  const relativePath = path9.relative(rootDir, absolutePath);
-  const lineCount = sourceFile.getEndLineNumber();
-  const entry = {
-    path: relativePath,
-    lines: lineCount,
-    category: detectFileCategory(relativePath, sourceFile),
-    exports: extractExports(sourceFile),
-    dependencies: extractDependencies(sourceFile)
-  };
-  if (extractDescriptions) {
-    const desc = extractDescription(sourceFile);
-    if (desc !== void 0) {
-      entry.description = desc;
-    }
-  }
-  return entry;
-}
-function processSourceFiles(project, rootDir, extractDescriptions) {
-  const files = [];
-  const errors = [];
-  for (const sourceFile of project.getSourceFiles()) {
-    const filePath = sourceFile.getFilePath();
-    try {
-      files.push(extractFileEntry(sourceFile, rootDir, extractDescriptions));
-    } catch (err2) {
-      const message = err2 instanceof Error ? err2.message : String(err2);
-      errors.push(`Error extracting ${filePath}: ${message}`);
-    }
-  }
-  return { files, errors };
-}
-function extractProject(options = {}) {
-  const opts = { ...DEFAULT_EXTRACTOR_OPTIONS, ...options };
-  const startTime = getTimeProvider().now();
-  const project = new Project({
-    skipAddingFilesFromTsConfig: true,
-    skipFileDependencyResolution: true
-  });
-  const rootDir = path9.resolve(process.cwd(), opts.rootDir);
-  const includePatterns = opts.include.map((p) => path9.join(rootDir, p));
-  const excludePatterns = opts.exclude.map((p) => `!${path9.join(rootDir, p)}`);
-  try {
-    project.addSourceFilesAtPaths([...includePatterns, ...excludePatterns]);
-    const { files, errors } = processSourceFiles(project, rootDir, opts.extractDescriptions);
-    return { files, errors, durationMs: getTimeProvider().now() - startTime };
-  } catch (err2) {
-    const message = err2 instanceof Error ? err2.message : String(err2);
-    return {
-      files: [],
-      errors: [`Error loading project: ${message}`],
-      durationMs: getTimeProvider().now() - startTime
-    };
-  }
-}
-
-// src/indexer/analyzer.ts
-import * as path10 from "path";
-var MODULE_PURPOSES = {
-  core: "Types, Result<T,E>, errors, logger",
-  config: "Configuration loading, validation, Zod schemas",
-  adapters: "Model adapters (Claude, OpenAI, Gemini, Ollama)",
-  agents: "Agent framework, Orchestrator, Experts, collaboration",
-  workflows: "Workflow engine, templates, execution",
-  mcp: "MCP server, tool definitions",
-  cli: "CLI interface, mode detection, commands",
-  "cli-adapters": "External CLI integrations (Claude, Gemini, Codex)",
-  context: "Context management, token counting, memory",
-  consensus: "Multi-agent consensus, voting strategies",
-  learning: "Feedback collection, outcome tracking",
-  indexer: "Codebase indexing and documentation",
-  security: "Sandbox execution, secrets management"
-};
-function detectModulePurpose(moduleName, files) {
-  const known = MODULE_PURPOSES[moduleName];
-  if (known !== void 0) {
-    return known;
-  }
-  const descriptions = files.filter((f) => f.description !== void 0).map((f) => f.description).slice(0, 3);
-  if (descriptions.length > 0) {
-    return descriptions.join("; ");
-  }
-  return `${moduleName} module`;
-}
-function extractPackageName(specifier) {
-  if (specifier.startsWith("@")) {
-    const parts2 = specifier.split("/");
-    const scope = parts2[0];
-    const name = parts2[1];
-    if (scope !== void 0 && name !== void 0) {
-      return `${scope}/${name}`;
-    }
-    return void 0;
-  }
-  if (specifier.startsWith("node:")) {
-    return specifier;
-  }
-  const parts = specifier.split("/");
-  return parts[0];
-}
-function groupFilesByModule(files) {
-  const modules = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const parts = file.path.split("/");
-    const moduleName = parts.length > 1 ? parts[0] ?? "root" : "root";
-    const existing = modules.get(moduleName);
-    if (existing !== void 0) {
-      existing.push(file);
-    } else {
-      modules.set(moduleName, [file]);
-    }
-  }
-  return modules;
-}
-function collectExternalPackages(file, packages) {
-  for (const dep of file.dependencies) {
-    if (dep.isExternal) {
-      const pkgName = extractPackageName(dep.specifier);
-      if (pkgName !== void 0) {
-        packages.add(pkgName);
-      }
-    }
-  }
-}
-function computeModuleStats(files) {
-  let totalLines = 0;
-  let exportCount = 0;
-  let internalDeps = 0;
-  let externalDeps = 0;
-  for (const file of files) {
-    totalLines += file.lines;
-    exportCount += file.exports.length;
-    for (const dep of file.dependencies) {
-      if (dep.isExternal) {
-        externalDeps++;
-      } else {
-        internalDeps++;
-      }
-    }
-  }
-  return {
-    fileCount: files.length,
-    totalLines,
-    exportCount,
-    internalDeps,
-    externalDeps
-  };
-}
-function resolveTargetModule(filePath, specifier) {
-  if (!specifier.startsWith(".")) return void 0;
-  const resolved = path10.join(path10.dirname(filePath), specifier);
-  const parts = resolved.split("/");
-  return parts[0];
-}
-function isValidModuleDep(targetModule, moduleName, allModules) {
-  return targetModule !== void 0 && targetModule !== moduleName && allModules.has(targetModule);
-}
-function detectModuleDependencies(moduleName, files, allModules) {
-  const deps = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    for (const dep of file.dependencies) {
-      if (dep.isExternal) continue;
-      const targetModule = resolveTargetModule(file.path, dep.specifier);
-      if (isValidModuleDep(targetModule, moduleName, allModules)) {
-        deps.add(targetModule);
-      }
-    }
-  }
-  return Array.from(deps).sort();
-}
-function analyzeModules(files) {
-  const filesByModule = groupFilesByModule(files);
-  const moduleNames = new Set(filesByModule.keys());
-  const modules = /* @__PURE__ */ new Map();
-  for (const [moduleName, moduleFiles] of filesByModule) {
-    modules.set(moduleName, {
-      name: moduleName,
-      path: moduleName === "root" ? "." : moduleName,
-      purpose: detectModulePurpose(moduleName, moduleFiles),
-      files: moduleFiles,
-      stats: computeModuleStats(moduleFiles),
-      dependsOn: detectModuleDependencies(moduleName, moduleFiles, moduleNames)
-    });
-  }
-  return modules;
-}
-function computeIndexStats(modules) {
-  let totalFiles = 0;
-  let totalLines = 0;
-  let totalExports = 0;
-  const externalPackages = /* @__PURE__ */ new Set();
-  for (const module of modules.values()) {
-    totalFiles += module.stats.fileCount;
-    totalLines += module.stats.totalLines;
-    totalExports += module.stats.exportCount;
-    for (const file of module.files) {
-      collectExternalPackages(file, externalPackages);
-    }
-  }
-  return {
-    totalFiles,
-    totalLines,
-    totalExports,
-    moduleCount: modules.size,
-    externalPackages: Array.from(externalPackages).sort()
-  };
-}
-function buildIndex(files) {
-  const modules = analyzeModules(files);
-  const stats = computeIndexStats(modules);
-  const now = new Date(getTimeProvider().now());
-  const etFormatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: "America/New_York",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false
-  });
-  const parts = etFormatter.formatToParts(now);
-  const getPart = (type) => parts.find((p) => p.type === type)?.value ?? "00";
-  const utcFormatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: "UTC",
-    hour: "numeric",
-    hour12: false
-  });
-  const utcHour = Number(
-    utcFormatter.formatToParts(now).find((p) => p.type === "hour")?.value ?? "0"
-  );
-  const etHour = Number(getPart("hour"));
-  const rawDiff = etHour - utcHour;
-  const offsetHours = rawDiff > 12 ? rawDiff - 24 : rawDiff < -12 ? rawDiff + 24 : rawDiff;
-  const offsetSign = offsetHours <= 0 ? "-" : "+";
-  const absOffset = String(Math.abs(offsetHours)).padStart(2, "0");
-  const timestamp = `${getPart("year")}-${getPart("month")}-${getPart("day")}T${getPart("hour")}:${getPart("minute")}:${getPart("second")}${offsetSign}${absOffset}:00`;
-  const modulesRecord = {};
-  for (const [name, entry] of modules) {
-    modulesRecord[name] = entry;
-  }
-  return {
-    schemaVersion: SCHEMA_VERSION,
-    generatedAt: timestamp,
-    stats,
-    modules: modulesRecord
-  };
-}
-
 // src/indexer/generator.ts
 import * as fs10 from "fs/promises";
-import * as path11 from "path";
+import * as path8 from "path";
 import * as yaml4 from "yaml";
 function indexToYaml(index) {
   const doc = new yaml4.Document(index);
@@ -10438,43 +9938,43 @@ function validateIndex(index, currentFiles) {
 }
 
 // src/indexer/entrypoint-types.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var ENTRYPOINT_SCHEMA_VERSION = "1.0";
-var OptionSpecSchema = z5.object({
-  name: z5.string(),
-  type: z5.string(),
-  description: z5.string().optional(),
-  required: z5.boolean().optional(),
-  default: z5.string().optional(),
-  short: z5.string().optional()
+var OptionSpecSchema = z4.object({
+  name: z4.string(),
+  type: z4.string(),
+  description: z4.string().optional(),
+  required: z4.boolean().optional(),
+  default: z4.string().optional(),
+  short: z4.string().optional()
 });
-var ParameterSpecSchema = z5.object({
-  name: z5.string(),
-  type: z5.string(),
-  description: z5.string().optional(),
-  required: z5.boolean().optional(),
-  default: z5.string().optional()
+var ParameterSpecSchema = z4.object({
+  name: z4.string(),
+  type: z4.string(),
+  description: z4.string().optional(),
+  required: z4.boolean().optional(),
+  default: z4.string().optional()
 });
-var CliCommandSpecSchema = z5.object({
-  name: z5.string(),
-  description: z5.string(),
-  subcommands: z5.array(z5.string()).readonly().optional(),
-  options: z5.array(OptionSpecSchema).readonly().optional(),
-  source_file: z5.string(),
-  source_line: z5.number().int().positive()
+var CliCommandSpecSchema = z4.object({
+  name: z4.string(),
+  description: z4.string(),
+  subcommands: z4.array(z4.string()).readonly().optional(),
+  options: z4.array(OptionSpecSchema).readonly().optional(),
+  source_file: z4.string(),
+  source_line: z4.number().int().positive()
 });
-var McpToolSpecSchema = z5.object({
-  name: z5.string(),
-  description: z5.string(),
-  parameters: z5.array(ParameterSpecSchema).readonly(),
-  source_file: z5.string(),
-  source_line: z5.number().int().positive()
+var McpToolSpecSchema = z4.object({
+  name: z4.string(),
+  description: z4.string(),
+  parameters: z4.array(ParameterSpecSchema).readonly(),
+  source_file: z4.string(),
+  source_line: z4.number().int().positive()
 });
-var EntrypointManifestSchema = z5.object({
-  schema_version: z5.literal(ENTRYPOINT_SCHEMA_VERSION),
-  generated_at: z5.string(),
-  cli_commands: z5.array(CliCommandSpecSchema).readonly(),
-  mcp_tools: z5.array(McpToolSpecSchema).readonly()
+var EntrypointManifestSchema = z4.object({
+  schema_version: z4.literal(ENTRYPOINT_SCHEMA_VERSION),
+  generated_at: z4.string(),
+  cli_commands: z4.array(CliCommandSpecSchema).readonly(),
+  mcp_tools: z4.array(McpToolSpecSchema).readonly()
 });
 var DEFAULT_ENTRYPOINT_EXTRACTOR_OPTIONS = {
   packageRoot: "packages/nexus-agents",
@@ -10484,8 +9984,8 @@ var DEFAULT_ENTRYPOINT_EXTRACTOR_OPTIONS = {
 };
 
 // src/indexer/entrypoint-extractor.ts
-import { Project as Project2 } from "ts-morph";
-import * as path14 from "path";
+import { Project } from "ts-morph";
+import * as path11 from "path";
 import * as yaml5 from "yaml";
 
 // src/indexer/entrypoint-sanitizer.ts
@@ -10582,7 +10082,7 @@ function sanitizeTool(tool) {
 
 // src/indexer/entrypoint-cli-extractor.ts
 import { SyntaxKind } from "ts-morph";
-import * as path12 from "path";
+import * as path9 from "path";
 function extractCliOptions(sourceFile) {
   const options = /* @__PURE__ */ new Map();
   const configVar = sourceFile.getVariableDeclaration("PARSE_ARGS_CONFIG");
@@ -10698,7 +10198,7 @@ function buildCommandSpec(entry, ctx) {
   return cmdSpec;
 }
 function extractCliCommands(project, packageRoot, cliCommandsPath, cliTypesPath, warnings) {
-  const typesFullPath = path12.join(packageRoot, cliTypesPath);
+  const typesFullPath = path9.join(packageRoot, cliTypesPath);
   const typesFile = project.getSourceFile(typesFullPath);
   if (typesFile === void 0 && warnings !== void 0) {
     warnings.push(
@@ -10706,7 +10206,7 @@ function extractCliCommands(project, packageRoot, cliCommandsPath, cliTypesPath,
     );
   }
   const cliOptions = typesFile !== void 0 ? extractCliOptions(typesFile) : /* @__PURE__ */ new Map();
-  const commandsFullPath = path12.join(packageRoot, cliCommandsPath);
+  const commandsFullPath = path9.join(packageRoot, cliCommandsPath);
   const commandsFile = project.getSourceFile(commandsFullPath);
   if (commandsFile === void 0) {
     if (warnings !== void 0) {
@@ -10718,7 +10218,7 @@ function extractCliCommands(project, packageRoot, cliCommandsPath, cliTypesPath,
   }
   const ctx = {
     commandsFile,
-    relativePath: path12.relative(process.cwd(), commandsFullPath),
+    relativePath: path9.relative(process.cwd(), commandsFullPath),
     cliOptions,
     cliCommandsPath,
     ...warnings !== void 0 && { warnings }
@@ -10728,7 +10228,7 @@ function extractCliCommands(project, packageRoot, cliCommandsPath, cliTypesPath,
 
 // src/indexer/entrypoint-mcp-extractor.ts
 import { SyntaxKind as SyntaxKind2 } from "ts-morph";
-import * as path13 from "path";
+import * as path10 from "path";
 function inferZodType(zodExpr) {
   if (zodExpr.includes("z.string()")) return "string";
   if (zodExpr.includes("z.number()")) return "number";
@@ -10771,7 +10271,7 @@ function extractZodParameters(schemaObj) {
 }
 function extractMcpTools(project, packageRoot, mcpToolsPath, warnings) {
   const tools = [];
-  const toolsDir = path13.join(packageRoot, mcpToolsPath);
+  const toolsDir = path10.join(packageRoot, mcpToolsPath);
   const toolFiles = project.getSourceFiles(`${toolsDir}/*.ts`);
   if (toolFiles.length === 0 && warnings !== void 0) {
     warnings.push(
@@ -10780,9 +10280,9 @@ function extractMcpTools(project, packageRoot, mcpToolsPath, warnings) {
   }
   for (const sourceFile of toolFiles) {
     const filePath = sourceFile.getFilePath();
-    const fileName = path13.basename(filePath);
+    const fileName = path10.basename(filePath);
     if (fileName.endsWith(".test.ts") || fileName === "index.ts") continue;
-    const relativePath = path13.relative(process.cwd(), filePath);
+    const relativePath = path10.relative(process.cwd(), filePath);
     const extractedTools = extractToolsFromFile(sourceFile, relativePath, warnings);
     tools.push(...extractedTools);
   }
@@ -10910,19 +10410,19 @@ function generateTimestamp() {
   });
 }
 function createProject(opts) {
-  const project = new Project2({
-    tsConfigFilePath: path14.join(opts.packageRoot, "tsconfig.json"),
+  const project = new Project({
+    tsConfigFilePath: path11.join(opts.packageRoot, "tsconfig.json"),
     skipAddingFilesFromTsConfig: true
   });
   project.addSourceFilesAtPaths([
-    path14.join(opts.packageRoot, opts.cliCommandsPath),
-    path14.join(opts.packageRoot, "src/cli-types.ts"),
+    path11.join(opts.packageRoot, opts.cliCommandsPath),
+    path11.join(opts.packageRoot, "src/cli-types.ts"),
     // HELP_TEXT was extracted to cli-help-text.ts in #293 (Jan 2026) and
     // cli-types.ts now only re-exports it. The extractor reads it via AST,
     // so we have to load the defining file — a bare re-export isn't enough.
     // Without this line the CLI command list silently came back empty.
-    path14.join(opts.packageRoot, "src/cli-help-text.ts"),
-    path14.join(opts.packageRoot, opts.mcpToolsPath, "*.ts")
+    path11.join(opts.packageRoot, "src/cli-help-text.ts"),
+    path11.join(opts.packageRoot, opts.mcpToolsPath, "*.ts")
   ]);
   return project;
 }
@@ -10969,17 +10469,17 @@ function manifestToJson(manifest) {
 
 // src/cli/index-command-link-validator.ts
 import * as fs12 from "fs/promises";
-import * as path16 from "path";
+import * as path13 from "path";
 
 // src/cli/index-command-link-validation-helpers.ts
 import * as fs11 from "fs/promises";
-import * as path15 from "path";
+import * as path12 from "path";
 async function validateInternalLink(url, sourceFile) {
   const [filePath, anchor] = url.split("#");
   if (filePath === void 0 || filePath === "") {
     return { valid: true };
   }
-  const resolvedPath = path15.resolve(path15.dirname(sourceFile), filePath);
+  const resolvedPath = path12.resolve(path12.dirname(sourceFile), filePath);
   try {
     await fs11.access(resolvedPath);
     if (anchor !== void 0 && anchor !== "") {
@@ -11064,9 +10564,9 @@ async function validateAnchorInFile(anchor, targetFile) {
         return { valid: true };
       }
     }
-    return { valid: false, error: `Anchor '#${anchor}' not found in ${path15.basename(targetFile)}` };
+    return { valid: false, error: `Anchor '#${anchor}' not found in ${path12.basename(targetFile)}` };
   } catch {
-    return { valid: false, error: `Failed to read ${path15.basename(targetFile)} for anchor check` };
+    return { valid: false, error: `Failed to read ${path12.basename(targetFile)} for anchor check` };
   }
 }
 async function validateAnchorLink(anchor, sourceFile) {
@@ -11158,7 +10658,7 @@ async function findMarkdownFiles(dir) {
   try {
     const entries = await fs12.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path13.join(dir, entry.name);
       if (entry.name === "node_modules" || entry.name === "dist") {
         continue;
       }
@@ -11353,7 +10853,7 @@ async function generateIndex(options) {
     `Extracted ${String(extraction.files.length)} files in ${String(extraction.durationMs)}ms`
   );
   const index = buildIndex(extraction.files);
-  const outputDir = path17.dirname(outputPath);
+  const outputDir = path14.dirname(outputPath);
   await fs13.mkdir(outputDir, { recursive: true });
   const content = format === "yaml" ? indexToYaml(index) : indexToJson(index);
   await fs13.writeFile(outputPath, content, "utf-8");
@@ -11424,7 +10924,7 @@ async function generateDiagram(options) {
   CodebaseIndexSchema.parse(parsed);
   const index = parsed;
   const diagram = generateDiagramMarkdown(index);
-  await fs13.mkdir(path17.dirname(diagramPath), { recursive: true });
+  await fs13.mkdir(path14.dirname(diagramPath), { recursive: true });
   await fs13.writeFile(diagramPath, diagram, "utf-8");
   logger10.info(`Wrote diagram to ${diagramPath}`);
   return {
@@ -11530,7 +11030,7 @@ async function entrypointsCommand(options) {
   for (const warning of result.warnings) {
     logger10.warn(warning);
   }
-  const outputDir = path17.dirname(outputPath);
+  const outputDir = path14.dirname(outputPath);
   await fs13.mkdir(outputDir, { recursive: true });
   const content = format === "yaml" ? manifestToYaml(manifest) : manifestToJson(manifest);
   await fs13.writeFile(outputPath, content, "utf-8");
@@ -11552,7 +11052,7 @@ async function freshnessCommand(options) {
   const hasIssues = summary.stale > 0 || summary.warning > 0 || summary.unknown > 0;
   const output2 = options.format === "json" ? formatFreshnessJson(result) : formatFreshnessTable(result);
   if (options.output !== void 0) {
-    const outputDir = path17.dirname(options.output);
+    const outputDir = path14.dirname(options.output);
     await fs13.mkdir(outputDir, { recursive: true });
     await fs13.writeFile(options.output, output2, "utf-8");
     logger10.info(`Wrote freshness report to ${options.output}`);
@@ -11586,7 +11086,7 @@ async function linksCommand(options) {
   const hasBrokenLinks = summary.brokenLinks > 0;
   const output2 = options.format === "json" ? formatLinkValidationJson(result) : formatLinkValidationTable(result);
   if (options.output !== void 0) {
-    const outputDir = path17.dirname(options.output);
+    const outputDir = path14.dirname(options.output);
     await fs13.mkdir(outputDir, { recursive: true });
     await fs13.writeFile(options.output, output2, "utf-8");
     logger10.info(`Wrote link validation report to ${options.output}`);
@@ -12082,32 +11582,32 @@ function learningMetricsCommand(options, context) {
 }
 
 // src/cli/config-command-types.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var CONFIG_ACTIONS = ["get", "set", "list", "reset", "export", "import"];
 var CONFIG_FORMATS = ["json", "yaml"];
-var ConfigCommandOptionsSchema = z6.object({
+var ConfigCommandOptionsSchema = z5.object({
   /** Command action */
-  action: z6.enum(CONFIG_ACTIONS),
+  action: z5.enum(CONFIG_ACTIONS),
   /** Configuration key (dot notation supported) */
-  key: z6.string().optional(),
+  key: z5.string().optional(),
   /** Value to set */
-  value: z6.string().optional(),
+  value: z5.string().optional(),
   /** File path for import/export */
-  file: z6.string().optional(),
+  file: z5.string().optional(),
   /** Export format */
-  format: z6.enum(CONFIG_FORMATS).default("json"),
+  format: z5.enum(CONFIG_FORMATS).default("json"),
   /** Force overwrite without backup */
-  force: z6.boolean().default(false),
+  force: z5.boolean().default(false),
   /** Show verbose output */
-  verbose: z6.boolean().default(false)
+  verbose: z5.boolean().default(false)
 });
-var ParsedConfigKeySchema = z6.object({
+var ParsedConfigKeySchema = z5.object({
   /** Full key string */
-  fullKey: z6.string(),
+  fullKey: z5.string(),
   /** Category portion */
-  category: z6.string(),
+  category: z5.string(),
   /** Key within category */
-  key: z6.string()
+  key: z5.string()
 });
 var ConfigCommandError = class extends Error {
   code;
@@ -12123,7 +11623,7 @@ function isValidConfigAction(value) {
 
 // src/cli/config-command-helpers.ts
 import * as fs14 from "fs/promises";
-import * as path18 from "path";
+import * as path15 from "path";
 import { existsSync as existsSync10 } from "fs";
 
 // src/cli/config-command-formatting.ts
@@ -12391,10 +11891,10 @@ function parseValueFromString(stringValue, defaultValue) {
 }
 function resolveFilePath(filePath, allowedBase) {
   const base = allowedBase ?? process.cwd();
-  const resolved = path18.isAbsolute(filePath) ? filePath : path18.resolve(base, filePath);
-  const normalizedResolved = path18.normalize(resolved);
-  const normalizedBase = path18.normalize(base);
-  const isWithinBase = normalizedResolved === normalizedBase || normalizedResolved.startsWith(normalizedBase + path18.sep);
+  const resolved = path15.isAbsolute(filePath) ? filePath : path15.resolve(base, filePath);
+  const normalizedResolved = path15.normalize(resolved);
+  const normalizedBase = path15.normalize(base);
+  const isWithinBase = normalizedResolved === normalizedBase || normalizedResolved.startsWith(normalizedBase + path15.sep);
   if (!isWithinBase) {
     throw new ConfigCommandError(
       "PATH_TRAVERSAL",
@@ -12405,7 +11905,7 @@ function resolveFilePath(filePath, allowedBase) {
 }
 function getDefaultExportPath(format) {
   const extension = format === "json" ? "json" : "yaml";
-  return path18.resolve(process.cwd(), `nexus-config.${extension}`);
+  return path15.resolve(process.cwd(), `nexus-config.${extension}`);
 }
 
 // src/cli/config-command-handlers.ts
@@ -12775,8 +12275,8 @@ async function configCommand(options) {
 }
 
 // src/cli/hooks/hook-types.ts
-import { z as z7 } from "zod";
-var HookEventName = z7.enum([
+import { z as z6 } from "zod";
+var HookEventName = z6.enum([
   "SessionStart",
   "UserPromptSubmit",
   "PreToolUse",
@@ -12791,100 +12291,100 @@ var HookEventName = z7.enum([
   "Notification",
   "Setup"
 ]);
-var PermissionMode = z7.enum([
+var PermissionMode = z6.enum([
   "default",
   "plan",
   "acceptEdits",
   "dontAsk",
   "bypassPermissions"
 ]);
-var HookInputBaseSchema = z7.object({
-  session_id: z7.string(),
-  transcript_path: z7.string(),
-  cwd: z7.string(),
+var HookInputBaseSchema = z6.object({
+  session_id: z6.string(),
+  transcript_path: z6.string(),
+  cwd: z6.string(),
   permission_mode: PermissionMode,
   hook_event_name: HookEventName
 });
-var SessionStartSource = z7.enum(["startup", "resume", "clear", "compact"]);
+var SessionStartSource = z6.enum(["startup", "resume", "clear", "compact"]);
 var SessionStartInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("SessionStart"),
+  hook_event_name: z6.literal("SessionStart"),
   source: SessionStartSource,
-  model: z7.string().optional(),
-  agent_type: z7.string().optional()
+  model: z6.string().optional(),
+  agent_type: z6.string().optional()
 });
-var SessionEndReason = z7.enum(["clear", "logout", "prompt_input_exit", "other"]);
+var SessionEndReason = z6.enum(["clear", "logout", "prompt_input_exit", "other"]);
 var SessionEndInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("SessionEnd"),
+  hook_event_name: z6.literal("SessionEnd"),
   reason: SessionEndReason
 });
 var PreToolUseInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("PreToolUse"),
-  tool_name: z7.string(),
-  tool_input: z7.record(z7.string(), z7.unknown()),
-  tool_use_id: z7.string()
+  hook_event_name: z6.literal("PreToolUse"),
+  tool_name: z6.string(),
+  tool_input: z6.record(z6.string(), z6.unknown()),
+  tool_use_id: z6.string()
 });
 var PostToolUseInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("PostToolUse"),
-  tool_name: z7.string(),
-  tool_input: z7.record(z7.string(), z7.unknown()),
-  tool_response: z7.record(z7.string(), z7.unknown()),
-  tool_use_id: z7.string()
+  hook_event_name: z6.literal("PostToolUse"),
+  tool_name: z6.string(),
+  tool_input: z6.record(z6.string(), z6.unknown()),
+  tool_response: z6.record(z6.string(), z6.unknown()),
+  tool_use_id: z6.string()
 });
 var PostToolUseFailureInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("PostToolUseFailure"),
-  tool_name: z7.string(),
-  tool_input: z7.record(z7.string(), z7.unknown()),
-  tool_use_id: z7.string(),
-  error: z7.string().optional()
+  hook_event_name: z6.literal("PostToolUseFailure"),
+  tool_name: z6.string(),
+  tool_input: z6.record(z6.string(), z6.unknown()),
+  tool_use_id: z6.string(),
+  error: z6.string().optional()
 });
 var StopInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("Stop"),
-  stop_hook_active: z7.boolean()
+  hook_event_name: z6.literal("Stop"),
+  stop_hook_active: z6.boolean()
 });
 var SubagentStopInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("SubagentStop"),
-  stop_hook_active: z7.boolean(),
-  agent_id: z7.string(),
-  agent_transcript_path: z7.string()
+  hook_event_name: z6.literal("SubagentStop"),
+  stop_hook_active: z6.boolean(),
+  agent_id: z6.string(),
+  agent_transcript_path: z6.string()
 });
 var UserPromptSubmitInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("UserPromptSubmit"),
-  prompt: z7.string()
+  hook_event_name: z6.literal("UserPromptSubmit"),
+  prompt: z6.string()
 });
-var NotificationType = z7.enum([
+var NotificationType = z6.enum([
   "permission_prompt",
   "idle_prompt",
   "auth_success",
   "elicitation_dialog"
 ]);
 var NotificationInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("Notification"),
-  message: z7.string(),
+  hook_event_name: z6.literal("Notification"),
+  message: z6.string(),
   notification_type: NotificationType
 });
-var PreCompactTrigger = z7.enum(["manual", "auto"]);
+var PreCompactTrigger = z6.enum(["manual", "auto"]);
 var PreCompactInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("PreCompact"),
+  hook_event_name: z6.literal("PreCompact"),
   trigger: PreCompactTrigger,
-  custom_instructions: z7.string().optional()
+  custom_instructions: z6.string().optional()
 });
-var SetupTrigger = z7.enum(["init", "maintenance"]);
+var SetupTrigger = z6.enum(["init", "maintenance"]);
 var SetupInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("Setup"),
+  hook_event_name: z6.literal("Setup"),
   trigger: SetupTrigger
 });
 var SubagentStartInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("SubagentStart"),
-  agent_id: z7.string(),
-  agent_type: z7.string()
+  hook_event_name: z6.literal("SubagentStart"),
+  agent_id: z6.string(),
+  agent_type: z6.string()
 });
 var PermissionRequestInputSchema = HookInputBaseSchema.extend({
-  hook_event_name: z7.literal("PermissionRequest"),
-  tool_name: z7.string(),
-  tool_input: z7.record(z7.string(), z7.unknown()),
-  tool_use_id: z7.string()
+  hook_event_name: z6.literal("PermissionRequest"),
+  tool_name: z6.string(),
+  tool_input: z6.record(z6.string(), z6.unknown()),
+  tool_use_id: z6.string()
 });
-var HookInputSchema = z7.discriminatedUnion("hook_event_name", [
+var HookInputSchema = z6.discriminatedUnion("hook_event_name", [
   SessionStartInputSchema,
   SessionEndInputSchema,
   PreToolUseInputSchema,
@@ -12899,57 +12399,57 @@ var HookInputSchema = z7.discriminatedUnion("hook_event_name", [
   SubagentStartInputSchema,
   PermissionRequestInputSchema
 ]);
-var PermissionDecision = z7.enum(["allow", "deny", "ask"]);
-var HookDecision = z7.enum(["block"]);
-var HookOutputBaseSchema = z7.object({
-  continue: z7.boolean().optional(),
-  stopReason: z7.string().optional(),
-  suppressOutput: z7.boolean().optional(),
-  systemMessage: z7.string().optional()
+var PermissionDecision = z6.enum(["allow", "deny", "ask"]);
+var HookDecision = z6.enum(["block"]);
+var HookOutputBaseSchema = z6.object({
+  continue: z6.boolean().optional(),
+  stopReason: z6.string().optional(),
+  suppressOutput: z6.boolean().optional(),
+  systemMessage: z6.string().optional()
 });
 var PreToolUseOutputSchema = HookOutputBaseSchema.extend({
-  hookSpecificOutput: z7.object({
-    hookEventName: z7.literal("PreToolUse"),
+  hookSpecificOutput: z6.object({
+    hookEventName: z6.literal("PreToolUse"),
     permissionDecision: PermissionDecision.optional(),
-    permissionDecisionReason: z7.string().optional(),
-    updatedInput: z7.record(z7.string(), z7.unknown()).optional(),
-    additionalContext: z7.string().optional()
+    permissionDecisionReason: z6.string().optional(),
+    updatedInput: z6.record(z6.string(), z6.unknown()).optional(),
+    additionalContext: z6.string().optional()
   }).optional()
 });
 var PostToolUseOutputSchema = HookOutputBaseSchema.extend({
   decision: HookDecision.optional(),
-  reason: z7.string().optional(),
-  hookSpecificOutput: z7.object({
-    hookEventName: z7.literal("PostToolUse"),
-    additionalContext: z7.string().optional()
+  reason: z6.string().optional(),
+  hookSpecificOutput: z6.object({
+    hookEventName: z6.literal("PostToolUse"),
+    additionalContext: z6.string().optional()
   }).optional()
 });
 var StopOutputSchema = HookOutputBaseSchema.extend({
   decision: HookDecision.optional(),
-  reason: z7.string().optional()
+  reason: z6.string().optional()
 });
 var UserPromptSubmitOutputSchema = HookOutputBaseSchema.extend({
   decision: HookDecision.optional(),
-  reason: z7.string().optional(),
-  hookSpecificOutput: z7.object({
-    hookEventName: z7.literal("UserPromptSubmit"),
-    additionalContext: z7.string().optional()
+  reason: z6.string().optional(),
+  hookSpecificOutput: z6.object({
+    hookEventName: z6.literal("UserPromptSubmit"),
+    additionalContext: z6.string().optional()
   }).optional()
 });
 var SessionStartOutputSchema = HookOutputBaseSchema.extend({
-  hookSpecificOutput: z7.object({
-    hookEventName: z7.literal("SessionStart"),
-    additionalContext: z7.string().optional()
+  hookSpecificOutput: z6.object({
+    hookEventName: z6.literal("SessionStart"),
+    additionalContext: z6.string().optional()
   }).optional()
 });
 var PermissionRequestOutputSchema = HookOutputBaseSchema.extend({
-  hookSpecificOutput: z7.object({
-    hookEventName: z7.literal("PermissionRequest"),
-    decision: z7.object({
-      behavior: z7.enum(["allow", "deny"]),
-      updatedInput: z7.record(z7.string(), z7.unknown()).optional(),
-      message: z7.string().optional(),
-      interrupt: z7.boolean().optional()
+  hookSpecificOutput: z6.object({
+    hookEventName: z6.literal("PermissionRequest"),
+    decision: z6.object({
+      behavior: z6.enum(["allow", "deny"]),
+      updatedInput: z6.record(z6.string(), z6.unknown()).optional(),
+      message: z6.string().optional(),
+      interrupt: z6.boolean().optional()
     })
   }).optional()
 });
@@ -13035,7 +12535,7 @@ function writeResultAndExit(result) {
 
 // src/cli/hooks/hook-router.ts
 async function readStdin() {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve13, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("readable", () => {
@@ -13046,24 +12546,24 @@ async function readStdin() {
       }
     });
     process.stdin.on("end", () => {
-      resolve14(data);
+      resolve13(data);
     });
     process.stdin.on("error", (err2) => {
       reject(err2);
     });
     if (process.stdin.isTTY) {
-      resolve14("");
+      resolve13("");
     }
   });
 }
 async function readStdinWithTimeout(timeoutMs = 5e3) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve13, reject) => {
     const timeout2 = setTimeout(() => {
       reject(new Error(`Stdin read timeout after ${String(timeoutMs)}ms`));
     }, timeoutMs);
     readStdin().then((data) => {
       clearTimeout(timeout2);
-      resolve14(data);
+      resolve13(data);
     }).catch((err2) => {
       clearTimeout(timeout2);
       reject(err2 instanceof Error ? err2 : new Error(String(err2)));
@@ -14553,9 +14053,9 @@ function interactiveIO() {
     write: (text) => {
       process.stdout.write(text);
     },
-    prompt: (question) => new Promise((resolve14) => {
+    prompt: (question) => new Promise((resolve13) => {
       rl.question(question, (answer) => {
-        resolve14(answer.trim());
+        resolve13(answer.trim());
       });
     }),
     close: () => {
@@ -14577,8 +14077,8 @@ function scriptedIO() {
 // src/governance/claims-registry.ts
 import { existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml2 } from "yaml";
-import { z as z8 } from "zod";
-var VerificationMethodSchema = z8.enum([
+import { z as z7 } from "zod";
+var VerificationMethodSchema = z7.enum([
   "file-exists",
   "file-contains",
   "source-contains-all",
@@ -14586,7 +14086,7 @@ var VerificationMethodSchema = z8.enum([
   "manifest-tool-count",
   "roadmap-status"
 ]);
-var ClaimStatusSchema = z8.enum([
+var ClaimStatusSchema = z7.enum([
   "verified",
   // backed by live evidence the runner checks every CI run
   "partial",
@@ -14596,25 +14096,25 @@ var ClaimStatusSchema = z8.enum([
   "stale"
   // known-broken backing; tracked, must not regress to silent
 ]);
-var EvidenceTypeSchema = z8.enum(["test", "gate", "eval-artifact", "adr", "source"]);
-var VerificationSchema = z8.object({
+var EvidenceTypeSchema = z7.enum(["test", "gate", "eval-artifact", "adr", "source"]);
+var VerificationSchema = z7.object({
   method: VerificationMethodSchema,
   /** Repo-root-relative path to the live backing evidence. */
-  path: z8.string().min(1),
+  path: z7.string().min(1),
   /**
    * Expected value. Numeric for `enum-member-count` / `manifest-tool-count`,
    * string for `file-contains` / `roadmap-status`. Unused by `file-exists`.
    */
-  expected: z8.union([z8.number().int().nonnegative(), z8.string().min(1)]).optional(),
+  expected: z7.union([z7.number().int().nonnegative(), z7.string().min(1)]).optional(),
   /** Target symbol name (e.g. the exported `z.enum` const) for count methods. */
-  symbol: z8.string().min(1).optional(),
+  symbol: z7.string().min(1).optional(),
   /**
    * Literal the claim's `subject` doc must contain (#3877). When present, the
    * runner verifies the doc making the claim — not just the source of truth —
    * so README/ARCHITECTURE drift fails the gate. Omit only for claims whose
    * `subject` IS the verification `path` (e.g. `roadmap-status`).
    */
-  subjectContains: z8.string().min(1).optional()
+  subjectContains: z7.string().min(1).optional()
 }).strict().superRefine((v, ctx) => {
   const needsNumber = v.method === "enum-member-count" || v.method === "manifest-tool-count";
   const needsString = v.method === "file-contains" || v.method === "source-contains-all" || v.method === "roadmap-status";
@@ -14640,24 +14140,24 @@ var VerificationSchema = z8.object({
     });
   }
 });
-var ClaimEntrySchema = z8.object({
+var ClaimEntrySchema = z7.object({
   /** Stable, kebab-case identifier; never reused. */
-  id: z8.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+  id: z7.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
   /** Human-readable claim text (<=25 words). */
-  claim: z8.string().min(1).refine((s) => s.trim().split(/\s+/).length <= 25, "claim must be <=25 words"),
+  claim: z7.string().min(1).refine((s) => s.trim().split(/\s+/).length <= 25, "claim must be <=25 words"),
   /** Repo-root-relative doc that makes the claim (e.g. README.md). */
-  subject: z8.string().min(1),
+  subject: z7.string().min(1),
   status: ClaimStatusSchema,
   evidenceType: EvidenceTypeSchema,
   verification: VerificationSchema,
   /** ISO date (YYYY-MM-DD) the claim was last manually verified. */
-  lastVerified: z8.string().regex(/^\d{4}-\d{2}-\d{2}$/, "lastVerified must be YYYY-MM-DD"),
+  lastVerified: z7.string().regex(/^\d{4}-\d{2}-\d{2}$/, "lastVerified must be YYYY-MM-DD"),
   /** Optional caveat surfaced in reports (required-ish for `partial`). */
-  caveat: z8.string().optional()
+  caveat: z7.string().optional()
 }).strict();
-var ClaimsRegistrySchema = z8.object({
-  version: z8.number().int().positive(),
-  claims: z8.array(ClaimEntrySchema).min(1).superRefine((claims, ctx) => {
+var ClaimsRegistrySchema = z7.object({
+  version: z7.number().int().positive(),
+  claims: z7.array(ClaimEntrySchema).min(1).superRefine((claims, ctx) => {
     const seen = /* @__PURE__ */ new Set();
     for (const [i, c] of claims.entries()) {
       if (seen.has(c.id)) {
@@ -14674,7 +14174,7 @@ var ClaimsRegistrySchema = z8.object({
 
 // src/governance/claims-verify.ts
 import { existsSync as existsSync13, readFileSync as readFileSync7 } from "fs";
-import { isAbsolute as isAbsolute2, join as join12 } from "path";
+import { isAbsolute as isAbsolute2, join as join10 } from "path";
 
 // src/cli/fitness-audit.ts
 var COLORS = colors;
@@ -15879,7 +15379,7 @@ async function releaseAnnounceCommand(args) {
 
 // src/cli/scaffold.ts
 import * as fs16 from "fs";
-import * as path19 from "path";
+import * as path16 from "path";
 
 // src/cli/scaffold-templates.ts
 function toolImportsAndSchema(name, pascal) {
@@ -16215,8 +15715,8 @@ ${lines}`;
 function writeFiles(files) {
   const createdPaths = [];
   for (const file of files) {
-    const fullPath = path19.resolve(process.cwd(), file.path);
-    const dir = path19.dirname(fullPath);
+    const fullPath = path16.resolve(process.cwd(), file.path);
+    const dir = path16.dirname(fullPath);
     fs16.mkdirSync(dir, { recursive: true });
     if (fs16.existsSync(fullPath)) {
       return {
@@ -17013,11 +16513,11 @@ import {
   appendFileSync as appendFileSync2,
   readFileSync as readFileSync13
 } from "fs";
-import { resolve as resolve10, join as join16, isAbsolute as isAbsolute3 } from "path";
+import { resolve as resolve9, join as join14, isAbsolute as isAbsolute3 } from "path";
 
 // src/cli/mcp-config-emitter.ts
 import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync5, appendFileSync } from "fs";
-import { join as join13 } from "path";
+import { join as join11 } from "path";
 var MCP_CONFIG_FILENAME = ".mcp.json";
 var NEXUS_SERVER_KEY = "nexus-agents";
 function buildNexusServerEntry(dataDir, commandPath) {
@@ -17039,23 +16539,23 @@ function entriesEqual(a, b) {
   for (const k of aKeys) if (aEnv[k] !== bEnv[k]) return false;
   return true;
 }
-function loadExistingConfig(path21) {
-  if (!existsSync18(path21)) return { ok: true, value: void 0 };
+function loadExistingConfig(path18) {
+  if (!existsSync18(path18)) return { ok: true, value: void 0 };
   let raw;
   try {
-    raw = readFileSync11(path21, "utf-8");
+    raw = readFileSync11(path18, "utf-8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
   try {
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) {
-      return { ok: false, error: `${path21}: top-level JSON must be an object` };
+      return { ok: false, error: `${path18}: top-level JSON must be an object` };
     }
     return { ok: true, value: parsed };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
-    return { ok: false, error: `${path21}: invalid JSON \u2014 ${msg}` };
+    return { ok: false, error: `${path18}: invalid JSON \u2014 ${msg}` };
   }
 }
 function decideEmission(existing, desired, force) {
@@ -17077,9 +16577,9 @@ function decideEmission(existing, desired, force) {
   return { kind: "write", nextConfig: { ...existing, mcpServers: nextServers } };
 }
 function autoGitignoreMcpConfig(workspaceDir, dryRun) {
-  const gitDir = join13(workspaceDir, ".git");
+  const gitDir = join11(workspaceDir, ".git");
   if (!existsSync18(gitDir)) return false;
-  const gitignorePath = join13(workspaceDir, ".gitignore");
+  const gitignorePath = join11(workspaceDir, ".gitignore");
   let existing = "";
   if (existsSync18(gitignorePath)) {
     existing = readFileSync11(gitignorePath, "utf-8");
@@ -17094,7 +16594,7 @@ function autoGitignoreMcpConfig(workspaceDir, dryRun) {
   return true;
 }
 function emitMcpConfig(options) {
-  const mcpConfigPath = join13(options.workspaceDir, MCP_CONFIG_FILENAME);
+  const mcpConfigPath = join11(options.workspaceDir, MCP_CONFIG_FILENAME);
   const dryRun = options.dryRun === true;
   const force = options.force === true;
   const desired = buildNexusServerEntry(options.dataDir, options.commandPath);
@@ -17133,12 +16633,12 @@ function makeFailure(mcpConfigPath, error) {
 // src/cli/portable-installer.ts
 import { execFile as execFile2 } from "child_process";
 import { existsSync as existsSync20, mkdirSync as mkdirSync4, rmSync, writeFileSync as writeFileSync7 } from "fs";
-import { join as join15 } from "path";
+import { join as join13 } from "path";
 import { promisify as promisify2 } from "util";
 
 // src/cli/bin-shim.ts
 import { existsSync as existsSync19, readFileSync as readFileSync12, writeFileSync as writeFileSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join14 } from "path";
+import { join as join12 } from "path";
 var SHIM_BASENAME = "nexus-agents";
 var SHIM_MODE = 493;
 function buildShimContents(cliEntryPath) {
@@ -17152,7 +16652,7 @@ function buildShimContents(cliEntryPath) {
   return lines.join("\n");
 }
 function writeBinShim(options) {
-  const shimPath = join14(options.binDir, SHIM_BASENAME);
+  const shimPath = join12(options.binDir, SHIM_BASENAME);
   const desired = buildShimContents(options.cliEntryPath);
   const dryRun = options.dryRun === true;
   try {
@@ -17198,10 +16698,10 @@ function writeInstallManifest(cliDir, version) {
     description: "Local install root for portable nexus-agents (generated; do not commit)",
     dependencies: { "nexus-agents": version }
   };
-  writeFileSync7(join15(cliDir, "package.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  writeFileSync7(join13(cliDir, "package.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 function isAlreadyInstalled(cliDir) {
-  return existsSync20(join15(cliDir, "node_modules", "nexus-agents", "package.json"));
+  return existsSync20(join13(cliDir, "node_modules", "nexus-agents", "package.json"));
 }
 async function spawnNpmInstall(cliDir) {
   await execFileAsync2("npm", ["install", "--no-audit", "--no-fund", "--silent"], {
@@ -17228,8 +16728,8 @@ async function runNpmStep(ctx) {
   }
 }
 async function installPortable(options) {
-  const cliDir = join15(options.dataDir, CLI_SUBDIR);
-  const binDir = join15(options.dataDir, BIN_SUBDIR);
+  const cliDir = join13(options.dataDir, CLI_SUBDIR);
+  const binDir = join13(options.dataDir, BIN_SUBDIR);
   const versionResolution = resolveInstallVersion(options.version);
   if (!versionResolution.ok) {
     return {
@@ -17250,7 +16750,7 @@ async function installPortable(options) {
   }
   const npmFailure = await runNpmStep(ctx);
   if (npmFailure !== void 0) return npmFailure;
-  const shim = writeBinShim({ binDir, cliEntryPath: join15(cliDir, CLI_ENTRY_RELATIVE) });
+  const shim = writeBinShim({ binDir, cliEntryPath: join13(cliDir, CLI_ENTRY_RELATIVE) });
   if (!shim.success) {
     cleanupOnFailure(cliDir);
     return {
@@ -17264,8 +16764,8 @@ async function installPortable(options) {
   return { success: true, ...ctx, shim, skipped: false, error: null };
 }
 function uninstallPortable(options) {
-  const cliDir = join15(options.dataDir, CLI_SUBDIR);
-  const binDir = join15(options.dataDir, BIN_SUBDIR);
+  const cliDir = join13(options.dataDir, CLI_SUBDIR);
+  const binDir = join13(options.dataDir, BIN_SUBDIR);
   const removed = [];
   const notPresent = [];
   const dryRun = options.dryRun === true;
@@ -17285,7 +16785,7 @@ function uninstallPortable(options) {
   }
 }
 function findBinShim(dataDir) {
-  const shimPath = join15(dataDir, BIN_SUBDIR, "nexus-agents");
+  const shimPath = join13(dataDir, BIN_SUBDIR, "nexus-agents");
   return existsSync20(shimPath) ? shimPath : void 0;
 }
 
@@ -17294,9 +16794,9 @@ var DEFAULT_PORTABLE_DIRNAME = ".nexus-agents";
 var RESTRICTED_SUBDIRS = /* @__PURE__ */ new Set(["auth"]);
 function resolveTargetPath(rawPath) {
   if (rawPath === void 0 || rawPath === "") {
-    return resolve10(process.cwd(), DEFAULT_PORTABLE_DIRNAME);
+    return resolve9(process.cwd(), DEFAULT_PORTABLE_DIRNAME);
   }
-  return isAbsolute3(rawPath) ? rawPath : resolve10(process.cwd(), rawPath);
+  return isAbsolute3(rawPath) ? rawPath : resolve9(process.cwd(), rawPath);
 }
 function isNonEmpty(dir) {
   if (!existsSync21(dir)) return false;
@@ -17304,20 +16804,20 @@ function isNonEmpty(dir) {
   if (!stat2.isDirectory()) return true;
   return readdirSync(dir).length > 0;
 }
-function ensureDir(path21, dryRun, created, alreadyExisted, mode) {
-  if (existsSync21(path21)) {
-    alreadyExisted.push(path21);
+function ensureDir(path18, dryRun, created, alreadyExisted, mode) {
+  if (existsSync21(path18)) {
+    alreadyExisted.push(path18);
     return;
   }
   if (!dryRun) {
-    mkdirSync5(path21, { recursive: true, ...mode !== void 0 ? { mode } : {} });
+    mkdirSync5(path18, { recursive: true, ...mode !== void 0 ? { mode } : {} });
   }
-  created.push(path21);
+  created.push(path18);
 }
 function maybeUpdateGitignore(workspaceDir, portableDirName, dryRun) {
-  const gitDir = join16(workspaceDir, ".git");
+  const gitDir = join14(workspaceDir, ".git");
   if (!existsSync21(gitDir)) return false;
-  const gitignorePath = join16(workspaceDir, ".gitignore");
+  const gitignorePath = join14(workspaceDir, ".gitignore");
   const entry = `${portableDirName}/`;
   let existing = "";
   if (existsSync21(gitignorePath)) {
@@ -17338,14 +16838,14 @@ function inspectTarget(target) {
   if (!exists) return { exists: false, nonEmpty: false, isExistingNexusDir: false };
   const nonEmpty = isNonEmpty(target);
   const stat2 = statSync2(target);
-  const isExistingNexusDir = stat2.isDirectory() && existsSync21(join16(target, "audit"));
+  const isExistingNexusDir = stat2.isDirectory() && existsSync21(join14(target, "audit"));
   return { exists, nonEmpty, isExistingNexusDir };
 }
 function createDataLayout(target, dryRun, created, alreadyExisted) {
   ensureDir(target, dryRun, created, alreadyExisted);
   for (const subdir of DATA_SUBDIRECTORIES) {
     const mode = RESTRICTED_SUBDIRS.has(subdir) ? 448 : void 0;
-    ensureDir(join16(target, subdir), dryRun, created, alreadyExisted, mode);
+    ensureDir(join14(target, subdir), dryRun, created, alreadyExisted, mode);
   }
 }
 function makeResult(opts) {
@@ -17364,13 +16864,13 @@ function makeResult(opts) {
 }
 function applyGitignoreOption(target, options, dryRun) {
   if (options.gitignore !== true) return false;
-  const workspaceDir = resolve10(target, "..");
+  const workspaceDir = resolve9(target, "..");
   const portableName = target.slice(workspaceDir.length + 1);
   return maybeUpdateGitignore(workspaceDir, portableName, dryRun);
 }
 function applyMcpConfigOption(target, options, dryRun) {
   if (options.mcpConfig !== true) return void 0;
-  const workspaceDir = resolve10(target, "..");
+  const workspaceDir = resolve9(target, "..");
   const shimPath = findBinShim(target);
   return emitMcpConfig({
     workspaceDir,
@@ -17886,7 +17386,7 @@ function startImprovementReviewScheduler(options) {
   let running = false;
   const runOnce = async () => {
     try {
-      const { runImprovementReview: runImprovementReview2, ImprovementReviewInputSchema: ImprovementReviewInputSchema2 } = await import("./improvement-review-2W6LKP74.js");
+      const { runImprovementReview: runImprovementReview2, ImprovementReviewInputSchema: ImprovementReviewInputSchema2 } = await import("./improvement-review-DGQPADKS.js");
       const input = ImprovementReviewInputSchema2.parse({ fileIssues });
       const result = await runImprovementReview2(input, { logger: logger19 });
       logger19.info("Scheduled improvement_review complete", {
@@ -18307,8 +17807,8 @@ async function initUpstreamServers(gatewayConfig, server, logger19) {
     servers: upstreamServers.length,
     tools: tools.length
   });
-  const { z: z14 } = await import("zod");
-  const passthroughSchema = z14.looseObject({});
+  const { z: z13 } = await import("zod");
+  const passthroughSchema = z13.looseObject({});
   for (const tool of tools) {
     const toolName = tool.name;
     const desc = tool.description ?? `Upstream tool: ${toolName}`;
@@ -18463,6 +17963,7 @@ var HANDLER_TABLE = {
   verify_audit_chain: standardHandler("verify_audit_chain", registerVerifyAuditChainTool),
   extract_symbols: standardHandler("extract_symbols", registerExtractSymbolsTool),
   search_codebase: standardHandler("search_codebase", registerSearchCodebaseTool),
+  search_usages: standardHandler("search_usages", registerSearchUsagesTool),
   run_dev_pipeline: standardHandler("run_dev_pipeline", registerDevPipelineTool),
   run_pipeline: standardHandler("run_pipeline", registerPipelineTool),
   pr_review: (ctx) => {
@@ -18568,21 +18069,21 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // src/mcp/workspace-roots.ts
 import { existsSync as existsSync22 } from "fs";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 import { fileURLToPath } from "url";
 function deriveWorkspaceRootFromRoots(roots) {
   let first = null;
   let gitRoot = null;
   for (const root of roots) {
     if (typeof root.uri !== "string" || !root.uri.startsWith("file://")) continue;
-    let path21;
+    let path18;
     try {
-      path21 = fileURLToPath(root.uri);
+      path18 = fileURLToPath(root.uri);
     } catch {
       continue;
     }
-    first ??= path21;
-    if (gitRoot === null && existsSync22(join17(path21, ".git"))) gitRoot = path21;
+    first ??= path18;
+    if (gitRoot === null && existsSync22(join15(path18, ".git"))) gitRoot = path18;
   }
   return gitRoot ?? first;
 }
@@ -18765,7 +18266,7 @@ async function executeReplTask(task, options, logger19, rl) {
   }
 }
 function runOrchestratorRepl(options, logger19) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve13) => {
     const rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -18788,7 +18289,7 @@ function runOrchestratorRepl(options, logger19) {
     });
     rl.on("close", () => {
       logger19.info("Orchestrator REPL closed");
-      resolve14();
+      resolve13();
     });
   });
 }
@@ -19939,7 +19440,7 @@ function adaptConfigToLibrary(config) {
 }
 function createBeliefPromoter() {
   return async (event) => {
-    const { getToolMemory } = await import("./tool-memory-XJ5VRMNQ.js");
+    const { getToolMemory } = await import("./tool-memory-IV5BVIV4.js");
     const tm = getToolMemory();
     await tm.recordBelief(
       `skill:${event.name}`,
@@ -21115,7 +20616,7 @@ async function handleResearchCommand(args) {
   }
 }
 async function handleRegistryCommand(args) {
-  const { registryCommand, isValidRegistrySubcommand, formatRegistryUsage } = await import("./registry-command-5D2DJT53.js");
+  const { registryCommand, isValidRegistrySubcommand, formatRegistryUsage } = await import("./registry-command-VXXKVZ3H.js");
   const subcommand = args.subcommand;
   if (!isValidRegistrySubcommand(subcommand)) {
     process.stdout.write(`${formatRegistryUsage()}
@@ -21163,7 +20664,7 @@ async function handleVerifyCommand(args) {
 async function handleDoctorCommand(args) {
   const exitCode = await doctorCommand({ fix: args.options.fix });
   if (args.options.deep) {
-    const { runDeepDiagnostics: runDeepDiagnostics2, formatDeepDiagnostics: formatDeepDiagnostics2 } = await import("./doctor-deep-DALT3OXC.js");
+    const { runDeepDiagnostics: runDeepDiagnostics2, formatDeepDiagnostics: formatDeepDiagnostics2 } = await import("./doctor-deep-EULAHWTK.js");
     const diag = runDeepDiagnostics2();
     process.stdout.write(formatDeepDiagnostics2(diag) + "\n");
   }
@@ -21213,7 +20714,7 @@ async function runInitPortableFlow(args) {
   return cliExit(result.success ? EXIT_CODES.SUCCESS : EXIT_CODES.SERVER_START_FAILED);
 }
 async function runInitOpencodeFlow(args) {
-  const { runInitOpencode } = await import("./init-opencode-XVTVJ6FN.js");
+  const { runInitOpencode } = await import("./init-opencode-MK2NUEWH.js");
   const opencodePath = args.options.opencode;
   if (opencodePath === void 0 || opencodePath === "") {
     process.stderr.write("Error: --opencode requires a path argument.\n");
@@ -21239,7 +20740,7 @@ async function runInitOpencodeFlow(args) {
   return cliExit(EXIT_CODES.SUCCESS);
 }
 async function renderOpencodeValidate(opencodePath) {
-  const { runOpencodeValidate } = await import("./init-opencode-XVTVJ6FN.js");
+  const { runOpencodeValidate } = await import("./init-opencode-MK2NUEWH.js");
   const result = await runOpencodeValidate(opencodePath);
   if (!result.ok) {
     process.stderr.write(`init --opencode --validate: ${result.reason ?? "failed"}
@@ -21278,7 +20779,7 @@ async function handleSetupCommandAsync(args) {
   return cliExitFromStatus(exitCode);
 }
 async function runCustomApiSetup(args) {
-  const { configureCustomApi } = await import("./setup-custom-api-XRUPWEPF.js");
+  const { configureCustomApi } = await import("./setup-custom-api-2E4MZ5MF.js");
   const baseUrl = args.options.customApi;
   if (baseUrl === void 0) return EXIT_CODES.SERVER_START_FAILED;
   const input = {
@@ -21640,13 +21141,13 @@ function handleScaffoldCommand(args) {
 
 // src/cli/visualize-summary.ts
 import * as fs17 from "fs";
-import * as path20 from "path";
+import * as path17 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findPackageRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 5; i++) {
-    if (fs17.existsSync(path20.join(dir, "package.json"))) return dir;
-    const parent = path20.dirname(dir);
+    if (fs17.existsSync(path17.join(dir, "package.json"))) return dir;
+    const parent = path17.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -21657,7 +21158,7 @@ function countFiles(dir, pattern) {
   let count = 0;
   for (const entry of fs17.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
-      count += countFiles(path20.join(dir, entry.name), pattern);
+      count += countFiles(path17.join(dir, entry.name), pattern);
     } else if (entry.isFile() && pattern.test(entry.name)) {
       count++;
     }
@@ -21666,7 +21167,7 @@ function countFiles(dir, pattern) {
 }
 function readVersion(pkgRoot) {
   try {
-    const raw = fs17.readFileSync(path20.join(pkgRoot, "package.json"), "utf-8");
+    const raw = fs17.readFileSync(path17.join(pkgRoot, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return pkg.version ?? "unknown";
   } catch {
@@ -21687,13 +21188,13 @@ var LAYER_DIRS = [
 ];
 function gatherSystemSummary() {
   const thisFile = fileURLToPath2(import.meta.url);
-  const pkgRoot = findPackageRoot(path20.dirname(thisFile));
-  const srcDir = path20.resolve(pkgRoot, "src");
+  const pkgRoot = findPackageRoot(path17.dirname(thisFile));
+  const srcDir = path17.resolve(pkgRoot, "src");
   const allTs = countFiles(srcDir, /\.ts$/);
   const testTs = countFiles(srcDir, /\.test\.ts$/);
   const layers = LAYER_DIRS.map(({ name, dir }) => ({
     name,
-    files: countFiles(path20.join(srcDir, dir), /\.ts$/)
+    files: countFiles(path17.join(srcDir, dir), /\.ts$/)
   })).filter((l) => l.files > 0);
   return {
     version: readVersion(pkgRoot),
@@ -22851,7 +22352,7 @@ function handleStatusCommand2(args) {
 
 // src/cli/scenario-command.ts
 import { readdir as readdir4 } from "fs/promises";
-import { join as join19, resolve as resolve12 } from "path";
+import { join as join17, resolve as resolve11 } from "path";
 
 // src/testing/e2e/scenario-runner.ts
 import { readFile as readFile7 } from "fs/promises";
@@ -22982,9 +22483,9 @@ function checkCircularDependencies(workflow) {
   for (const step of workflow.steps) {
     stepMap.set(step.id, step);
   }
-  const visit = (stepId, path21) => {
+  const visit = (stepId, path18) => {
     if (visiting.has(stepId)) {
-      errors.push(`Circular dependency detected: ${[...path21, stepId].join(" -> ")}`);
+      errors.push(`Circular dependency detected: ${[...path18, stepId].join(" -> ")}`);
       return false;
     }
     if (visited.has(stepId)) return true;
@@ -22992,7 +22493,7 @@ function checkCircularDependencies(workflow) {
     const step = stepMap.get(stepId);
     if (step?.dependsOn) {
       for (const dep of step.dependsOn) {
-        if (!visit(dep, [...path21, stepId])) {
+        if (!visit(dep, [...path18, stepId])) {
           return false;
         }
       }
@@ -23011,7 +22512,7 @@ function checkCircularDependencies(workflow) {
 var defaultStubFactory = {
   createAgentStub(agentType, action) {
     return async (inputs) => {
-      await new Promise((resolve14) => setTimeout(resolve14, 10));
+      await new Promise((resolve13) => setTimeout(resolve13, 10));
       return {
         stepId: `${agentType}-${action}`,
         status: "success",
@@ -23036,8 +22537,8 @@ var ScenarioRunner = class {
   /**
    * Load a scenario fixture from a YAML file.
    */
-  async loadFixture(path21) {
-    const content = await readFile7(path21, "utf-8");
+  async loadFixture(path18) {
+    const content = await readFile7(path18, "utf-8");
     const data = yaml7.parse(content);
     return ScenarioFixtureSchema.parse(data);
   }
@@ -23170,7 +22671,7 @@ function createScenarioRunner(stubFactory) {
 }
 
 // src/cli/scenario-command.ts
-var FIXTURES_DIR = resolve12(import.meta.dirname, "../testing/e2e/fixtures");
+var FIXTURES_DIR = resolve11(import.meta.dirname, "../testing/e2e/fixtures");
 var SCENARIO_SUFFIX = ".scenario.yaml";
 async function listScenarios() {
   try {
@@ -23221,7 +22722,7 @@ async function handleRun(args) {
     return cliExit(EXIT_CODES.SERVER_START_FAILED);
   }
   const runner = createScenarioRunner();
-  const fixturePath = join19(FIXTURES_DIR, `${name}${SCENARIO_SUFFIX}`);
+  const fixturePath = join17(FIXTURES_DIR, `${name}${SCENARIO_SUFFIX}`);
   try {
     const fixture = await runner.loadFixture(fixturePath);
     const result = await runner.run(fixture);
@@ -23776,10 +23277,10 @@ function stripRefsPrefix(ref) {
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 import { writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { join as join20, dirname as dirname11 } from "path";
+import { join as join18, dirname as dirname9 } from "path";
 
 // src/mcp/tools/improvement-remediation-capability.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var PHASE_CAPABILITIES = {
   research: /* @__PURE__ */ new Set(["untrusted-input", "secrets"]),
   implement: /* @__PURE__ */ new Set(["repo-write", "secrets"])
@@ -23820,7 +23321,7 @@ var CapabilityLedger = class {
     }
   }
 };
-var RemediationActionKindSchema = z9.enum([
+var RemediationActionKindSchema = z8.enum([
   "investigate",
   "adjust-routing",
   "add-test",
@@ -23828,17 +23329,17 @@ var RemediationActionKindSchema = z9.enum([
   "update-docs",
   "fix-bug"
 ]);
-var RemediationStepSchema = z9.object({
+var RemediationStepSchema = z8.object({
   kind: RemediationActionKindSchema,
-  description: z9.string().min(1).max(500),
+  description: z8.string().min(1).max(500),
   /** Optional path hint; bounded inert string, validated for traversal at use. */
-  targetPath: z9.string().min(1).max(300).optional()
+  targetPath: z8.string().min(1).max(300).optional()
 }).strict();
-var RemediationPlanSchema = z9.object({
+var RemediationPlanSchema = z8.object({
   /** Source signal key (mirrors ImprovementSignal.signalKey). */
-  signalKey: z9.string().min(1).max(200),
+  signalKey: z8.string().min(1).max(200),
   /** Signal category (mirrors SignalCategory; 'tool-fitness' #3852, 'perf-regression' #3692). */
-  category: z9.enum([
+  category: z8.enum([
     "routing",
     "tech-debt",
     "bug",
@@ -23847,8 +23348,8 @@ var RemediationPlanSchema = z9.object({
     "tool-fitness",
     "perf-regression"
   ]),
-  summary: z9.string().min(1).max(1e3),
-  steps: z9.array(RemediationStepSchema).min(1).max(20)
+  summary: z8.string().min(1).max(1e3),
+  steps: z8.array(RemediationStepSchema).min(1).max(20)
 }).strict();
 function parseRemediationPlan(raw) {
   const result = RemediationPlanSchema.safeParse(raw);
@@ -23935,13 +23436,13 @@ function makeGitWorktreeOps(repoRoot) {
   };
   return {
     async addWorktree(branch, baseBranch) {
-      const path21 = join20(repoRoot, ".nexus-worktrees", branch.replace(/\//g, "_"));
-      await git2(["worktree", "add", "-b", branch, path21, baseBranch], repoRoot);
-      return path21;
+      const path18 = join18(repoRoot, ".nexus-worktrees", branch.replace(/\//g, "_"));
+      await git2(["worktree", "add", "-b", branch, path18, baseBranch], repoRoot);
+      return path18;
     },
     async writeFileIn(worktreePath, relPath, content) {
-      const abs = join20(worktreePath, relPath);
-      await mkdir5(dirname11(abs), { recursive: true });
+      const abs = join18(worktreePath, relPath);
+      await mkdir5(dirname9(abs), { recursive: true });
       await writeFile6(abs, content, "utf8");
     },
     async commitAll(worktreePath, message) {
@@ -23978,25 +23479,25 @@ function makeGhPrCreator() {
 }
 
 // src/mcp/tools/remediation-review.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 function soakRefOf(record) {
   return `${record.signalKey}::${record.timestamp}`;
 }
-var ReviewRecordSchema = z10.object({
+var ReviewRecordSchema = z9.object({
   /** Reference to the reviewed soak selection (`signalKey::timestamp`). */
-  soakRef: z10.string(),
+  soakRef: z9.string(),
   /** ISO-8601 time the review was recorded. */
-  reviewedAt: z10.string(),
+  reviewedAt: z9.string(),
   /** Always true — a persisted record is, by construction, a review. */
-  reviewed: z10.literal(true),
+  reviewed: z9.literal(true),
   /** Whether the evaluator assessed the selection SOUND. */
-  sound: z10.boolean(),
+  sound: z9.boolean(),
   /** Named evaluator who performed the review (required — the gate's named-evaluator criterion). */
-  evaluator: z10.string().min(1),
+  evaluator: z9.string().min(1),
   /** Named owner accepting enforcement, recorded at sign-off time (optional per record). */
-  owner: z10.string().min(1).optional(),
+  owner: z9.string().min(1).optional(),
   /** Free-text note (secret-scrubbed). */
-  note: z10.string().optional()
+  note: z9.string().optional()
 });
 var REVIEW_MAX_RECORDS = 1e4;
 function getRemediationReviewFile() {
@@ -24141,14 +23642,14 @@ import { createHash as createHash4 } from "crypto";
 import { createHash as createHash3 } from "crypto";
 import { mkdtempSync, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, rmSync as rmSync2, realpathSync as realpathSync2 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname13, join as join21 } from "path";
+import { dirname as dirname11, join as join19 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 
 // src/mcp/tools/codepr-guards.ts
 import { realpathSync } from "fs";
-import { isAbsolute as isAbsolute4, resolve as resolve13, relative as relative5, sep as sep3, dirname as dirname12, basename as basename5 } from "path";
-import { z as z11 } from "zod";
+import { isAbsolute as isAbsolute4, resolve as resolve12, relative as relative4, sep as sep3, dirname as dirname10, basename as basename4 } from "path";
+import { z as z10 } from "zod";
 function deny(reason, detail) {
   return { ok: false, reason, detail };
 }
@@ -24169,7 +23670,7 @@ function confinePath(worktreeRoot, candidatePath, realpath = realpathSync) {
   } catch {
     return deny("path_escape", "worktreeRoot could not be resolved (fail-closed)");
   }
-  const joined = isAbsolute4(candidatePath) ? candidatePath : resolve13(resolvedRoot, candidatePath);
+  const joined = isAbsolute4(candidatePath) ? candidatePath : resolve12(resolvedRoot, candidatePath);
   const reassembled = resolveNewFilePath(joined, realpath);
   if (reassembled === void 0) {
     return deny("path_escape", "candidate path could not be resolved (fail-closed)");
@@ -24188,17 +23689,17 @@ function resolveNewFilePath(joined, realpath) {
       break;
     } catch (err2) {
       if (errnoCode(err2) !== "ENOENT") return void 0;
-      const parent = dirname12(existing);
+      const parent = dirname10(existing);
       if (parent === existing) return void 0;
-      trailing.push(basename5(existing));
+      trailing.push(basename4(existing));
       existing = parent;
     }
   }
-  return trailing.length === 0 ? existing : resolve13(existing, ...trailing.reverse());
+  return trailing.length === 0 ? existing : resolve12(existing, ...trailing.reverse());
 }
 function isWithin(parent, child) {
   if (child === parent) return true;
-  const rel = relative5(parent, child);
+  const rel = relative4(parent, child);
   if (rel === "") return true;
   if (rel === ".." || rel.startsWith(".." + sep3)) return false;
   if (isAbsolute4(rel)) return false;
@@ -24294,11 +23795,11 @@ function classifyPath(relPath) {
   }
   return { sensitive: false };
 }
-var BlastRadiusLimitsSchema = z11.object({
+var BlastRadiusLimitsSchema = z10.object({
   /** Max number of files the change may touch. Default 20. */
-  maxFiles: z11.number().int().positive().default(20),
+  maxFiles: z10.number().int().positive().default(20),
   /** Max total changed lines (added + removed across all files). Default 400. */
-  maxLines: z11.number().int().positive().default(400)
+  maxLines: z10.number().int().positive().default(400)
 }).strict();
 var DEFAULT_BLAST_RADIUS_LIMITS = Object.freeze(
   BlastRadiusLimitsSchema.parse({})
@@ -24376,13 +23877,13 @@ function auditAutonomousEvent(logger19, record) {
   }
   return { ok: true };
 }
-var ResourceBudgetLimitsSchema = z11.object({
+var ResourceBudgetLimitsSchema = z10.object({
   /** Wall-clock ceiling in ms. Default 600000 (10 min). */
-  maxWallClockMs: z11.number().int().positive().default(6e5),
+  maxWallClockMs: z10.number().int().positive().default(6e5),
   /** Token ceiling. Default 200000. */
-  maxTokens: z11.number().int().positive().default(2e5),
+  maxTokens: z10.number().int().positive().default(2e5),
   /** Tool-call ceiling. Default 200. */
-  maxToolCalls: z11.number().int().positive().default(200)
+  maxToolCalls: z10.number().int().positive().default(200)
 }).strict();
 var DEFAULT_RESOURCE_BUDGET_LIMITS = Object.freeze(
   ResourceBudgetLimitsSchema.parse({})
@@ -24442,19 +23943,19 @@ function runGuard(name, fn) {
 }
 
 // src/mcp/tools/codepr-orchestrator.ts
-var ProposedChangeSchema = z12.object({
+var ProposedChangeSchema = z11.object({
   /** Repo-relative path the change would write. */
-  relPath: z12.string().min(1),
+  relPath: z11.string().min(1),
   /** The full new file content. */
-  newContent: z12.string()
+  newContent: z11.string()
 }).strict();
-var CodePrRunInputSchema = z12.object({
+var CodePrRunInputSchema = z11.object({
   /** Correlates all audit events for this run. */
-  runId: z12.string().min(1),
+  runId: z11.string().min(1),
   /** Hash of the source signal (fitness/improvement) that triggered the run. */
-  sourceSignalHash: z12.string().min(1),
+  sourceSignalHash: z11.string().min(1),
   /** The proposed change set. */
-  changes: z12.array(ProposedChangeSchema).min(1)
+  changes: z11.array(ProposedChangeSchema).min(1)
 }).strict();
 var ORCHESTRATOR_USAGE_ZERO = { wallClockMs: 0, tokens: 0, toolCalls: 0 };
 function sha256(s) {
@@ -24471,9 +23972,9 @@ function parseNumstat(numstat) {
     if (parts.length < 3) continue;
     const added = parts[0] === "-" ? 0 : Number.parseInt(parts[0] ?? "0", 10);
     const removed = parts[1] === "-" ? 0 : Number.parseInt(parts[1] ?? "0", 10);
-    const path21 = parts.slice(2).join("	");
+    const path18 = parts.slice(2).join("	");
     files.push({
-      path: path21,
+      path: path18,
       addedLines: Number.isFinite(added) ? added : 0,
       removedLines: Number.isFinite(removed) ? removed : 0
     });
@@ -24528,7 +24029,7 @@ function applyChanges(worktreeRoot, run) {
   for (const change of run.changes) {
     const confined = confinePath(worktreeRoot, change.relPath);
     if (!confined.ok) throw new Error(`apply: ${confined.detail}`);
-    mkdirSync6(dirname13(confined.resolvedPath), { recursive: true });
+    mkdirSync6(dirname11(confined.resolvedPath), { recursive: true });
     writeFileSync8(confined.resolvedPath, change.newContent);
   }
 }
@@ -24590,8 +24091,8 @@ function runGuardsAndPlan(args, logger19) {
 function runInWorktree(run, logger19, options, handle) {
   const fault = options.faultInjector;
   const repoRoot = options.repoRoot ?? process.cwd();
-  handle.tempParent = realpathSync2(mkdtempSync(join21(tmpdir(), "codepr-orchestrator-")));
-  handle.worktreeRoot = join21(handle.tempParent, "wt");
+  handle.tempParent = realpathSync2(mkdtempSync(join19(tmpdir(), "codepr-orchestrator-")));
+  handle.worktreeRoot = join19(handle.tempParent, "wt");
   git(repoRoot, ["worktree", "add", "--detach", handle.worktreeRoot]);
   fault?.("after-worktree");
   const precheck = precheckChanges(handle.worktreeRoot, run, logger19);
@@ -24657,20 +24158,20 @@ function planCodePrRun(input, logger19, options = {}) {
 }
 
 // src/mcp/tools/codepr-soak-store.ts
-import { z as z13 } from "zod";
-var CodePrSoakRecordSchema = z13.object({
+import { z as z12 } from "zod";
+var CodePrSoakRecordSchema = z12.object({
   /** ISO-8601 capture time. */
-  timestamp: z13.string(),
+  timestamp: z12.string(),
   /** Correlates the data point to the dry-run's orchestrator runId. */
-  runId: z13.string(),
+  runId: z12.string(),
   /** The improvement signal's stable key that triggered the dry-run. */
-  signalKey: z13.string(),
+  signalKey: z12.string(),
   /** True when the dry-run plan succeeded with ZERO guard denial. */
-  green: z13.boolean(),
+  green: z12.boolean(),
   /** The guard denial reason when `green` is false; omitted for a green plan. */
-  denialReason: z13.string().optional(),
+  denialReason: z12.string().optional(),
   /** Files the dry-run plan touched (0 on denial before the diff was realized). */
-  filesTouched: z13.number().int().nonnegative()
+  filesTouched: z12.number().int().nonnegative()
 }).strict();
 var CODEPR_SOAK_MAX_RECORDS = 1e4;
 function getCodePrSoakFile() {
@@ -24736,11 +24237,11 @@ function deriveProposedChanges(plan) {
   const changes = [];
   for (const step of plan.steps) {
     if (!CODE_TOUCHING_KINDS.has(step.kind)) continue;
-    const path21 = step.targetPath !== void 0 && step.targetPath !== "" ? step.targetPath : placeholderPathFor(plan, step.kind);
-    if (seen.has(path21)) continue;
-    seen.add(path21);
+    const path18 = step.targetPath !== void 0 && step.targetPath !== "" ? step.targetPath : placeholderPathFor(plan, step.kind);
+    if (seen.has(path18)) continue;
+    seen.add(path18);
     changes.push({
-      relPath: path21,
+      relPath: path18,
       newContent: `// codepr soak dry-run placeholder for ${plan.signalKey} (${step.kind})
 `
     });
@@ -25016,11 +24517,11 @@ var PROTECTED_PATH_FRAGMENTS = [
   "secret",
   "credential"
 ];
-function normalize2(path21) {
-  return path21.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+function normalize2(path18) {
+  return path18.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
 }
-function isProtectedPath(path21) {
-  const p = normalize2(path21);
+function isProtectedPath(path18) {
+  const p = normalize2(path18);
   return PROTECTED_PATH_FRAGMENTS.some((frag) => p.includes(frag));
 }
 function planTouchesProtectedPath(plan) {
@@ -25460,16 +24961,16 @@ async function handleRemediationReviewCommand(args) {
 // src/cli/migrate-command.ts
 import { cpSync, existsSync as existsSync24, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
 import { homedir } from "os";
-import { join as join22 } from "path";
+import { join as join20 } from "path";
 var logger18 = createLogger({ component: "migrate-command" });
-var HOMEDIR_DEFAULT_BASE = join22(homedir(), ".nexus-agents");
+var HOMEDIR_DEFAULT_BASE = join20(homedir(), ".nexus-agents");
 function countItems(dir) {
   if (!existsSync24(dir)) return 0;
   try {
     const entries = readdirSync3(dir, { withFileTypes: true });
     let n = 0;
     for (const e of entries) {
-      const p = join22(dir, e.name);
+      const p = join20(dir, e.name);
       if (e.isDirectory()) {
         n += countItems(p);
       } else {
@@ -25524,8 +25025,8 @@ function checkEarlyExits(fromBase, toBase, dryRun) {
   return null;
 }
 function planAndExecuteEntry(name, fromBase, toBase, perRepoSet, dryRun) {
-  const source = join22(fromBase, name);
-  const target = join22(toBase, name);
+  const source = join20(fromBase, name);
+  const target = join20(toBase, name);
   if (!perRepoSet.has(name)) {
     return { subdir: name, status: "skipped-not-per-repo", source, target: "", itemsCopied: 0 };
   }
@@ -25545,7 +25046,7 @@ function planAndExecuteEntry(name, fromBase, toBase, perRepoSet, dryRun) {
 function resolveDefaultTarget(cwd) {
   const repoRoot = findRepoRoot(cwd);
   if (repoRoot === null) return null;
-  return join22(repoRoot, ".nexus-agents");
+  return join20(repoRoot, ".nexus-agents");
 }
 function formatMigrationResult(result) {
   if (!result.success) {
@@ -25588,7 +25089,7 @@ async function handleMigrateCommand(args) {
 
 // src/cli/first-run-hint.ts
 import { existsSync as existsSync25, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname14 } from "path";
+import { dirname as dirname12 } from "path";
 var HINT_SUPPRESSED_COMMANDS = /* @__PURE__ */ new Set(["version", "help", "setup"]);
 function firstRunMarkerPath() {
   return nexusSharedPath(".first-run-done");
@@ -25605,7 +25106,7 @@ function maybeShowFirstRunHint(command) {
     "\x1B[36mnexus-agents\x1B[0m: First time? Run \x1B[1mnexus-agents setup\x1B[0m to configure.\n  (This one-time hint is now dismissed.)\n"
   );
   try {
-    mkdirSync8(dirname14(marker), { recursive: true });
+    mkdirSync8(dirname12(marker), { recursive: true });
     writeFileSync9(marker, `${(/* @__PURE__ */ new Date()).toISOString()}
 `, { flag: "w" });
   } catch {