nexus-agents 2.167.1 → 2.169.0

package/dist/{chunk-ZSUN7BHE.js → chunk-XGNB7LQB.js}

@@ -1,21 +1,22 @@
 import {
   resolveToken
-} from "./chunk-UNIDAVVR.js";
+} from "./chunk-3JH3FMEJ.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
   loadPapersRegistry,
   loadTechniquesRegistry,
   savePapersRegistry
-} from "./chunk-PC4Y4VPX.js";
+} from "./chunk-HAVBBSYN.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
 import {
   getToolMemory
-} from "./chunk-KM3YEIEN.js";
+} from "./chunk-Q3UMNYV2.js";
 import {
-  capitalizeWords
+  capitalizeWords,
+  truncateSentence
 } from "./chunk-6T3EPABN.js";
 import {
   extractSystemPrompt,
@@ -37,7 +38,7 @@ import {
   getTimeProvider,
   ok,
   registerPersistentDistillerFactory
-} from "./chunk-CURHM4TH.js";
+} from "./chunk-QXSR5KPG.js";
 import {
   ensureLearningDir,
   getRulesFile
@@ -2831,6 +2832,662 @@ function getTokenLedger() {
   return singleton;
 }
 
+// src/indexer/category-detection.ts
+import * as path4 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(path4.basename(filePath), path4.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 path5 from "path";
+
+// src/indexer/types.ts
+import { z as z6 } from "zod";
+var SCHEMA_VERSION = "1.0";
+var ExportEntrySchema = z6.object({
+  name: z6.string(),
+  kind: z6.enum(["type", "interface", "class", "function", "const", "enum", "unknown"]),
+  isReExport: z6.boolean(),
+  sourceModule: z6.string().optional()
+});
+var DependencyEntrySchema = z6.object({
+  specifier: z6.string(),
+  isExternal: z6.boolean(),
+  imports: z6.array(z6.string()).readonly()
+});
+var FileEntrySchema = z6.object({
+  path: z6.string(),
+  lines: z6.number().int().nonnegative(),
+  category: z6.enum(["types", "implementation", "test", "config", "cli", "util", "index"]),
+  exports: z6.array(ExportEntrySchema).readonly(),
+  dependencies: z6.array(DependencyEntrySchema).readonly(),
+  description: z6.string().optional()
+});
+var ModuleStatsSchema = z6.object({
+  fileCount: z6.number().int().nonnegative(),
+  totalLines: z6.number().int().nonnegative(),
+  exportCount: z6.number().int().nonnegative(),
+  internalDeps: z6.number().int().nonnegative(),
+  externalDeps: z6.number().int().nonnegative()
+});
+var ModuleEntrySchema = z6.object({
+  name: z6.string(),
+  path: z6.string(),
+  purpose: z6.string(),
+  files: z6.array(FileEntrySchema).readonly(),
+  stats: ModuleStatsSchema,
+  dependsOn: z6.array(z6.string()).readonly()
+});
+var IndexStatsSchema = z6.object({
+  totalFiles: z6.number().int().nonnegative(),
+  totalLines: z6.number().int().nonnegative(),
+  totalExports: z6.number().int().nonnegative(),
+  moduleCount: z6.number().int().nonnegative(),
+  externalPackages: z6.array(z6.string()).readonly()
+});
+var CodebaseIndexSchema = z6.object({
+  schemaVersion: z6.literal(SCHEMA_VERSION),
+  generatedAt: z6.string(),
+  stats: IndexStatsSchema,
+  modules: z6.record(z6.string(), ModuleEntrySchema)
+});
+var DEFAULT_EXTRACTOR_OPTIONS = {
+  rootDir: "src",
+  include: ["**/*.ts"],
+  exclude: ["**/*.test.ts", "**/*.d.ts", "**/node_modules/**"],
+  extractDescriptions: true
+};
+
+// src/indexer/project-extraction.ts
+function extractFileEntry(sourceFile, rootDir, extractDescriptions) {
+  const absolutePath = sourceFile.getFilePath();
+  const relativePath = path5.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 = path5.resolve(process.cwd(), opts.rootDir);
+  const includePatterns = opts.include.map((p) => path5.join(rootDir, p));
+  const excludePatterns = opts.exclude.map((p) => `!${path5.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 path6 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 = path6.join(path6.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/context/repo-map.ts
+var REPO_MAP_FLAG = "NEXUS_REPO_MAP";
+var DEFAULT_REPO_MAP_TOKEN_BUDGET = 400;
+var REPO_MAP_CAVEAT = "Import-graph only: edges are module import dependencies + declaration names, NOT call-site/usage data. Centrality reflects import structure, not runtime call frequency \u2014 do not treat this as a call graph (call-site edges tracked in #4249-A).";
+var REPO_MAP_HEADER = "## Repo Map (module import graph \u2014 PageRank-ranked)";
+var PAGERANK_DAMPING = 0.85;
+var PAGERANK_MAX_ITERATIONS = 100;
+var PAGERANK_EPSILON = 1e-6;
+function computeModulePageRank(modules) {
+  const names = Object.keys(modules);
+  const n = names.length;
+  if (n === 0) return /* @__PURE__ */ new Map();
+  const outEdges = buildOutEdges(modules, names);
+  let ranks = new Map(names.map((name) => [name, 1 / n]));
+  for (let iter = 0; iter < PAGERANK_MAX_ITERATIONS; iter++) {
+    const next = pageRankStep(names, outEdges, ranks, n);
+    if (l1Delta(ranks, next) < PAGERANK_EPSILON) return next;
+    ranks = next;
+  }
+  return ranks;
+}
+function buildOutEdges(modules, names) {
+  const known = new Set(names);
+  const out = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const deps = modules[name]?.dependsOn ?? [];
+    out.set(
+      name,
+      deps.filter((d) => known.has(d) && d !== name)
+    );
+  }
+  return out;
+}
+function pageRankStep(names, outEdges, ranks, n) {
+  const danglingShare = PAGERANK_DAMPING * sumDanglingRank(names, outEdges, ranks) / n;
+  const base = (1 - PAGERANK_DAMPING) / n + danglingShare;
+  const next = new Map(names.map((name) => [name, base]));
+  for (const src of names) {
+    const targets = outEdges.get(src) ?? [];
+    if (targets.length === 0) continue;
+    const share = PAGERANK_DAMPING * (ranks.get(src) ?? 0) / targets.length;
+    for (const t of targets) {
+      next.set(t, (next.get(t) ?? 0) + share);
+    }
+  }
+  return next;
+}
+function sumDanglingRank(names, outEdges, ranks) {
+  let sum = 0;
+  for (const name of names) {
+    if ((outEdges.get(name) ?? []).length === 0) sum += ranks.get(name) ?? 0;
+  }
+  return sum;
+}
+function l1Delta(a, b) {
+  let d = 0;
+  for (const [k, v] of a) d += Math.abs(v - (b.get(k) ?? 0));
+  return d;
+}
+function rankRepoMapEntries(index) {
+  const ranks = computeModulePageRank(index.modules);
+  const entries = Object.entries(index.modules).map(([name, mod]) => ({
+    module: name,
+    centrality: ranks.get(name) ?? 0,
+    purpose: mod.purpose,
+    dependsOn: mod.dependsOn,
+    fileCount: mod.stats.fileCount
+  }));
+  return entries.sort(
+    (a, b) => b.centrality !== a.centrality ? b.centrality - a.centrality : a.module.localeCompare(b.module)
+  );
+}
+var CHARS_PER_TOKEN3 = 4;
+var MAX_DEPS_PER_LINE = 6;
+var MAX_LINE_CHARS = 200;
+function buildRepoMap(index, options = {}) {
+  const entries = rankRepoMapEntries(index);
+  if (entries.length === 0) return "";
+  const budget = options.budgetTokens ?? DEFAULT_REPO_MAP_TOKEN_BUDGET;
+  return renderRepoMap(entries, budget);
+}
+function renderRepoMap(entries, budgetTokens) {
+  const preamble = `${REPO_MAP_HEADER}
+> ${REPO_MAP_CAVEAT}`;
+  const lines = entries.map(formatEntryLine);
+  const { kept, omitted } = fitLinesWithinBudget(lines, budgetTokens);
+  const bodyText = kept.length > 0 ? clampToTokenBudget(kept.join("\n"), budgetTokens).text : "";
+  const body = bodyText === "" ? "" : `
+${bodyText}`;
+  const notice = omitted > 0 ? `
+_(+${String(omitted)} lower-centrality modules omitted for the ~${String(budgetTokens)}-token module budget \u2014 #4254)_` : "";
+  return `${preamble}${body}${notice}`;
+}
+function formatEntryLine(e) {
+  const shownDeps = e.dependsOn.slice(0, MAX_DEPS_PER_LINE);
+  const more = e.dependsOn.length > MAX_DEPS_PER_LINE ? ", \u2026" : "";
+  const deps = shownDeps.length > 0 ? ` \u2192 ${shownDeps.join(", ")}${more}` : "";
+  const line = `- ${e.module} (centrality ${e.centrality.toFixed(3)}, ${String(e.fileCount)} files): ${oneLine2(e.purpose)}${deps}`;
+  return line.slice(0, MAX_LINE_CHARS);
+}
+function fitLinesWithinBudget(lines, budgetTokens) {
+  let used = 0;
+  const kept = [];
+  for (const line of lines) {
+    const cost = estimateTokens2(line) + 1;
+    if (used + cost > budgetTokens) break;
+    used += cost;
+    kept.push(line);
+  }
+  return { kept, omitted: lines.length - kept.length };
+}
+function estimateTokens2(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN3);
+}
+function oneLine2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+var STRUCTURAL_CATEGORIES = /* @__PURE__ */ new Set([
+  "architecture",
+  "planning",
+  "code_generation",
+  "code_review",
+  "security_review"
+]);
+var STRUCTURAL_TASK_PATTERN = /architect|refactor|depend|module|cross[- ]file|structure|integrat|migrat|coupl|call ?graph|import ?graph|repo.?map|entry ?point|wiring|data ?flow/i;
+function taskNeedsRepoMap(task, category) {
+  if (STRUCTURAL_CATEGORIES.has(category)) return true;
+  return STRUCTURAL_TASK_PATTERN.test(task);
+}
+function getRepoMapForTask(options) {
+  if (process.env[REPO_MAP_FLAG] !== "1") return void 0;
+  if (!taskNeedsRepoMap(options.task, options.category)) return void 0;
+  const log = options.logger ?? createLogger({ component: "RepoMap" });
+  try {
+    const index = (options.indexProvider ?? buildLiveIndex)();
+    const map = buildRepoMap(index, {
+      budgetTokens: options.budgetTokens ?? DEFAULT_REPO_MAP_TOKEN_BUDGET
+    });
+    return map === "" ? void 0 : map;
+  } catch (error) {
+    log.debug("repo-map build failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
+function buildLiveIndex() {
+  const extraction = extractProject({ extractDescriptions: false });
+  return buildIndex(extraction.files);
+}
+
 // src/context/context-retriever.ts
 var DEFAULT_LIMIT = 5;
 async function getContextForTask(options) {
@@ -2862,7 +3519,12 @@ async function getContextForTask(options) {
     priorStrategies,
     researchInsights
   };
-  return { ...base, rankedMemories: rankMemories({ ...base, rankedMemories: [] }, options.task) };
+  const result = {
+    ...base,
+    rankedMemories: rankMemories({ ...base, rankedMemories: [] }, options.task)
+  };
+  const repoMap = getRepoMapForTask({ task: options.task, category: options.category, logger });
+  return repoMap === void 0 ? result : { ...result, repoMap };
 }
 var MIN_RELEVANCE_TOKEN = 4;
 function selectRelevantResearch(techniques, task, limit) {
@@ -2986,7 +3648,7 @@ function inferTaskCategory(task) {
   return "exploration";
 }
 var MAX_SUMMARY_FIELD = 200;
-function oneLine2(value) {
+function oneLine3(value) {
   return value.replace(/\s+/g, " ").trim().slice(0, MAX_SUMMARY_FIELD);
 }
 function summarizeContextForPrompt(ctx, budgetTokens = DEFAULT_CONTEXT_BUDGET_TOKENS) {
@@ -2994,7 +3656,24 @@ function summarizeContextForPrompt(ctx, budgetTokens = DEFAULT_CONTEXT_BUDGET_TO
   const rendered = ranked ? summarizeRankedContext(ctx) : summarizeLegacyContext(ctx);
   const clamped = clampRenderedContext(rendered, budgetTokens);
   recordAssembledContextTokens(clamped, ranked);
-  return clamped;
+  return appendRepoMapSection(clamped, ctx);
+}
+function appendRepoMapSection(memoryBlock, ctx) {
+  const map = ctx.repoMap;
+  if (map === void 0 || map === "") return memoryBlock;
+  recordRepoMapTokens(map);
+  return memoryBlock === "" ? map : `${memoryBlock}
+
+${map}`;
+}
+var REPO_MAP_LEDGER_VARIANT = `${REPO_MAP_FLAG}=1`;
+function recordRepoMapTokens(rendered) {
+  getTokenLedger().record({
+    tool: "context-retriever.summarizeContextForPrompt",
+    contextSource: "repo-map",
+    inputTokens: contextTokenCounter.estimate(rendered),
+    variant: REPO_MAP_LEDGER_VARIANT
+  });
 }
 var contextTokenCounter = createTokenCounter();
 function recordAssembledContextTokens(rendered, ranked) {
@@ -3021,19 +3700,19 @@ function summarizeLegacyContext(ctx) {
   const sections = [];
   if (ctx.beliefs.length > 0) {
     const lines = ctx.beliefs.slice(0, 5).map(
-      (b) => `- ${oneLine2(b.subject)} ${oneLine2(b.predicate)} ${oneLine2(b.object)} (confidence: ${b.confidence})`
+      (b) => `- ${oneLine3(b.subject)} ${oneLine3(b.predicate)} ${oneLine3(b.object)} (confidence: ${b.confidence})`
     );
     sections.push(`### Beliefs
 ${lines.join("\n")}`);
   }
   if (ctx.similarMemories.length > 0) {
-    const lines = ctx.similarMemories.slice(0, 3).map((m) => `- ${oneLine2(m.attributes.contextDescription)}`);
+    const lines = ctx.similarMemories.slice(0, 3).map((m) => `- ${oneLine3(m.attributes.contextDescription)}`);
     sections.push(`### Similar prior work
 ${lines.join("\n")}`);
   }
   if (ctx.experiencePatterns.length > 0) {
     const lines = ctx.experiencePatterns.slice(0, 3).map(
-      (p) => `- ${oneLine2(p.taskType)}: ${(p.successRate * 100).toFixed(0)}% success over ${String(p.attemptCount)} attempts`
+      (p) => `- ${oneLine3(p.taskType)}: ${(p.successRate * 100).toFixed(0)}% success over ${String(p.attemptCount)} attempts`
     );
     sections.push(`### Observed patterns
 ${lines.join("\n")}`);
@@ -3045,7 +3724,7 @@ ${lines.join("\n")}`);
     );
   }
   if (ctx.researchInsights.length > 0) {
-    const lines = ctx.researchInsights.slice(0, 5).map((r) => `- ${oneLine2(r.name)} (${oneLine2(r.status)}) \u2014 ${oneLine2(r.topic)}`);
+    const lines = ctx.researchInsights.slice(0, 5).map((r) => `- ${oneLine3(r.name)} (${oneLine3(r.status)}) \u2014 ${oneLine3(r.topic)}`);
     sections.push(`### Prior research on this topic
 ${lines.join("\n")}`);
   }
@@ -3067,7 +3746,7 @@ function summarizeRankedContext(ctx) {
   const top = topRankedWithinBudget(ranked, RANKED_PREFIX_TOKEN_BUDGET);
   if (top.length === 0) return "";
   const lines = top.map(
-    (r) => `- [${RANKED_SOURCE_LABEL[r.source]}] ${oneLine2(r.text)} (relevance: ${r.relevanceScore.toFixed(2)})`
+    (r) => `- [${RANKED_SOURCE_LABEL[r.source]}] ${oneLine3(r.text)} (relevance: ${r.relevanceScore.toFixed(2)})`
   );
   return `## Prior Context (Nexus Memory)
 ### Most relevant prior context
@@ -3129,6 +3808,9 @@ export {
   TokenCountError,
   TokenCounter,
   createTokenCounter,
+  CodebaseIndexSchema,
+  extractProject,
+  buildIndex,
   getContextForTask,
   selectRelevantResearch,
   getResearchInsightsForTask,
@@ -3137,4 +3819,4 @@ export {
   DEFAULT_CONTEXT_BUDGET_TOKENS,
   getContextPromptPrefix
 };
-//# sourceMappingURL=chunk-ZSUN7BHE.js.map
+//# sourceMappingURL=chunk-XGNB7LQB.js.map