nexus-agents 2.58.0 → 2.60.0

package/dist/{chunk-JLYJQ7OG.js → chunk-5JSMLCCK.js}

@@ -1,7 +1,13 @@
+import {
+  SharedMemoryStore
+} from "./chunk-ED6VQWNG.js";
 import {
   getTokenEnvVars,
   resolveToken
 } from "./chunk-EZXOJZYE.js";
+import {
+  executeExpert
+} from "./chunk-JKDHWOQL.js";
 import {
   ClaudeAdapter,
   DEFAULT_RELEVANCE_CONFIG,
@@ -29,7 +35,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-L3NHOUEX.js";
+} from "./chunk-FEWWXGFE.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -56,22 +62,22 @@ import {
   extractSymbolIndex,
   extractSymbols
 } from "./chunk-BQ4YXGGQ.js";
-import {
-  SharedMemoryStore
-} from "./chunk-ED6VQWNG.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-7EYQBG3W.js";
+} from "./chunk-XRXUCE6K.js";
 import {
   DEFAULTS
 } from "./chunk-H43PABG4.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
+import {
+  nexusDataPath
+} from "./chunk-FDNWRZNJ.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -97,9 +103,6 @@ import {
 import {
   getFallbackChainForCategory
 } from "./chunk-PTGBJFSD.js";
-import {
-  executeExpert
-} from "./chunk-JKDHWOQL.js";
 import {
   ClaudeCliAdapter,
   CliDetectionCache,
@@ -13860,7 +13863,7 @@ function wouldCreateCycle(from, to, getNode) {
   return canReach(to, from, /* @__PURE__ */ new Set(), getNode);
 }
 function findCyclePath(from, to, getNode) {
-  const path21 = [from, to];
+  const path20 = [from, to];
   const visited = /* @__PURE__ */ new Set([from]);
   const findPath = (current) => {
     if (current === from) return true;
@@ -13869,9 +13872,9 @@ function findCyclePath(from, to, getNode) {
     for (const depId of node.dependencies.keys()) {
       if (!visited.has(depId)) {
         visited.add(depId);
-        path21.push(depId);
+        path20.push(depId);
         if (findPath(depId)) return true;
-        path21.pop();
+        path20.pop();
       } else if (depId === from) {
         return true;
       }
@@ -13879,7 +13882,7 @@ function findCyclePath(from, to, getNode) {
     return false;
   };
   findPath(to);
-  return path21;
+  return path20;
 }
 function detectCycleDFS(nodeId, visited, stack, getNode) {
   visited.add(nodeId);
@@ -13898,29 +13901,29 @@ function detectCycleDFS(nodeId, visited, stack, getNode) {
   return false;
 }
 function findCycleFromNode(startId, getNode) {
-  const path21 = [];
+  const path20 = [];
   const visited = /* @__PURE__ */ new Set();
   const dfs = (nodeId) => {
-    if (path21.includes(nodeId)) {
-      const cycleStart = path21.indexOf(nodeId);
-      path21.splice(0, cycleStart);
-      path21.push(nodeId);
+    if (path20.includes(nodeId)) {
+      const cycleStart = path20.indexOf(nodeId);
+      path20.splice(0, cycleStart);
+      path20.push(nodeId);
       return true;
     }
     if (visited.has(nodeId)) return false;
     visited.add(nodeId);
-    path21.push(nodeId);
+    path20.push(nodeId);
     const node = getNode(nodeId);
     if (node) {
       for (const depId of node.dependencies.keys()) {
         if (dfs(depId)) return true;
       }
     }
-    path21.pop();
+    path20.pop();
     return false;
   };
   dfs(startId);
-  return path21;
+  return path20;
 }
 
 // src/agents/skills/skill-dependency-graph.ts
@@ -15078,7 +15081,6 @@ function createContextItem(id, content, source, relevance, timestamp) {
 // src/agents/wave-checkpoint-persistence.ts
 import * as fs from "fs";
 import * as path from "path";
-import * as os from "os";
 
 // src/agents/wave-checkpoint-types.ts
 import { z as z27 } from "zod";
@@ -15103,13 +15105,13 @@ var WaveCheckpointEntrySchema = z27.object({
 
 // src/agents/wave-checkpoint-persistence.ts
 var logger5 = createLogger({ component: "wave-checkpoint" });
-var CHECKPOINT_DIR = path.join(".nexus-agents", "checkpoints");
+var CHECKPOINT_SUBDIR = "checkpoints";
 var DIR_MODE = 448;
 function getCheckpointDir(customDir) {
   if (customDir !== void 0) {
     return path.resolve(customDir);
   }
-  return path.join(os.homedir(), CHECKPOINT_DIR);
+  return nexusDataPath(CHECKPOINT_SUBDIR);
 }
 function ensureCheckpointDir(customDir) {
   const dirPath = getCheckpointDir(customDir);
@@ -18466,18 +18468,18 @@ var DependencyGraph = class {
     }
     const startNode = firstNode;
     const visited = /* @__PURE__ */ new Set();
-    const path21 = [];
+    const path20 = [];
     const dfs = (nodeId) => {
-      if (path21.includes(nodeId)) {
-        const cycleStart = path21.indexOf(nodeId);
-        path21.splice(0, cycleStart);
+      if (path20.includes(nodeId)) {
+        const cycleStart = path20.indexOf(nodeId);
+        path20.splice(0, cycleStart);
         return true;
       }
       if (visited.has(nodeId)) {
         return false;
       }
       visited.add(nodeId);
-      path21.push(nodeId);
+      path20.push(nodeId);
       const node = this.nodes.get(nodeId);
       if (node) {
         for (const depId of node.dependencies) {
@@ -18488,11 +18490,11 @@ var DependencyGraph = class {
           }
         }
       }
-      path21.pop();
+      path20.pop();
       return false;
     };
     dfs(startNode);
-    return path21.length > 0 ? path21 : cycleNodes.slice(0, 3);
+    return path20.length > 0 ? path20 : cycleNodes.slice(0, 3);
   }
   /**
    * Gets the execution order (topologically sorted step IDs).
@@ -19344,9 +19346,9 @@ function getBuiltInTemplatesPath() {
     join3(dirname2(currentDir), "workflows", "templates"),
     join3(dirname2(currentDir), "dist", "workflows", "templates")
   ];
-  for (const path21 of possiblePaths) {
-    if (existsSync3(path21)) {
-      return path21;
+  for (const path20 of possiblePaths) {
+    if (existsSync3(path20)) {
+      return path20;
     }
   }
   return join3(currentDir, "templates");
@@ -19887,9 +19889,9 @@ function validateRequiredInputs(inputs, required) {
 }
 
 // src/workflows/expression-resolver-helpers.ts
-function getNestedValue(obj, path21) {
+function getNestedValue(obj, path20) {
   let current = obj;
-  for (const key of path21) {
+  for (const key of path20) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -19900,24 +19902,24 @@ function getNestedValue(obj, path21) {
   }
   return current;
 }
-function resolveInputs(path21, context) {
-  const value = getNestedValue(context.inputs, path21);
+function resolveInputs(path20, context) {
+  const value = getNestedValue(context.inputs, path20);
   if (value === void 0) {
     return {
       success: false,
-      error: `Input '${path21.join(".")}' not found`
+      error: `Input '${path20.join(".")}' not found`
     };
   }
   return { success: true, value };
 }
-function validateStepPath(path21) {
-  if (path21.length < 2) {
+function validateStepPath(path20) {
+  if (path20.length < 2) {
     return {
       success: false,
       error: "Steps expression requires at least stepId and output"
     };
   }
-  if (path21[0] === void 0 || path21[1] === void 0) {
+  if (path20[0] === void 0 || path20[1] === void 0) {
     return {
       success: false,
       error: "Steps expression requires stepId and output"
@@ -19943,12 +19945,12 @@ function validateStepResult(stepId, outputKey, stepResult) {
   }
   return null;
 }
-function resolveSteps(path21, context) {
-  const pathError = validateStepPath(path21);
+function resolveSteps(path20, context) {
+  const pathError = validateStepPath(path20);
   if (pathError !== null) return pathError;
-  const stepId = path21[0] ?? "";
-  const outputKey = path21[1] ?? "";
-  const rest = path21.slice(2);
+  const stepId = path20[0] ?? "";
+  const outputKey = path20[1] ?? "";
+  const rest = path20.slice(2);
   const stepResult = context.stepResults.get(stepId);
   const earlyReturn = validateStepResult(stepId, outputKey, stepResult);
   if (earlyReturn !== null) return earlyReturn;
@@ -19964,15 +19966,15 @@ function resolveSteps(path21, context) {
   }
   return { success: true, value };
 }
-function resolveVariables(path21, context) {
-  if (path21.length === 0) {
+function resolveVariables(path20, context) {
+  if (path20.length === 0) {
     return {
       success: false,
       error: "Variables expression requires a variable name"
     };
   }
-  const varName = path21[0];
-  const rest = path21.slice(1);
+  const varName = path20[0];
+  const rest = path20.slice(1);
   if (varName === void 0) {
     return {
       success: false,
@@ -20995,8 +20997,8 @@ var WorkflowEngine = class {
     this.config = resolveConfig2(config);
   }
   /** Load workflow template from file. */
-  async loadTemplate(path21) {
-    return this.deps.loadWorkflowFile(path21);
+  async loadTemplate(path20) {
+    return this.deps.loadWorkflowFile(path20);
   }
   /** Execute a workflow with inputs. */
   async execute(workflow, inputs) {
@@ -21100,8 +21102,8 @@ var WorkflowEngine = class {
     }
     return Promise.resolve(templates);
   }
-  createTemplate(workflow, path21, category) {
-    const t = { name: workflow.name, version: workflow.version, path: path21, category };
+  createTemplate(workflow, path20, category) {
+    const t = { name: workflow.name, version: workflow.version, path: path20, category };
     if (workflow.description !== void 0) t.description = workflow.description;
     return t;
   }
@@ -21387,8 +21389,8 @@ function createParseWorkflow() {
   };
 }
 function createLoadWorkflowFile() {
-  return async (path21) => {
-    const result = await loadWorkflowFile(path21);
+  return async (path20) => {
+    const result = await loadWorkflowFile(path20);
     if (!result.ok) {
       if (result.error instanceof ParseError) {
         return result;
@@ -21617,13 +21619,12 @@ function withLogging(toolName, handler3, logger56) {
 // src/mcp/middleware/auth-handler.ts
 import { randomBytes, timingSafeEqual } from "crypto";
 import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
-import { homedir as homedir2 } from "os";
-var DEFAULT_AUTH_DIR = ".nexus-agents/auth";
+import { dirname as dirname3 } from "path";
+var DEFAULT_AUTH_SUBDIR = "auth";
 var DEFAULT_TOKEN_FILE = "server-token";
 var TOKEN_LENGTH_BYTES = 32;
 function getDefaultTokenPath() {
-  return join4(homedir2(), DEFAULT_AUTH_DIR, DEFAULT_TOKEN_FILE);
+  return nexusDataPath(DEFAULT_AUTH_SUBDIR, DEFAULT_TOKEN_FILE);
 }
 function generateSecureToken() {
   return randomBytes(TOKEN_LENGTH_BYTES).toString("hex");
@@ -23437,10 +23438,10 @@ function calculateZStatistic(params) {
 function calculateDifferenceCI(p1, p2, total1, total2, confidence) {
   const difference = p1 - p2;
   const seDiff = Math.sqrt(p1 * (1 - p1) / (total1 || 1) + p2 * (1 - p2) / (total2 || 1));
-  const z103 = getZScore(confidence);
+  const z104 = getZScore(confidence);
   return {
-    lower: difference - z103 * seDiff,
-    upper: difference + z103 * seDiff,
+    lower: difference - z104 * seDiff,
+    upper: difference + z104 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23463,11 +23464,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z103 = getZScore(opts.confidence);
-  const z210 = z103 * z103;
+  const z104 = getZScore(opts.confidence);
+  const z210 = z104 * z104;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z103 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z104 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
   const lower = Math.max(0, center - margin);
   const upper = Math.min(1, center + margin);
   const standardError = Math.sqrt(p * (1 - p) / n);
@@ -23497,8 +23498,8 @@ function meanConfidenceInterval(values, options = {}) {
   const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1 || 1);
   const stdDev = Math.sqrt(variance);
   const standardError = stdDev / Math.sqrt(n);
-  const z103 = getZScore(opts.confidence);
-  const margin = z103 * standardError;
+  const z104 = getZScore(opts.confidence);
+  const margin = z104 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -27030,31 +27031,31 @@ var GraphBuilder = class {
     }
     const visited = /* @__PURE__ */ new Set();
     const stack = /* @__PURE__ */ new Set();
-    const path21 = [];
+    const path20 = [];
     for (const nodeId of this.nodes.keys()) {
-      const cycle = this.dfs(nodeId, adj, visited, stack, path21);
+      const cycle = this.dfs(nodeId, adj, visited, stack, path20);
       if (cycle !== void 0) return cycle;
     }
     return void 0;
   }
-  dfs(nodeId, adj, visited, stack, path21) {
+  dfs(nodeId, adj, visited, stack, path20) {
     if (stack.has(nodeId)) {
-      const cycleStart = path21.indexOf(nodeId);
-      const cyclePath = path21.slice(cycleStart);
+      const cycleStart = path20.indexOf(nodeId);
+      const cyclePath = path20.slice(cycleStart);
       cyclePath.push(nodeId);
       return { type: "cycle_detected", path: cyclePath };
     }
     if (visited.has(nodeId)) return void 0;
     visited.add(nodeId);
     stack.add(nodeId);
-    path21.push(nodeId);
+    path20.push(nodeId);
     const neighbors = adj.get(nodeId) ?? [];
     for (const neighbor of neighbors) {
-      const cycle = this.dfs(neighbor, adj, visited, stack, path21);
+      const cycle = this.dfs(neighbor, adj, visited, stack, path20);
       if (cycle !== void 0) return cycle;
     }
     stack.delete(nodeId);
-    path21.pop();
+    path20.pop();
     return void 0;
   }
   checkReachability() {
@@ -27594,13 +27595,13 @@ function emitPipelineStageEvent(prefix, stage, status, details) {
 
 // src/pipeline/trace-writer.ts
 import { mkdir, writeFile, rename, unlink } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 var logger18 = createLogger({ component: "TraceWriter" });
 var MAX_BUFFER_SIZE = 5e4;
 var TraceWriter = class {
   constructor(bus, options) {
     this.options = options;
-    this.runDir = join6(options.runsDir, options.runId);
+    this.runDir = join5(options.runsDir, options.runId);
     this.maxBuffer = options.maxBufferSize ?? MAX_BUFFER_SIZE;
     this.unsubscribe = bus.subscribe({}, (event) => {
       if (!this.stopped) {
@@ -27621,7 +27622,7 @@ var TraceWriter = class {
     if (this.buffer.length === 0) return;
     await mkdir(this.runDir, { recursive: true });
     const lines = this.buffer.map((e) => JSON.stringify(e)).join("\n");
-    const tracePath = join6(this.runDir, "trace.jsonl");
+    const tracePath = join5(this.runDir, "trace.jsonl");
     const traceTmp = `${tracePath}.tmp.${String(process.pid)}`;
     try {
       await writeFile(traceTmp, lines + "\n", "utf-8");
@@ -27634,7 +27635,7 @@ var TraceWriter = class {
       throw err2;
     }
     const indexContent = this.buildIndex();
-    const indexPath = join6(this.runDir, "index.md");
+    const indexPath = join5(this.runDir, "index.md");
     const indexTmp = `${indexPath}.tmp.${String(process.pid)}`;
     try {
       await writeFile(indexTmp, indexContent, "utf-8");
@@ -27722,8 +27723,8 @@ function extractModelAttribution(event) {
   };
 }
 function extractRoutingAttribution(event) {
-  const path21 = event.decisionPath !== void 0 ? [...event.decisionPath] : void 0;
-  return { modelId: event.selectedModel, reasoning: event.reasoning, decisionPath: path21 };
+  const path20 = event.decisionPath !== void 0 ? [...event.decisionPath] : void 0;
+  return { modelId: event.selectedModel, reasoning: event.reasoning, decisionPath: path20 };
 }
 function extractPipelineAttribution(event) {
   if (event.type === "pipeline.completed") {
@@ -29284,10 +29285,8 @@ function createSicaOrchestratorAdapter(sicaAgent, _logger) {
 
 // src/mcp/tools/research-auto-catalog.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
-import * as os2 from "os";
 import { z as z51 } from "zod";
-var CATALOG_DIR = path4.join(".nexus-agents", "research");
+var CATALOG_SUBDIR = "research";
 var CATALOG_FILE = "pending-catalog.json";
 var FILE_MODE = 384;
 var DIR_MODE2 = 448;
@@ -29305,7 +29304,7 @@ var PersistedCatalogSchema = z51.object({
   savedAt: z51.string()
 });
 function getCatalogPath() {
-  return path4.join(os2.homedir(), CATALOG_DIR, CATALOG_FILE);
+  return nexusDataPath(CATALOG_SUBDIR, CATALOG_FILE);
 }
 function loadPersistedCatalog(logger56) {
   const filePath = getCatalogPath();
@@ -29330,7 +29329,7 @@ function loadPersistedCatalog(logger56) {
   }
 }
 function savePersistedCatalog(references, logger56) {
-  const dirPath = path4.join(os2.homedir(), CATALOG_DIR);
+  const dirPath = nexusDataPath(CATALOG_SUBDIR);
   const filePath = getCatalogPath();
   const tempPath = `${filePath}.tmp.${String(process.pid)}`;
   try {
@@ -31931,8 +31930,8 @@ function isReflectiveShadowMode() {
 }
 
 // src/mcp/tools/orchestrate-reflection.ts
-import * as os3 from "os";
-import * as path5 from "path";
+import * as os from "os";
+import * as path4 from "path";
 var logger28 = createLogger({ component: "orchestrate-reflection" });
 var REFLECTION_MAX_TOKENS2 = 1e3;
 var REFLECTION_WRITE_CONFIDENCE_THRESHOLD = 0.6;
@@ -32023,7 +32022,7 @@ function writeLearningsToSession(learnings, taskDescription) {
   }
   if (eligible.length === 0) return 0;
   try {
-    const memoryDir = path5.join(os3.homedir(), ".nexus-agents", "memory", "sessions");
+    const memoryDir = path4.join(os.homedir(), ".nexus-agents", "memory", "sessions");
     const memory = createSessionMemory(memoryDir);
     const sessionId = `reflection-${String(Date.now())}`;
     const startResult = memory.startSession(sessionId);
@@ -32471,8 +32470,8 @@ function hashObjective(userObjective) {
 
 // src/context/structured-task-state.ts
 import * as fs5 from "fs";
-import * as path6 from "path";
-import * as os4 from "os";
+import * as path5 from "path";
+import * as os2 from "os";
 
 // src/context/structured-task-state-types.ts
 import { z as z55 } from "zod";
@@ -32595,15 +32594,15 @@ var StructuredTaskLogEntrySchema = z55.discriminatedUnion("event", [
 
 // src/context/structured-task-state.ts
 var logger29 = createLogger({ component: "structured-task-state" });
-var TASKS_DIR = path6.join(".nexus-agents", "tasks");
+var TASKS_DIR = path5.join(".nexus-agents", "tasks");
 var FILE_MODE2 = 384;
 var DIR_MODE3 = 448;
 function getTasksDir(customDir) {
-  if (customDir !== void 0) return path6.resolve(customDir);
-  return path6.join(os4.homedir(), TASKS_DIR);
+  if (customDir !== void 0) return path5.resolve(customDir);
+  return path5.join(os2.homedir(), TASKS_DIR);
 }
 function getLogPath(taskId, customDir) {
-  return path6.join(getTasksDir(customDir), `state-${taskId}.jsonl`);
+  return path5.join(getTasksDir(customDir), `state-${taskId}.jsonl`);
 }
 function validateTaskId(taskId) {
   if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
@@ -36384,18 +36383,18 @@ function parseArxivEntries(xml, source, topic = "") {
 
 // src/cli/research-helpers-sources-io.ts
 import * as fs6 from "fs/promises";
-import * as path7 from "path";
+import * as path6 from "path";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 var SOURCES_FILE = "sources.yaml";
 function validatePath3(constructedPath, allowedRoot) {
   const resolved = resolveInsideRoot(constructedPath, allowedRoot);
   if (resolved === null) {
-    const root = path7.resolve(allowedRoot);
+    const root = path6.resolve(allowedRoot);
     return {
       ok: false,
       error: {
         code: "PATH_TRAVERSAL",
-        message: `Path ${path7.resolve(constructedPath)} is outside ${root}`
+        message: `Path ${path6.resolve(constructedPath)} is outside ${root}`
       }
     };
   }
@@ -36403,7 +36402,7 @@ function validatePath3(constructedPath, allowedRoot) {
 }
 async function loadSourcesRegistry(rootDir) {
   const root = rootDir ?? getProjectRoot();
-  const filePath = path7.join(root, REGISTRY_PATH, SOURCES_FILE);
+  const filePath = path6.join(root, REGISTRY_PATH, SOURCES_FILE);
   const pathResult = validatePath3(filePath, root);
   if (!pathResult.ok) return pathResult;
   try {
@@ -36429,7 +36428,7 @@ async function loadSourcesRegistry(rootDir) {
 }
 async function saveSourcesRegistry(registry, rootDir) {
   const root = rootDir ?? getProjectRoot();
-  const filePath = path7.join(root, REGISTRY_PATH, SOURCES_FILE);
+  const filePath = path6.join(root, REGISTRY_PATH, SOURCES_FILE);
   const pathResult = validatePath3(filePath, root);
   if (!pathResult.ok) return pathResult;
   try {
@@ -36736,12 +36735,12 @@ function rankDiscoveredItems(items, topic) {
 
 // src/cli/research-helpers-index-ops.ts
 import * as fs7 from "fs/promises";
-import * as path8 from "path";
+import * as path7 from "path";
 function getRegistryPath() {
-  return path8.resolve(process.cwd(), "docs/research/registry");
+  return path7.resolve(process.cwd(), "docs/research/registry");
 }
 function getIndexPath() {
-  return path8.resolve(process.cwd(), "docs/research/RESEARCH_INDEX.md");
+  return path7.resolve(process.cwd(), "docs/research/RESEARCH_INDEX.md");
 }
 async function handleStatsCommand(options) {
   const registryPath = getRegistryPath();
@@ -36771,7 +36770,7 @@ async function handleRefreshCommand(options) {
   if (!mdResult.ok) {
     return `Error: Failed to generate markdown: ${mdResult.error.message}`;
   }
-  await fs7.mkdir(path8.dirname(outputPath), { recursive: true });
+  await fs7.mkdir(path7.dirname(outputPath), { recursive: true });
   await fs7.writeFile(outputPath, mdResult.value, "utf-8");
   const stats = index.stats;
   return [
@@ -38711,12 +38710,12 @@ function extractFileReferences(markdown) {
   let match;
   FILE_REF_PATTERN.lastIndex = 0;
   while ((match = FILE_REF_PATTERN.exec(markdown)) !== null) {
-    const path21 = match[1];
-    if (path21 === void 0 || seen.has(path21)) continue;
-    seen.add(path21);
+    const path20 = match[1];
+    if (path20 === void 0 || seen.has(path20)) continue;
+    seen.add(path20);
     const lineStr = match[2];
     const line = lineStr !== void 0 ? parseInt(lineStr, 10) : void 0;
-    refs.push(line !== void 0 ? { path: path21, line } : { path: path21 });
+    refs.push(line !== void 0 ? { path: path20, line } : { path: path20 });
   }
   return refs;
 }
@@ -40000,7 +39999,7 @@ function registerExtractSymbolsTool(server, deps) {
 
 // src/mcp/tools/query-trace-tool.ts
 import { readFile as readFile5, stat as stat3 } from "fs/promises";
-import { join as join11, resolve as resolve11, sep as sep3 } from "path";
+import { join as join9, resolve as resolve11, sep as sep3 } from "path";
 import { z as z84 } from "zod";
 var QueryTraceInputSchema = z84.object({
   runId: z84.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/, "runId must be alphanumeric, hyphens, or underscores").describe("Run ID to query traces for"),
@@ -40041,7 +40040,7 @@ var EMPTY_RESPONSE = {
 };
 async function queryTraceFromDisk(input, runsDir) {
   const dir = runsDir ?? DEFAULT_RUNS_DIR;
-  const tracePath = join11(dir, input.runId, "trace.jsonl");
+  const tracePath = join9(dir, input.runId, "trace.jsonl");
   const resolvedDir = resolve11(dir);
   const resolvedTrace = resolve11(tracePath);
   if (!resolvedTrace.startsWith(resolvedDir + sep3) && resolvedTrace !== resolvedDir) {
@@ -40351,11 +40350,11 @@ var InMemoryAuditStorage = class {
 
 // src/audit/audit-storage.ts
 import * as fs9 from "fs";
-import * as path9 from "path";
+import * as path8 from "path";
 function validateLogDir(logDir, allowedRoot) {
-  const resolvedRoot = path9.resolve(allowedRoot);
-  const resolvedLogDir = path9.resolve(allowedRoot, logDir);
-  if (!resolvedLogDir.startsWith(resolvedRoot + path9.sep) && resolvedLogDir !== resolvedRoot) {
+  const resolvedRoot = path8.resolve(allowedRoot);
+  const resolvedLogDir = path8.resolve(allowedRoot, logDir);
+  if (!resolvedLogDir.startsWith(resolvedRoot + path8.sep) && resolvedLogDir !== resolvedRoot) {
     return {
       ok: false,
       error: new SecurityError("Path traversal detected: logDir escapes allowed root directory", {
@@ -40378,10 +40377,10 @@ function validateLogDirBasic(logDir) {
       };
     }
   }
-  const resolved = path9.resolve(logDir);
+  const resolved = path8.resolve(logDir);
   const systemDirs = ["/etc", "/var", "/usr", "/bin", "/sbin", "/root", "/proc", "/sys"];
   for (const sysDir of systemDirs) {
-    if (resolved === sysDir || resolved.startsWith(sysDir + path9.sep)) {
+    if (resolved === sysDir || resolved.startsWith(sysDir + path8.sep)) {
       return {
         ok: false,
         error: new SecurityError("logDir cannot be a system directory", {
@@ -40470,7 +40469,7 @@ var FileAuditStorage = class _FileAuditStorage {
     const existingFiles = this.getExistingLogFiles();
     const latestFileName = existingFiles[0];
     if (existingFiles.length > 0 && latestFileName !== void 0) {
-      const latestFile = path9.join(this.logDir, latestFileName);
+      const latestFile = path8.join(this.logDir, latestFileName);
       const stats = fs9.statSync(latestFile);
       if (stats.size < this.maxFileSizeBytes) {
         this.currentFile = latestFile;
@@ -40493,7 +40492,7 @@ var FileAuditStorage = class _FileAuditStorage {
       this.writeStream.end();
       this.writeStream = null;
     }
-    this.currentFile = path9.join(this.logDir, this.generateFileName());
+    this.currentFile = path8.join(this.logDir, this.generateFileName());
     this.currentFileSize = 0;
     this.openWriteStream();
     this.logger.debug("Rotated audit log file", { file: this.currentFile });
@@ -40504,7 +40503,7 @@ var FileAuditStorage = class _FileAuditStorage {
     if (files.length > this.maxFiles) {
       const filesToDelete = files.slice(this.maxFiles);
       for (const file of filesToDelete) {
-        const filePath = path9.join(this.logDir, file);
+        const filePath = path8.join(this.logDir, file);
         fs9.unlinkSync(filePath);
         this.logger.info("Pruned old audit log", { file });
       }
@@ -40558,7 +40557,7 @@ var FileAuditStorage = class _FileAuditStorage {
     let skipped = 0;
     for (const file of files) {
       if (results.length >= limit) break;
-      const filePath = path9.join(this.logDir, file);
+      const filePath = path8.join(this.logDir, file);
       const events = await readAuditFile({
         filePath,
         criteria,
@@ -41529,7 +41528,7 @@ function resolveConfidence(rule) {
 }
 
 // src/mcp/tools/security-scan.ts
-import * as path10 from "path";
+import * as path9 from "path";
 var logger33 = createLogger({ component: "security-scan" });
 var SCAN_TIMEOUT_MS = 3e5;
 async function isSemgrepAvailable() {
@@ -41556,9 +41555,9 @@ async function runSemgrep(targetDir, rulesets) {
   return stdout;
 }
 function validateTargetPath(target) {
-  const root = path10.resolve(process.cwd());
-  const resolved = path10.resolve(root, target);
-  if (resolved !== root && !resolved.startsWith(root + path10.sep)) {
+  const root = path9.resolve(process.cwd());
+  const resolved = path9.resolve(root, target);
+  if (resolved !== root && !resolved.startsWith(root + path9.sep)) {
     throw new Error(
       `Invalid target path: must resolve inside ${root} (got ${resolved})`
     );
@@ -41987,8 +41986,8 @@ async function runOsvCheck(targetDir, enabled) {
   if (!enabled) return [];
   try {
     const fs20 = await import("fs");
-    const path21 = await import("path");
-    const pkgPath = path21.join(targetDir, "package.json");
+    const path20 = await import("path");
+    const pkgPath = path20.join(targetDir, "package.json");
     if (!fs20.existsSync(pkgPath)) return [];
     const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
     const deps = Object.entries(pkg.dependencies ?? {}).slice(0, 20).map(([name, version]) => ({
@@ -42099,11 +42098,10 @@ async function persistMobiMemState() {
   try {
     const { isPersistenceEnabled } = await import("./learning-persistence-WMWZJZ35.js");
     if (!isPersistenceEnabled()) return;
-    const os6 = await import("os");
-    const path21 = await import("path");
+    const { nexusDataPath: nexusDataPath2 } = await import("./nexus-data-dir-M6DYKIHJ.js");
     const { createMobiMem } = await import("./mobimem-QDBP37H7.js");
     const mobimem = createMobiMem();
-    const savePath = path21.join(os6.homedir(), ".nexus-agents", "memory", "mobimem-state.json");
+    const savePath = nexusDataPath2("memory", "mobimem-state.json");
     await mobimem.save(savePath);
   } catch {
   }
@@ -42257,7 +42255,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-HDM6HA5Z.js");
+        const { executeVoting } = await import("./consensus-vote-PRLGGUNY.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -42417,7 +42415,7 @@ function extractIssues(text) {
 
 // src/pipeline/pipeline-checkpoint.ts
 import * as fs10 from "fs";
-import * as path11 from "path";
+import * as path10 from "path";
 var logger38 = createLogger({ component: "pipeline-checkpoint" });
 var SESSION_ID_REGEX = /^[a-zA-Z0-9_-]{1,128}$/;
 function validateSessionId(sessionId) {
@@ -42429,7 +42427,7 @@ function getCheckpointPath(sessionId, customDir) {
     logger38.warn("Checkpoint directory unavailable", { error: dirResult.error.message });
     return null;
   }
-  return path11.join(dirResult.value, `pipeline-${sessionId}.jsonl`);
+  return path10.join(dirResult.value, `pipeline-${sessionId}.jsonl`);
 }
 function saveStageCheckpoint(sessionId, stage, data, customDir) {
   if (!validateSessionId(sessionId)) {
@@ -42521,10 +42519,6 @@ function checkpointToResult(state) {
   return result;
 }
 
-// src/pipeline/dev-pipeline.ts
-import { homedir as homedir6 } from "os";
-import { join as join14 } from "path";
-
 // src/orchestration/qa-loop.ts
 var logger39 = createLogger({ component: "qa-loop" });
 var DEFAULT_MAX_QA_ITERATIONS = 3;
@@ -42611,7 +42605,7 @@ async function runDevPipelineInner(task, stages, options, sid, prior) {
 function createTraceWriter(sessionId) {
   if (sessionId === void 0) return null;
   try {
-    const tracesDir = join14(homedir6(), ".nexus-agents", "traces");
+    const tracesDir = nexusDataPath("traces");
     return new TraceWriter(getPipelineEventBus(), {
       runsDir: tracesDir,
       runId: `pipeline-${sessionId}`
@@ -43106,11 +43100,11 @@ async function extractSymbolsForTask(task) {
     const fileRefs = task.match(/(?:src|lib|packages)\/[^\s,)]+\.ts/g);
     if (fileRefs === null || fileRefs.length === 0) return null;
     const { extractSymbols: extractSymbols2 } = await import("./symbol-extractor-UEBANFSN.js");
-    const path21 = await import("path");
+    const path20 = await import("path");
     const summaries = [];
     for (const ref of fileRefs.slice(0, 3)) {
       try {
-        const resolved = path21.resolve(ref);
+        const resolved = path20.resolve(ref);
         const result = await extractSymbols2(resolved);
         const exported = result.symbols.filter((s) => s.exported);
         if (exported.length > 0) {
@@ -43127,12 +43121,12 @@ async function extractSymbolsForTask(task) {
 async function retrieveAdaptiveMemory(task) {
   try {
     const { AdaptiveMemoryBackend } = await import("./adaptive-memory-TSZEJUJC.js");
-    const os6 = await import("os");
-    const path21 = await import("path");
-    const baseDir = path21.join(os6.homedir(), ".nexus-agents", "memory");
+    const path20 = await import("path");
+    const { nexusDataPath: nexusDataPath2 } = await import("./nexus-data-dir-M6DYKIHJ.js");
+    const baseDir = nexusDataPath2("memory");
     const memory = new AdaptiveMemoryBackend({
-      dbPath: path21.join(baseDir, "adaptive.db"),
-      markdownDir: path21.join(baseDir, "adaptive-md")
+      dbPath: path20.join(baseDir, "adaptive.db"),
+      markdownDir: path20.join(baseDir, "adaptive-md")
     });
     const key = task.slice(0, 50).replace(/\s+/g, "-").toLowerCase();
     const result = await memory.retrieve(key);
@@ -43581,7 +43575,7 @@ function registerQueryTaskStateTool(server, deps) {
 
 // src/mcp/tools/verify-audit-chain-tool.ts
 import * as fs11 from "fs/promises";
-import * as path12 from "path";
+import * as path11 from "path";
 import { z as z92 } from "zod";
 var VerifyAuditChainInputSchema = z92.object({
   logDir: z92.string().min(1).max(512).describe(
@@ -43593,7 +43587,7 @@ async function loadAuditEvents(dir, logger56) {
   const auditFiles = entries.filter((name) => name.startsWith("audit-") && name.endsWith(".jsonl")).sort();
   const events = [];
   for (const filename of auditFiles) {
-    const fullPath = path12.join(dir, filename);
+    const fullPath = path11.join(dir, filename);
     let content;
     try {
       content = await fs11.readFile(fullPath, "utf-8");
@@ -43628,7 +43622,7 @@ async function handler2(args, ctx) {
   if (!parsed.success) {
     return toolError(`Validation error: ${formatZodError(parsed.error)}`);
   }
-  const resolvedDir = path12.resolve(parsed.data.logDir);
+  const resolvedDir = path11.resolve(parsed.data.logDir);
   let dirStats;
   try {
     dirStats = await fs11.stat(resolvedDir);
@@ -43678,7 +43672,7 @@ function registerVerifyAuditChainTool(server, deps) {
 // src/mcp/tools/pipeline-tool.ts
 import { z as z93 } from "zod";
 import * as fs12 from "fs";
-import * as path13 from "path";
+import * as path12 from "path";
 var PipelineInputSchema = z93.object({
   /** The task to execute. */
   task: z93.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
@@ -43721,8 +43715,8 @@ function buildOutput2(result) {
 }
 function resolveTask(task, specFile) {
   if (specFile === void 0) return task;
-  const resolved = path13.resolve(specFile);
-  const cwdRoot = path13.resolve(".");
+  const resolved = path12.resolve(specFile);
+  const cwdRoot = path12.resolve(".");
   if (!resolved.startsWith(cwdRoot)) {
     throw new Error(`Path traversal denied: specFile must be within ${cwdRoot}`);
   }
@@ -43776,6 +43770,29 @@ function registerPipelineTool(server, _deps) {
   });
 }
 
+// src/mcp/tools/supply-chain-tradeoff-panel.ts
+import { z as z94 } from "zod";
+var DEFAULT_AXES = [
+  "build_time_determinism",
+  "supply_chain_risk",
+  "update_cadence"
+];
+var MAX_AXES = 6;
+var MAX_AXIS_NAME_LENGTH = 64;
+var MAX_PROPOSAL_LENGTH = 4e3;
+var MAX_CONTEXT_LENGTH = 4e3;
+var SupplyChainTradeoffPanelInputSchema = z94.object({
+  proposal: z94.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z94.array(z94.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+    `Tradeoff axes to evaluate. Default: ${DEFAULT_AXES.join(", ")}. Custom axes accepted; max ${String(MAX_AXES)}.`
+  ),
+  context: z94.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+    "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
+  ),
+  quickMode: z94.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z94.boolean().optional().default(false).describe("Use simulated voters (testing only)")
+});
+
 // src/mcp/tools/tool-annotations.ts
 var TOOL_ANNOTATIONS = {
   delegate_to_model: {
@@ -44194,7 +44211,8 @@ function registerTools(server, options) {
       "search_codebase",
       "run_dev_pipeline",
       "run_pipeline",
-      "pr_review"
+      "pr_review",
+      "supply_chain_tradeoff_panel"
     ],
     logger: logger56,
     rateLimiter
@@ -44322,40 +44340,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z94 } from "zod";
-var HazardCategorySchema = z94.enum(HazardCategory);
-var HazardSeveritySchema = z94.enum(HazardSeverity);
-var ConstraintPrioritySchema = z94.enum(ConstraintPriority);
-var RiskLevelSchema = z94.enum(RiskLevel);
-var TriggerPatternSchema = z94.object({
-  parameter: z94.string().min(1),
-  matchType: z94.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z94.string(),
-  reason: z94.string()
+import { z as z95 } from "zod";
+var HazardCategorySchema = z95.enum(HazardCategory);
+var HazardSeveritySchema = z95.enum(HazardSeverity);
+var ConstraintPrioritySchema = z95.enum(ConstraintPriority);
+var RiskLevelSchema = z95.enum(RiskLevel);
+var TriggerPatternSchema = z95.object({
+  parameter: z95.string().min(1),
+  matchType: z95.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z95.string(),
+  reason: z95.string()
 });
-var HazardSchema = z94.object({
-  id: z94.string().min(1),
-  description: z94.string(),
+var HazardSchema = z95.object({
+  id: z95.string().min(1),
+  description: z95.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z94.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z94.array(z94.string()),
-  consequences: z94.array(z94.string())
+  likelihood: z95.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z95.array(z95.string()),
+  consequences: z95.array(z95.string())
 });
-var UnsafeControlActionSchema = z94.object({
-  id: z94.string().min(1),
-  toolName: z94.string().min(1),
-  type: z94.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z94.string(),
-  unsafeContext: z94.string(),
-  relatedHazards: z94.array(z94.string()),
-  triggerPatterns: z94.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z95.object({
+  id: z95.string().min(1),
+  toolName: z95.string().min(1),
+  type: z95.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z95.string(),
+  unsafeContext: z95.string(),
+  relatedHazards: z95.array(z95.string()),
+  triggerPatterns: z95.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z94.object({
-  id: z94.string().min(1),
-  description: z94.string(),
-  mitigates: z94.array(z94.string()),
-  enforcement: z94.enum([
+var SafetyConstraintSchema = z95.object({
+  id: z95.string().min(1),
+  description: z95.string(),
+  mitigates: z95.array(z95.string()),
+  enforcement: z95.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -44363,54 +44381,54 @@ var SafetyConstraintSchema = z94.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z94.string().optional(),
+  validationFunction: z95.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z94.object({
-  type: z94.string(),
-  description: z94.string().optional(),
-  enum: z94.array(z94.unknown()).optional(),
-  pattern: z94.string().optional(),
-  minimum: z94.number().optional(),
-  maximum: z94.number().optional()
+var PropertySchemaSchema = z95.object({
+  type: z95.string(),
+  description: z95.string().optional(),
+  enum: z95.array(z95.unknown()).optional(),
+  pattern: z95.string().optional(),
+  minimum: z95.number().optional(),
+  maximum: z95.number().optional()
 });
-var ToolInputSchemaSchema = z94.object({
-  type: z94.string(),
-  properties: z94.record(z94.string(), PropertySchemaSchema).optional(),
-  required: z94.array(z94.string()).optional(),
-  additionalProperties: z94.boolean().optional()
+var ToolInputSchemaSchema = z95.object({
+  type: z95.string(),
+  properties: z95.record(z95.string(), PropertySchemaSchema).optional(),
+  required: z95.array(z95.string()).optional(),
+  additionalProperties: z95.boolean().optional()
 });
-var ToolDefinitionSchema = z94.object({
-  name: z94.string().min(1),
-  description: z94.string(),
+var ToolDefinitionSchema = z95.object({
+  name: z95.string().min(1),
+  description: z95.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z94.object({
-  includeLowSeverity: z94.boolean().default(true),
-  generateAllConstraints: z94.boolean().default(true),
-  checkInteractions: z94.boolean().default(true),
-  maxHazardsPerTool: z94.number().int().min(1).max(100).default(50),
-  categories: z94.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z95.object({
+  includeLowSeverity: z95.boolean().default(true),
+  generateAllConstraints: z95.boolean().default(true),
+  checkInteractions: z95.boolean().default(true),
+  maxHazardsPerTool: z95.number().int().min(1).max(100).default(50),
+  categories: z95.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z94.object({
-  constraintId: z94.string().min(1),
-  constraintDescription: z94.string(),
+var ConstraintViolationSchema = z95.object({
+  constraintId: z95.string().min(1),
+  constraintDescription: z95.string(),
   severity: HazardSeveritySchema,
-  details: z94.string(),
-  remediation: z94.string()
+  details: z95.string(),
+  remediation: z95.string()
 });
-var ValidationWarningSchema = z94.object({
-  code: z94.string().min(1),
-  message: z94.string(),
-  affected: z94.string()
+var ValidationWarningSchema = z95.object({
+  code: z95.string().min(1),
+  message: z95.string(),
+  affected: z95.string()
 });
-var ValidationResultSchema = z94.object({
-  valid: z94.boolean(),
-  toolName: z94.string().min(1),
-  violations: z94.array(ConstraintViolationSchema),
-  passed: z94.array(z94.string()),
-  warnings: z94.array(ValidationWarningSchema),
-  validatedAt: z94.date()
+var ValidationResultSchema = z95.object({
+  valid: z95.boolean(),
+  toolName: z95.string().min(1),
+  violations: z95.array(ConstraintViolationSchema),
+  passed: z95.array(z95.string()),
+  warnings: z95.array(ValidationWarningSchema),
+  validatedAt: z95.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -45495,22 +45513,22 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/task-analyzer.ts
-import { z as z95 } from "zod";
-var TaskProfileSchema = z95.object({
+import { z as z96 } from "zod";
+var TaskProfileSchema = z96.object({
   /** Estimated input tokens required */
-  contextRequired: z95.number().min(0),
+  contextRequired: z96.number().min(0),
   /** Reasoning complexity on 0-10 scale */
-  reasoningComplexity: z95.number().min(0).max(10),
+  reasoningComplexity: z96.number().min(0).max(10),
   /** Whether task involves code generation */
-  codeGeneration: z95.boolean(),
+  codeGeneration: z96.boolean(),
   /** Whether task involves multimodal content (images, etc.) */
-  multimodal: z95.boolean(),
+  multimodal: z96.boolean(),
   /** Whether task can be split into parallel subtasks */
-  parallelizable: z95.boolean(),
+  parallelizable: z96.boolean(),
   /** Whether cost should be minimized */
-  budgetSensitive: z95.boolean(),
+  budgetSensitive: z96.boolean(),
   /** Primary task type classification */
-  taskType: z95.enum([
+  taskType: z96.enum([
     "architecture",
     "code_implementation",
     "code_review",
@@ -45524,53 +45542,53 @@ var TaskProfileSchema = z95.object({
 });
 
 // src/cli-adapters/router-types.ts
-import { z as z96 } from "zod";
-var RouterConfigSchema = z96.object({
-  minCapacityThreshold: z96.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z96.boolean().default(false),
-  maxDecisionTimeMs: z96.number().min(1).max(1e3).default(100)
+import { z as z97 } from "zod";
+var RouterConfigSchema = z97.object({
+  minCapacityThreshold: z97.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z97.boolean().default(false),
+  maxDecisionTimeMs: z97.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z97 } from "zod";
-var AgreementCascadeConfigSchema = z97.object({
-  agreementThreshold: z97.number().min(0.5).max(1).default(0.7),
-  maxStages: z97.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z97.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z98 } from "zod";
+var AgreementCascadeConfigSchema = z98.object({
+  agreementThreshold: z98.number().min(0.5).max(1).default(0.7),
+  maxStages: z98.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z98.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger42 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/daao-types.ts
-import { z as z98 } from "zod";
-var EncodedFeaturesSchema = z98.object({
+import { z as z99 } from "zod";
+var EncodedFeaturesSchema = z99.object({
   /** Lexical complexity score (vocabulary diversity, rare words) */
-  lexicalComplexity: z98.number().min(0).max(1),
+  lexicalComplexity: z99.number().min(0).max(1),
   /** Syntactic complexity score (sentence structure, nesting) */
-  syntacticComplexity: z98.number().min(0).max(1),
+  syntacticComplexity: z99.number().min(0).max(1),
   /** Semantic density score (concept density, abstraction level) */
-  semanticDensity: z98.number().min(0).max(1),
+  semanticDensity: z99.number().min(0).max(1),
   /** Technical specificity (domain-specific terminology) */
-  technicalSpecificity: z98.number().min(0).max(1),
+  technicalSpecificity: z99.number().min(0).max(1),
   /** Task scope (breadth of requirements) */
-  taskScope: z98.number().min(0).max(1),
+  taskScope: z99.number().min(0).max(1),
   /** Constraint complexity (constraints, edge cases, requirements) */
-  constraintComplexity: z98.number().min(0).max(1),
+  constraintComplexity: z99.number().min(0).max(1),
   /** Ambiguity level (inverse - higher means more clear/specific) */
-  clarity: z98.number().min(0).max(1),
+  clarity: z99.number().min(0).max(1),
   /** Output complexity expectation */
-  outputComplexity: z98.number().min(0).max(1)
+  outputComplexity: z99.number().min(0).max(1)
 });
-var FeatureWeightsSchema = z98.object({
-  lexicalComplexity: z98.number().min(0).max(1),
-  syntacticComplexity: z98.number().min(0).max(1),
-  semanticDensity: z98.number().min(0).max(1),
-  technicalSpecificity: z98.number().min(0).max(1),
-  taskScope: z98.number().min(0).max(1),
-  constraintComplexity: z98.number().min(0).max(1),
-  clarity: z98.number().min(0).max(1),
-  outputComplexity: z98.number().min(0).max(1)
+var FeatureWeightsSchema = z99.object({
+  lexicalComplexity: z99.number().min(0).max(1),
+  syntacticComplexity: z99.number().min(0).max(1),
+  semanticDensity: z99.number().min(0).max(1),
+  technicalSpecificity: z99.number().min(0).max(1),
+  taskScope: z99.number().min(0).max(1),
+  constraintComplexity: z99.number().min(0).max(1),
+  clarity: z99.number().min(0).max(1),
+  outputComplexity: z99.number().min(0).max(1)
 });
 var DEFAULT_FEATURE_WEIGHTS = {
   lexicalComplexity: 0.1,
@@ -45592,50 +45610,50 @@ var DEFAULT_DAAO_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DAAOConfigSchema = z98.object({
+var DAAOConfigSchema = z99.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z98.object({
-    easyUpperBound: z98.number().min(0).max(1),
-    hardLowerBound: z98.number().min(0).max(1)
+  thresholds: z99.object({
+    easyUpperBound: z99.number().min(0).max(1),
+    hardLowerBound: z99.number().min(0).max(1)
   }).default(DEFAULT_DAAO_THRESHOLDS),
   /** Feature weights for difficulty aggregation */
   weights: FeatureWeightsSchema.default(DEFAULT_FEATURE_WEIGHTS),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z98.record(
-    z98.enum(["fast", "balanced", "powerful"]),
-    z98.array(z98.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z99.record(
+    z99.enum(["fast", "balanced", "powerful"]),
+    z99.array(z99.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_DAAO_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z98.boolean().default(true),
+  enableCalibration: z99.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z98.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z99.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z98.number().int().positive().default(50),
+  minCalibrationOutcomes: z99.number().int().positive().default(50),
   /** Reconstruction error threshold for typical patterns */
-  typicalPatternThreshold: z98.number().min(0).max(1).default(0.3),
+  typicalPatternThreshold: z99.number().min(0).max(1).default(0.3),
   /** Verbose logging */
-  verbose: z98.boolean().default(false)
+  verbose: z99.boolean().default(false)
 });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z99 } from "zod";
-var ClassificationPatternsSchema = z99.object({
-  code: z99.array(z99.string()).readonly(),
-  research: z99.array(z99.string()).readonly(),
-  documentation: z99.array(z99.string()).readonly(),
-  analysis: z99.array(z99.string()).readonly()
+import { z as z100 } from "zod";
+var ClassificationPatternsSchema = z100.object({
+  code: z100.array(z100.string()).readonly(),
+  research: z100.array(z100.string()).readonly(),
+  documentation: z100.array(z100.string()).readonly(),
+  analysis: z100.array(z100.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z100 } from "zod";
-var ResponseCacheConfigSchema = z100.object({
-  defaultTTL: z100.number().min(1e3).max(36e5).default(3e5),
+import { z as z101 } from "zod";
+var ResponseCacheConfigSchema = z101.object({
+  defaultTTL: z101.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z100.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z100.number().min(1).max(1e3).default(50),
-  cleanupInterval: z100.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z101.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z101.number().min(1).max(1e3).default(50),
+  cleanupInterval: z101.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z100.boolean().default(false)
+  enableLogging: z101.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -45643,12 +45661,12 @@ import { createHash as createHash4 } from "crypto";
 var logger43 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z101 } from "zod";
-var UnifiedRoutingDecisionSchema = z101.object({
-  selectedCli: z101.string(),
-  confidence: z101.number().min(0).max(1),
-  reason: z101.string(),
-  strategy: z101.enum([
+import { z as z102 } from "zod";
+var UnifiedRoutingDecisionSchema = z102.object({
+  selectedCli: z102.string(),
+  confidence: z102.number().min(0).max(1),
+  reason: z102.string(),
+  strategy: z102.enum([
     "composite",
     "quality",
     "budget",
@@ -45660,57 +45678,57 @@ var UnifiedRoutingDecisionSchema = z101.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z101.number().nonnegative(),
-  alternatives: z101.array(z101.string()).readonly(),
-  stagesExecuted: z101.array(z101.string()).readonly(),
-  withinBudget: z101.boolean().optional(),
-  estimatedComplexity: z101.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z101.number().int().positive().optional(),
-  topsisScore: z101.number().optional(),
-  ucbScore: z101.number().optional(),
-  resolvedAtStage: z101.number().int().nonnegative().optional(),
-  consensusReached: z101.boolean().optional(),
-  agreementScore: z101.number().min(0).max(1).optional(),
-  metadata: z101.record(z101.string(), z101.unknown()).optional()
+  decisionTimeMs: z102.number().nonnegative(),
+  alternatives: z102.array(z102.string()).readonly(),
+  stagesExecuted: z102.array(z102.string()).readonly(),
+  withinBudget: z102.boolean().optional(),
+  estimatedComplexity: z102.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z102.number().int().positive().optional(),
+  topsisScore: z102.number().optional(),
+  ucbScore: z102.number().optional(),
+  resolvedAtStage: z102.number().int().nonnegative().optional(),
+  consensusReached: z102.boolean().optional(),
+  agreementScore: z102.number().min(0).max(1).optional(),
+  metadata: z102.record(z102.string(), z102.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z102 } from "zod";
-var QualitySignalsSchema = z102.object({
-  testsPass: z102.boolean().optional(),
-  lintErrors: z102.number().int().min(0).optional(),
-  userApproved: z102.boolean().optional(),
-  retryCount: z102.number().int().min(0).default(0),
-  completionRatio: z102.number().min(0).max(1).default(1),
-  validStructure: z102.boolean().optional(),
-  coherenceScore: z102.number().min(0).max(1).optional()
+import { z as z103 } from "zod";
+var QualitySignalsSchema = z103.object({
+  testsPass: z103.boolean().optional(),
+  lintErrors: z103.number().int().min(0).optional(),
+  userApproved: z103.boolean().optional(),
+  retryCount: z103.number().int().min(0).default(0),
+  completionRatio: z103.number().min(0).max(1).default(1),
+  validStructure: z103.boolean().optional(),
+  coherenceScore: z103.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z102.object({
-  id: z102.uuid(),
-  timestamp: z102.iso.datetime(),
-  query: z102.string(),
-  routerType: z102.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z102.string(),
-  selectedTier: z102.enum(["strong", "weak"]).optional(),
-  armIndex: z102.number().int().min(0).optional(),
-  banditContext: z102.record(z102.string(), z102.unknown()).optional(),
-  queryFeatures: z102.record(z102.string(), z102.unknown()).optional(),
-  ucbScore: z102.number().optional(),
-  confidence: z102.number().min(0).max(1).optional(),
-  traceId: z102.string(),
-  domain: z102.string().optional()
+var RoutingDecisionSchema = z103.object({
+  id: z103.uuid(),
+  timestamp: z103.iso.datetime(),
+  query: z103.string(),
+  routerType: z103.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z103.string(),
+  selectedTier: z103.enum(["strong", "weak"]).optional(),
+  armIndex: z103.number().int().min(0).optional(),
+  banditContext: z103.record(z103.string(), z103.unknown()).optional(),
+  queryFeatures: z103.record(z103.string(), z103.unknown()).optional(),
+  ucbScore: z103.number().optional(),
+  confidence: z103.number().min(0).max(1).optional(),
+  traceId: z103.string(),
+  domain: z103.string().optional()
 });
-var TaskOutcomeSchema = z102.object({
-  routingDecisionId: z102.uuid(),
-  timestamp: z102.iso.datetime(),
-  outcomeClass: z102.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z102.boolean(),
-  qualityScore: z102.number().min(0).max(1),
-  durationMs: z102.number().min(0),
-  tokenUsage: z102.number().int().min(0),
-  errorMessage: z102.string().optional(),
+var TaskOutcomeSchema = z103.object({
+  routingDecisionId: z103.uuid(),
+  timestamp: z103.iso.datetime(),
+  outcomeClass: z103.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z103.boolean(),
+  qualityScore: z103.number().min(0).max(1),
+  durationMs: z103.number().min(0),
+  tokenUsage: z103.number().int().min(0),
+  errorMessage: z103.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z102.string()
+  traceId: z103.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -45725,17 +45743,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z102.object({
-  maxPendingDecisions: z102.number().int().positive().default(1e3),
-  pendingTimeoutMs: z102.number().positive().default(3e5),
-  enableAutoReward: z102.boolean().default(true),
-  qualityWeight: z102.number().min(0).max(1).default(0.5),
-  speedWeight: z102.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z102.number().min(0).max(1).default(0.2),
-  retryPenalty: z102.number().min(0).max(1).default(0.1),
-  targetDurationMs: z102.number().positive().default(5e3),
-  targetTokenUsage: z102.number().positive().default(2e3),
-  maxHistorySize: z102.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z103.object({
+  maxPendingDecisions: z103.number().int().positive().default(1e3),
+  pendingTimeoutMs: z103.number().positive().default(3e5),
+  enableAutoReward: z103.boolean().default(true),
+  qualityWeight: z103.number().min(0).max(1).default(0.5),
+  speedWeight: z103.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z103.number().min(0).max(1).default(0.2),
+  retryPenalty: z103.number().min(0).max(1).default(0.1),
+  targetDurationMs: z103.number().positive().default(5e3),
+  targetTokenUsage: z103.number().positive().default(2e3),
+  maxHistorySize: z103.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -48129,13 +48147,13 @@ function createEmptyContext() {
     approachHistory: []
   };
 }
-function assignRelevance(path21, response) {
+function assignRelevance(path20, response) {
   const lowerResponse = response.toLowerCase();
-  const lowerPath = path21.toLowerCase();
+  const lowerPath = path20.toLowerCase();
   const idx = lowerResponse.indexOf(lowerPath);
   if (idx === -1) return "low";
   const surroundStart = Math.max(0, idx - 100);
-  const surroundEnd = Math.min(lowerResponse.length, idx + path21.length + 100);
+  const surroundEnd = Math.min(lowerResponse.length, idx + path20.length + 100);
   const surrounding = lowerResponse.slice(surroundStart, surroundEnd);
   if (/(?:root cause|bug|fix|patch|change|modify|edit)/i.test(surrounding)) {
     return "high";
@@ -48279,9 +48297,9 @@ var SAFE_COMMIT_RE = /^[0-9a-f]{7,40}$/i;
 var SAFE_REPO_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
 async function tryExistingClone(repoDir, commit, exec5) {
   const fs20 = await import("fs/promises");
-  const path21 = await import("path");
+  const path20 = await import("path");
   try {
-    await fs20.access(path21.join(repoDir, ".git"));
+    await fs20.access(path20.join(repoDir, ".git"));
     await exec5(`git checkout -- .`, { cwd: repoDir, timeout: GIT_TIMEOUT_MS });
     await exec5(`git clean -fd`, { cwd: repoDir, timeout: GIT_TIMEOUT_MS });
     try {
@@ -48300,7 +48318,7 @@ async function tryExistingClone(repoDir, commit, exec5) {
   }
 }
 async function cloneRepository(repo, commit, workDir) {
-  const path21 = await import("path");
+  const path20 = await import("path");
   const fs20 = await import("fs/promises");
   const childProcess = await import("child_process");
   const { promisify: promisify9 } = await import("util");
@@ -48311,7 +48329,7 @@ async function cloneRepository(repo, commit, workDir) {
   if (!SAFE_COMMIT_RE.test(commit)) {
     return { ok: false, error: new AgentRunnerError(`Invalid commit hash: ${commit}`) };
   }
-  const repoDir = path21.join(workDir, repo.replaceAll("/", "__"));
+  const repoDir = path20.join(workDir, repo.replaceAll("/", "__"));
   try {
     await fs20.mkdir(workDir, { recursive: true });
     const cloned = await tryExistingClone(repoDir, commit, exec5);
@@ -48330,8 +48348,8 @@ async function applyPatch(repoDir, patch) {
   const { promisify: promisify9 } = await import("util");
   const exec5 = promisify9(childProcess.exec);
   const fs20 = await import("fs/promises");
-  const path21 = await import("path");
-  const patchFile = path21.join(repoDir, ".agent_patch.diff");
+  const path20 = await import("path");
+  const patchFile = path20.join(repoDir, ".agent_patch.diff");
   try {
     await fs20.writeFile(patchFile, patch);
     await exec5(`git apply --whitespace=fix ${patchFile}`, {
@@ -49469,7 +49487,7 @@ function transformHarnessOutput(raw) {
 // src/swe-bench/harness-file-operations.ts
 import { spawn } from "child_process";
 import * as fs14 from "fs/promises";
-import * as path14 from "path";
+import * as path13 from "path";
 var capitalizeFirst = capitalize;
 function buildHarnessArgs(config) {
   const args = [
@@ -49566,7 +49584,7 @@ function createInitialProgress(totalCount) {
   };
 }
 function getResultsFilePath(config) {
-  return path14.join(config.outputDir, config.runId, "results.json");
+  return path13.join(config.outputDir, config.runId, "results.json");
 }
 
 // src/swe-bench/harness-process-runner.ts
@@ -50123,7 +50141,7 @@ function formatValidationResult(result) {
 }
 
 // src/swe-bench/evaluation-harness-helpers.ts
-import * as os5 from "os";
+import * as os3 from "os";
 function calculateMetrics(results) {
   const totalInstances = results.length;
   const predictedInstances = totalInstances;
@@ -50215,12 +50233,12 @@ function createProgressAdapter(totalPredictions, onProgress) {
 }
 function getMemoryInfo() {
   return {
-    total: os5.totalmem(),
-    free: os5.freemem()
+    total: os3.totalmem(),
+    free: os3.freemem()
   };
 }
 function getCpuCores() {
-  return os5.cpus().length;
+  return os3.cpus().length;
 }
 
 // src/swe-bench/evaluation-harness.ts
@@ -51304,11 +51322,11 @@ function parsePatch(patch) {
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify7 } from "util";
 import * as fs15 from "fs/promises";
-import * as path15 from "path";
+import * as path14 from "path";
 var execFileAsync5 = promisify7(execFile5);
 var MAX_OUTPUT_BUFFER = 5 * 1024 * 1024;
 async function writeTempPatch(patch, workDir) {
-  const tempPath = path15.join(workDir, `.patch-${String(getTimeProvider().now())}.patch`);
+  const tempPath = path14.join(workDir, `.patch-${String(getTimeProvider().now())}.patch`);
   await fs15.writeFile(tempPath, patch, "utf-8");
   return tempPath;
 }
@@ -51559,9 +51577,9 @@ var TestRunnerError = class extends Error {
 
 // src/swe-bench/test-runner-parser.ts
 import * as fs16 from "fs/promises";
-import * as path16 from "path";
+import * as path15 from "path";
 async function readJsonResults(workDir) {
-  const jsonPath = path16.join(workDir, "test-results.json");
+  const jsonPath = path15.join(workDir, "test-results.json");
   try {
     const content = await fs16.readFile(jsonPath, "utf-8");
     return JSON.parse(content);
@@ -51756,7 +51774,7 @@ ${getStderr()}`.trim();
 import { exec as exec3 } from "child_process";
 import { promisify as promisify8 } from "util";
 import * as fs17 from "fs/promises";
-import * as path17 from "path";
+import * as path16 from "path";
 var execAsync3 = promisify8(exec3);
 var FRAMEWORK_CONFIG_FILES = {
   pytest: ["pytest.ini", "pyproject.toml", "setup.cfg", "conftest.py", "tox.ini"],
@@ -51862,7 +51880,7 @@ var TestRunner = class {
   async findConfigFiles(workDir, configFiles) {
     const found = [];
     for (const file of configFiles) {
-      const filePath = path17.join(workDir, file);
+      const filePath = path16.join(workDir, file);
       try {
         await fs17.access(filePath);
         found.push(file);
@@ -52015,7 +52033,7 @@ async function detectTestFramework(workDir) {
 
 // src/swe-bench/report-generator.ts
 import * as fs18 from "fs/promises";
-import * as path18 from "path";
+import * as path17 from "path";
 
 // src/swe-bench/report-renderer.ts
 function renderReport(report, format) {
@@ -52371,7 +52389,7 @@ var ReportGenerator = class {
   async save(report, config) {
     this.logger.info("Saving report", { outputPath: config.outputPath });
     const content = await this.render(report, config.format);
-    await fs18.mkdir(path18.dirname(config.outputPath), { recursive: true });
+    await fs18.mkdir(path17.dirname(config.outputPath), { recursive: true });
     await fs18.writeFile(config.outputPath, content, "utf-8");
     this.logger.info("Report saved", { path: config.outputPath, format: config.format });
   }
@@ -52591,14 +52609,14 @@ async function exportReport(result, outputPath, config) {
 
 // src/swe-bench/trace-logger.ts
 import { appendFile, writeFile as writeFile6 } from "fs/promises";
-import * as path19 from "path";
+import * as path18 from "path";
 function deriveTracePath(outputPath) {
-  const ext = path19.extname(outputPath);
+  const ext = path18.extname(outputPath);
   const base = outputPath.slice(0, outputPath.length - ext.length);
   return `${base}-trace.jsonl`;
 }
 function deriveStatusPath(outputPath) {
-  const ext = path19.extname(outputPath);
+  const ext = path18.extname(outputPath);
   const base = outputPath.slice(0, outputPath.length - ext.length);
   return `${base}-status.json`;
 }
@@ -52804,7 +52822,7 @@ function getStdinLifecycleMonitor() {
 
 // src/pipeline/task-tracker.ts
 import * as fs19 from "fs";
-import * as path20 from "path";
+import * as path19 from "path";
 var logger55 = createLogger({ component: "task-tracker" });
 async function exec4(cmd, args, timeout = 15e3) {
   const { execFile: execFile6 } = await import("child_process");
@@ -52882,8 +52900,8 @@ var JsonTaskTracker = class {
   outputPath;
   constructor(config) {
     const dir = config.outputDir ?? ".nexus-pipeline";
-    this.outputPath = path20.resolve(dir, "tasks.json");
-    fs19.mkdirSync(path20.dirname(this.outputPath), { recursive: true });
+    this.outputPath = path19.resolve(dir, "tasks.json");
+    fs19.mkdirSync(path19.dirname(this.outputPath), { recursive: true });
   }
   async createTask(title, body) {
     const id = String(this.nextId++);
@@ -53643,4 +53661,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-JLYJQ7OG.js.map
+//# sourceMappingURL=chunk-5JSMLCCK.js.map