nexus-agents 2.63.6 → 2.64.0

package/dist/{chunk-CUGQAPGY.js → chunk-RLLMWZAE.js}

@@ -69,7 +69,7 @@ import {
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-HRTGSG4L.js";
+} from "./chunk-Q3PDQ3FZ.js";
 import {
   DEFAULTS
 } from "./chunk-6MRF2PE2.js";
@@ -2468,13 +2468,13 @@ function makeCancelError(taskId) {
 }
 function executeWithTimeout(params) {
   const { task, maxDurationMs, executeTask, transformError, signal } = params;
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
       clearTimeout(timeoutId);
-      resolve18(result);
+      resolve19(result);
     };
     const timeoutId = setTimeout(() => {
       settle(
@@ -7856,13 +7856,13 @@ var WaveScheduler = class {
   }
   async withTimeout(promise, timeoutMs, taskId) {
     if (timeoutMs <= 0) return promise;
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`Task ${taskId} timed out after ${String(timeoutMs)}ms`));
       }, timeoutMs);
       promise.then((result) => {
         clearTimeout(timer);
-        resolve18(result);
+        resolve19(result);
       }).catch((error) => {
         clearTimeout(timer);
         reject(error instanceof Error ? error : new Error(String(error)));
@@ -13903,7 +13903,7 @@ function wouldCreateCycle(from, to, getNode) {
   return canReach(to, from, /* @__PURE__ */ new Set(), getNode);
 }
 function findCyclePath(from, to, getNode) {
-  const path19 = [from, to];
+  const path20 = [from, to];
   const visited = /* @__PURE__ */ new Set([from]);
   const findPath = (current) => {
     if (current === from) return true;
@@ -13912,9 +13912,9 @@ function findCyclePath(from, to, getNode) {
     for (const depId of node.dependencies.keys()) {
       if (!visited.has(depId)) {
         visited.add(depId);
-        path19.push(depId);
+        path20.push(depId);
         if (findPath(depId)) return true;
-        path19.pop();
+        path20.pop();
       } else if (depId === from) {
         return true;
       }
@@ -13922,7 +13922,7 @@ function findCyclePath(from, to, getNode) {
     return false;
   };
   findPath(to);
-  return path19;
+  return path20;
 }
 function detectCycleDFS(nodeId, visited, stack, getNode) {
   visited.add(nodeId);
@@ -13941,29 +13941,29 @@ function detectCycleDFS(nodeId, visited, stack, getNode) {
   return false;
 }
 function findCycleFromNode(startId, getNode) {
-  const path19 = [];
+  const path20 = [];
   const visited = /* @__PURE__ */ new Set();
   const dfs = (nodeId) => {
-    if (path19.includes(nodeId)) {
-      const cycleStart = path19.indexOf(nodeId);
-      path19.splice(0, cycleStart);
-      path19.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);
-    path19.push(nodeId);
+    path20.push(nodeId);
     const node = getNode(nodeId);
     if (node) {
       for (const depId of node.dependencies.keys()) {
         if (dfs(depId)) return true;
       }
     }
-    path19.pop();
+    path20.pop();
     return false;
   };
   dfs(startId);
-  return path19;
+  return path20;
 }
 
 // src/agents/skills/skill-dependency-graph.ts
@@ -18202,9 +18202,9 @@ var ExpertPool = class {
     if (this.active < this.capacity) {
       return this.issuePermit();
     }
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       const timer = setTimeout(() => {
-        const idx = this.queue.findIndex((e) => e.resolve === resolve18);
+        const idx = this.queue.findIndex((e) => e.resolve === resolve19);
         if (idx !== -1) {
           this.queue.splice(idx, 1);
         }
@@ -18214,7 +18214,7 @@ var ExpertPool = class {
           )
         );
       }, this.acquireTimeoutMs);
-      this.queue.push({ resolve: resolve18, reject, timer });
+      this.queue.push({ resolve: resolve19, reject, timer });
     });
   }
   /** Release a permit back to the pool. */
@@ -18508,18 +18508,18 @@ var DependencyGraph = class {
     }
     const startNode = firstNode;
     const visited = /* @__PURE__ */ new Set();
-    const path19 = [];
+    const path20 = [];
     const dfs = (nodeId) => {
-      if (path19.includes(nodeId)) {
-        const cycleStart = path19.indexOf(nodeId);
-        path19.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);
-      path19.push(nodeId);
+      path20.push(nodeId);
       const node = this.nodes.get(nodeId);
       if (node) {
         for (const depId of node.dependencies) {
@@ -18530,11 +18530,11 @@ var DependencyGraph = class {
           }
         }
       }
-      path19.pop();
+      path20.pop();
       return false;
     };
     dfs(startNode);
-    return path19.length > 0 ? path19 : cycleNodes.slice(0, 3);
+    return path20.length > 0 ? path20 : cycleNodes.slice(0, 3);
   }
   /**
    * Gets the execution order (topologically sorted step IDs).
@@ -18800,8 +18800,8 @@ var TaskQueue = class {
     if (this.cancelled) {
       return Promise.reject(new Error("Queue has been cancelled"));
     }
-    return new Promise((resolve18, reject) => {
-      this.queue.push({ task, resolve: resolve18, reject });
+    return new Promise((resolve19, reject) => {
+      this.queue.push({ task, resolve: resolve19, reject });
       this.processNext();
     });
   }
@@ -19077,16 +19077,16 @@ async function executeStepWithTimeout(step, context, stepExecutor, signal) {
   return executeWithTimeout2(step, stepContext, stepExecutor, stepTimeout, startTime);
 }
 function executeWithTimeout2(step, context, executor, timeout, startTime) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const timeoutId = setTimeout(() => {
-      resolve18(createTimeoutResult(step.id, getTimeProvider().now() - startTime, timeout));
+      resolve19(createTimeoutResult(step.id, getTimeProvider().now() - startTime, timeout));
     }, timeout);
     executor(step, context).then((result) => {
       clearTimeout(timeoutId);
-      resolve18(result);
+      resolve19(result);
     }).catch((error) => {
       clearTimeout(timeoutId);
-      resolve18(createErrorResult(step.id, getTimeProvider().now() - startTime, error));
+      resolve19(createErrorResult(step.id, getTimeProvider().now() - startTime, error));
     });
   });
 }
@@ -19386,9 +19386,9 @@ function getBuiltInTemplatesPath() {
     join3(dirname2(currentDir), "workflows", "templates"),
     join3(dirname2(currentDir), "dist", "workflows", "templates")
   ];
-  for (const path19 of possiblePaths) {
-    if (existsSync3(path19)) {
-      return path19;
+  for (const path20 of possiblePaths) {
+    if (existsSync3(path20)) {
+      return path20;
     }
   }
   return join3(currentDir, "templates");
@@ -19929,9 +19929,9 @@ function validateRequiredInputs(inputs, required) {
 }
 
 // src/workflows/expression-resolver-helpers.ts
-function getNestedValue(obj, path19) {
+function getNestedValue(obj, path20) {
   let current = obj;
-  for (const key of path19) {
+  for (const key of path20) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -19942,24 +19942,24 @@ function getNestedValue(obj, path19) {
   }
   return current;
 }
-function resolveInputs(path19, context) {
-  const value = getNestedValue(context.inputs, path19);
+function resolveInputs(path20, context) {
+  const value = getNestedValue(context.inputs, path20);
   if (value === void 0) {
     return {
       success: false,
-      error: `Input '${path19.join(".")}' not found`
+      error: `Input '${path20.join(".")}' not found`
     };
   }
   return { success: true, value };
 }
-function validateStepPath(path19) {
-  if (path19.length < 2) {
+function validateStepPath(path20) {
+  if (path20.length < 2) {
     return {
       success: false,
       error: "Steps expression requires at least stepId and output"
     };
   }
-  if (path19[0] === void 0 || path19[1] === void 0) {
+  if (path20[0] === void 0 || path20[1] === void 0) {
     return {
       success: false,
       error: "Steps expression requires stepId and output"
@@ -19985,12 +19985,12 @@ function validateStepResult(stepId, outputKey, stepResult) {
   }
   return null;
 }
-function resolveSteps(path19, context) {
-  const pathError = validateStepPath(path19);
+function resolveSteps(path20, context) {
+  const pathError = validateStepPath(path20);
   if (pathError !== null) return pathError;
-  const stepId = path19[0] ?? "";
-  const outputKey = path19[1] ?? "";
-  const rest = path19.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;
@@ -20006,15 +20006,15 @@ function resolveSteps(path19, context) {
   }
   return { success: true, value };
 }
-function resolveVariables(path19, context) {
-  if (path19.length === 0) {
+function resolveVariables(path20, context) {
+  if (path20.length === 0) {
     return {
       success: false,
       error: "Variables expression requires a variable name"
     };
   }
-  const varName = path19[0];
-  const rest = path19.slice(1);
+  const varName = path20[0];
+  const rest = path20.slice(1);
   if (varName === void 0) {
     return {
       success: false,
@@ -21037,8 +21037,8 @@ var WorkflowEngine = class {
     this.config = resolveConfig2(config);
   }
   /** Load workflow template from file. */
-  async loadTemplate(path19) {
-    return this.deps.loadWorkflowFile(path19);
+  async loadTemplate(path20) {
+    return this.deps.loadWorkflowFile(path20);
   }
   /** Execute a workflow with inputs. */
   async execute(workflow, inputs) {
@@ -21142,8 +21142,8 @@ var WorkflowEngine = class {
     }
     return Promise.resolve(templates);
   }
-  createTemplate(workflow, path19, category) {
-    const t = { name: workflow.name, version: workflow.version, path: path19, 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;
   }
@@ -21429,8 +21429,8 @@ function createParseWorkflow() {
   };
 }
 function createLoadWorkflowFile() {
-  return async (path19) => {
-    const result = await loadWorkflowFile(path19);
+  return async (path20) => {
+    const result = await loadWorkflowFile(path20);
     if (!result.ok) {
       if (result.error instanceof ParseError) {
         return result;
@@ -23478,10 +23478,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 z104 = getZScore(confidence);
+  const z107 = getZScore(confidence);
   return {
-    lower: difference - z104 * seDiff,
-    upper: difference + z104 * seDiff,
+    lower: difference - z107 * seDiff,
+    upper: difference + z107 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23504,11 +23504,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z104 = getZScore(opts.confidence);
-  const z210 = z104 * z104;
+  const z107 = getZScore(opts.confidence);
+  const z210 = z107 * z107;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z104 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z107 / 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);
@@ -23538,8 +23538,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 z104 = getZScore(opts.confidence);
-  const margin = z104 * standardError;
+  const z107 = getZScore(opts.confidence);
+  const margin = z107 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -26932,13 +26932,13 @@ function dedupe(ids) {
   return [...new Set(ids)];
 }
 async function withTimeout2(promise, ms) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     const timer = setTimeout(() => {
       reject(new Error(`Node timed out after ${String(ms)}ms`));
     }, ms);
     promise.then((result) => {
       clearTimeout(timer);
-      resolve18(result);
+      resolve19(result);
     }).catch((error) => {
       clearTimeout(timer);
       reject(error instanceof Error ? error : new Error(String(error)));
@@ -27071,31 +27071,31 @@ var GraphBuilder = class {
     }
     const visited = /* @__PURE__ */ new Set();
     const stack = /* @__PURE__ */ new Set();
-    const path19 = [];
+    const path20 = [];
     for (const nodeId of this.nodes.keys()) {
-      const cycle = this.dfs(nodeId, adj, visited, stack, path19);
+      const cycle = this.dfs(nodeId, adj, visited, stack, path20);
       if (cycle !== void 0) return cycle;
     }
     return void 0;
   }
-  dfs(nodeId, adj, visited, stack, path19) {
+  dfs(nodeId, adj, visited, stack, path20) {
     if (stack.has(nodeId)) {
-      const cycleStart = path19.indexOf(nodeId);
-      const cyclePath = path19.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);
-    path19.push(nodeId);
+    path20.push(nodeId);
     const neighbors = adj.get(nodeId) ?? [];
     for (const neighbor of neighbors) {
-      const cycle = this.dfs(neighbor, adj, visited, stack, path19);
+      const cycle = this.dfs(neighbor, adj, visited, stack, path20);
       if (cycle !== void 0) return cycle;
     }
     stack.delete(nodeId);
-    path19.pop();
+    path20.pop();
     return void 0;
   }
   checkReachability() {
@@ -27763,8 +27763,8 @@ function extractModelAttribution(event) {
   };
 }
 function extractRoutingAttribution(event) {
-  const path19 = event.decisionPath !== void 0 ? [...event.decisionPath] : void 0;
-  return { modelId: event.selectedModel, reasoning: event.reasoning, decisionPath: path19 };
+  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") {
@@ -29190,10 +29190,10 @@ function createMockTechLead() {
 async function raceAgainstDeadline(promise, deadlineMs, onTimeout) {
   const startedAt = Date.now();
   let timer;
-  const timeoutP = new Promise((resolve18) => {
+  const timeoutP = new Promise((resolve19) => {
     timer = setTimeout(
       () => {
-        resolve18(onTimeout(Date.now() - startedAt));
+        resolve19(onTimeout(Date.now() - startedAt));
       },
       Math.max(0, deadlineMs)
     );
@@ -30373,11 +30373,11 @@ function createWorkerTask(entry, taskIndex, waveNumber, opts) {
     }
     const staggerMs = taskIndex * opts.staggerDelayMs;
     if (staggerMs > 0) {
-      await new Promise((resolve18) => setTimeout(resolve18, staggerMs));
+      await new Promise((resolve19) => setTimeout(resolve19, staggerMs));
     }
     const spacingDelay = opts.failureTracker.getSpacingDelay(entry.role);
     if (spacingDelay > 0) {
-      await new Promise((resolve18) => setTimeout(resolve18, spacingDelay));
+      await new Promise((resolve19) => setTimeout(resolve19, spacingDelay));
     }
     const timeoutMs = opts.options.workerTimeoutMs ?? getExpertTaskTimeout(entry.subTask);
     const result = await executeSafe({
@@ -30429,7 +30429,7 @@ async function maybeDelayForRateLimit(results, waveIdx, totalWaves) {
   );
   if (hasRateLimit) {
     logger24.warn("Rate-limit detected \u2014 delaying next wave", { delayMs: RATE_LIMIT_WAVE_DELAY_MS });
-    await new Promise((resolve18) => setTimeout(resolve18, RATE_LIMIT_WAVE_DELAY_MS));
+    await new Promise((resolve19) => setTimeout(resolve19, RATE_LIMIT_WAVE_DELAY_MS));
   }
 }
 function emitWaveStarted(ctx, workerCount, roles) {
@@ -30523,7 +30523,7 @@ async function maybeRetryAfterTriage(opts) {
   }
   const useAltCli = triage.action === "retry_different_cli" && altExecuteWorker !== void 0;
   if (triage.action === "retry_different_cli") {
-    await new Promise((resolve18) => setTimeout(resolve18, RATE_LIMIT_SPACING_MS));
+    await new Promise((resolve19) => setTimeout(resolve19, RATE_LIMIT_SPACING_MS));
   }
   const retryTimeout = triage.action === "extend_timeout" ? Math.min(timeoutMs * TIMEOUT_EXTENSION_FACTOR, MAX_WORKER_TIMEOUT_MS) : timeoutMs;
   const retryExecutor = useAltCli ? altExecuteWorker : executeWorker;
@@ -36466,8 +36466,8 @@ async function saveSourcesRegistry(registry, rootDir) {
   const pathResult = validatePath3(filePath, root);
   if (!pathResult.ok) return pathResult;
   try {
-    const yaml3 = stringifyYaml(registry, { indent: 2 });
-    await fs6.writeFile(pathResult.value, yaml3, "utf-8");
+    const yaml4 = stringifyYaml(registry, { indent: 2 });
+    await fs6.writeFile(pathResult.value, yaml4, "utf-8");
     return { ok: true, value: void 0 };
   } catch (error) {
     return {
@@ -38793,12 +38793,12 @@ function extractFileReferences(markdown) {
   let match;
   FILE_REF_PATTERN.lastIndex = 0;
   while ((match = FILE_REF_PATTERN.exec(markdown)) !== null) {
-    const path19 = match[1];
-    if (path19 === void 0 || seen.has(path19)) continue;
-    seen.add(path19);
+    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: path19, line } : { path: path19 });
+    refs.push(line !== void 0 ? { path: path20, line } : { path: path20 });
   }
   return refs;
 }
@@ -40631,27 +40631,27 @@ var FileAuditStorage = class _FileAuditStorage {
     const data = this.writeBuffer.join("");
     this.writeBuffer = [];
     const stream = this.writeStream;
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       stream.write(data, (err2) => {
         if (err2 !== void 0 && err2 !== null) {
           reject(new AuditError("Failed to flush audit log", { cause: err2 }));
         } else {
-          resolve18();
+          resolve19();
         }
       });
     });
   }
   async close() {
     await this.flush();
-    return new Promise((resolve18) => {
+    return new Promise((resolve19) => {
       if (this.writeStream === null) {
-        resolve18();
+        resolve19();
         return;
       }
       this.writeStream.end(() => {
         this.writeStream = null;
         this.logger.info("Audit storage closed");
-        resolve18();
+        resolve19();
       });
     });
   }
@@ -42091,11 +42091,11 @@ function recordTriageLifecycle(findings, verdicts, entries) {
 async function runOsvCheck(targetDir, enabled) {
   if (!enabled) return [];
   try {
-    const fs20 = await import("fs");
-    const path19 = await import("path");
-    const pkgPath = path19.join(targetDir, "package.json");
-    if (!fs20.existsSync(pkgPath)) return [];
-    const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
+    const fs21 = await import("fs");
+    const path20 = await import("path");
+    const pkgPath = path20.join(targetDir, "package.json");
+    if (!fs21.existsSync(pkgPath)) return [];
+    const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
     const deps = Object.entries(pkg.dependencies ?? {}).slice(0, 20).map(([name, version]) => ({
       name,
       version: version.replace(/^[\^~>=<]+/, "")
@@ -43206,11 +43206,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 path19 = await import("path");
+    const path20 = await import("path");
     const summaries = [];
     for (const ref of fileRefs.slice(0, 3)) {
       try {
-        const resolved = path19.resolve(ref);
+        const resolved = path20.resolve(ref);
         const result = await extractSymbols2(resolved);
         const exported = result.symbols.filter((s) => s.exported);
         if (exported.length > 0) {
@@ -43227,12 +43227,12 @@ async function extractSymbolsForTask(task) {
 async function retrieveAdaptiveMemory(task) {
   try {
     const { AdaptiveMemoryBackend } = await import("./adaptive-memory-XD5O3TC4.js");
-    const path19 = await import("path");
+    const path20 = await import("path");
     const { nexusDataPath: nexusDataPath2 } = await import("./nexus-data-dir-M6DYKIHJ.js");
     const baseDir = nexusDataPath2("memory");
     const memory = new AdaptiveMemoryBackend({
-      dbPath: path19.join(baseDir, "adaptive.db"),
-      markdownDir: path19.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);
@@ -43625,10 +43625,566 @@ function registerPrReviewTool(server, deps) {
   logger56.info("Registered pr_review tool");
 }
 
-// src/mcp/tools/query-task-state-tool.ts
+// src/mcp/tools/survey-oss-landscape.ts
 import { z as z91 } from "zod";
-var QueryTaskStateInputSchema = z91.object({
-  taskId: z91.string().min(1).max(128).describe("Task ID whose structured state log should be read")
+var SurveyOssLandscapeInputSchema = z91.object({
+  query: z91.string().min(1).max(200).describe('Free-text search query, e.g. "cargo nextest replacement" or "OSS SBOM tools"'),
+  maxResults: z91.number().int().min(1).max(50).optional().default(10).describe("Maximum candidates to return (1-50; default 10)"),
+  minStars: z91.number().int().min(0).optional().default(0).describe("Minimum star count to include (default 0; useful for filtering noise)"),
+  language: z91.string().max(50).optional().describe('GitHub language filter, e.g. "rust" or "typescript"')
+});
+var GitHubRepoSchema2 = z91.object({
+  full_name: z91.string().optional(),
+  html_url: z91.string().optional(),
+  description: z91.string().nullable().optional(),
+  stargazers_count: z91.number().optional(),
+  pushed_at: z91.string().nullable().optional(),
+  language: z91.string().nullable().optional(),
+  license: z91.object({
+    spdx_id: z91.string().nullable().optional()
+  }).nullable().optional()
+});
+var GitHubSearchResponseSchema2 = z91.object({
+  total_count: z91.number().optional(),
+  items: z91.array(GitHubRepoSchema2).optional()
+});
+var GITHUB_SEARCH_BASE = "https://api.github.com/search/repositories";
+function buildGithubQuery(input) {
+  const parts = [input.query];
+  if (input.language !== void 0 && input.language.length > 0) {
+    parts.push(`language:${input.language}`);
+  }
+  if (input.minStars > 0) {
+    parts.push(`stars:>=${String(input.minStars)}`);
+  }
+  return parts.join(" ");
+}
+function splitFullName(fullName) {
+  if (fullName === void 0) return { owner: "", name: "" };
+  const idx = fullName.indexOf("/");
+  if (idx === -1) return { owner: "", name: fullName };
+  return { owner: fullName.slice(0, idx), name: fullName.slice(idx + 1) };
+}
+function parseCandidates(data) {
+  const items = data.items ?? [];
+  const candidates = items.map((repo) => {
+    const { owner, name } = splitFullName(repo.full_name);
+    return {
+      name,
+      owner,
+      url: repo.html_url ?? "",
+      stars: repo.stargazers_count ?? 0,
+      lastCommitAt: repo.pushed_at ?? null,
+      license: repo.license?.spdx_id ?? null,
+      language: repo.language ?? null,
+      description: repo.description ?? null,
+      source: "github"
+    };
+  });
+  return { totalFound: data.total_count ?? candidates.length, candidates };
+}
+async function fetchGithubCandidates(input, logger56) {
+  const query = encodeURIComponent(buildGithubQuery(input));
+  const perPage = String(input.maxResults);
+  const url = `${GITHUB_SEARCH_BASE}?q=${query}&sort=stars&order=desc&per_page=${perPage}`;
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "nexus-agents"
+  };
+  const tokenResult = await resolveToken({ platform: "github" });
+  if (tokenResult.ok) {
+    headers["Authorization"] = `Bearer ${tokenResult.value.value}`;
+  } else {
+    logger56.debug("No GitHub token; using unauthenticated rate limit (60/hr)");
+  }
+  const fetchResult = await fetchSource({ url, source: "github", headers });
+  if (!fetchResult.ok) return fetchResult;
+  let raw;
+  try {
+    raw = await fetchResult.value.json();
+  } catch (err2) {
+    return {
+      ok: false,
+      error: {
+        code: "PARSE_ERROR",
+        message: "GitHub response is not valid JSON",
+        source: "github",
+        cause: err2
+      }
+    };
+  }
+  const parsed = GitHubSearchResponseSchema2.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: {
+        code: "PARSE_ERROR",
+        message: "GitHub API response did not match the expected schema",
+        source: "github"
+      }
+    };
+  }
+  return { ok: true, value: parseCandidates(parsed.data) };
+}
+async function executeSurvey(input, logger56) {
+  const sourcesQueried = ["github"];
+  const sourcesFailed = [];
+  const githubResult = await fetchGithubCandidates(input, logger56);
+  if (!githubResult.ok) {
+    logger56.warn("GitHub source failed", {
+      code: githubResult.error.code,
+      message: githubResult.error.message
+    });
+    sourcesFailed.push("github");
+    return {
+      query: input.query,
+      totalFound: 0,
+      candidates: [],
+      sourcesQueried,
+      sourcesFailed
+    };
+  }
+  return {
+    query: input.query,
+    totalFound: githubResult.value.totalFound,
+    candidates: githubResult.value.candidates,
+    sourcesQueried,
+    sourcesFailed
+  };
+}
+function createSurveyHandler(deps) {
+  return async (args, ctx) => {
+    const validation = SurveyOssLandscapeInputSchema.safeParse(args);
+    if (!validation.success) {
+      return toolError(`Validation error: ${formatZodError(validation.error)}`);
+    }
+    const logger56 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
+    ctx.logger.debug("Surveying OSS landscape", {
+      query: validation.data.query,
+      maxResults: validation.data.maxResults
+    });
+    return withToolError("Survey failed", logger56, async () => {
+      const result = await executeSurvey(validation.data, logger56);
+      return toolSuccessStructured(result);
+    });
+  };
+}
+var SURVEY_OUTPUT_SCHEMA = {
+  query: z91.string(),
+  totalFound: z91.number(),
+  candidates: z91.array(z91.unknown()),
+  sourcesQueried: z91.array(z91.string()),
+  sourcesFailed: z91.array(z91.string())
+};
+var SURVEY_DESCRIPTION = 'Transient OSS project search. Returns a ranked list of GitHub repositories with license, last-commit, star-count, and one-line description. Does NOT persist to the research registry \u2014 use `research_add_source` for that. Best for one-off engineering decisions like "what tools exist in this space?".';
+function registerSurveyOssLandscapeTool(server, deps) {
+  const logger56 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
+  const secureHandler = createSecureHandler(createSurveyHandler(deps), {
+    toolName: "survey_oss_landscape",
+    rateLimiter: deps.rateLimiter,
+    logger: logger56
+  });
+  const timeoutMs = getToolTimeout("survey_oss_landscape", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("survey_oss_landscape", secureHandler, {
+    timeoutMs,
+    logger: logger56
+  });
+  server.registerTool(
+    "survey_oss_landscape",
+    {
+      description: SURVEY_DESCRIPTION,
+      inputSchema: SurveyOssLandscapeInputSchema.shape,
+      outputSchema: SURVEY_OUTPUT_SCHEMA
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger56.info("Registered survey_oss_landscape tool");
+}
+
+// src/mcp/tools/vendor-publishing-audit.ts
+import { z as z92 } from "zod";
+
+// src/mcp/tools/vendor-publishing-seed.ts
+var VENDOR_PUBLISHING_SEED = {
+  ubuntu: {
+    vendor: "ubuntu",
+    sha256SumsUrlPattern: "https://releases.ubuntu.com/{release}/SHA256SUMS",
+    sha256SumsSignatureUrlPattern: "https://releases.ubuntu.com/{release}/SHA256SUMS.gpg",
+    signaturePattern: "detached",
+    gpgKeys: [
+      {
+        name: "Ubuntu CD Image Automatic Signing Key (2012)",
+        fingerprint: "843938DF228D22F7B3742BC0D94AA3F0EFE21092",
+        role: "release-signing",
+        source: "https://help.ubuntu.com/community/VerifyIsoHowto"
+      },
+      {
+        name: "Ubuntu CD Image Automatic Signing Key (2018)",
+        fingerprint: "F6ECB3762474EDA9D21B7022871920D1991BC93C",
+        role: "release-signing",
+        source: "https://help.ubuntu.com/community/VerifyIsoHowto"
+      }
+    ],
+    releaseCadence: "LTS every 2 years (April even-numbered), interim every 6 months",
+    keyRotationNotes: "2018 key signs current-and-recent releases; 2012 key still valid for older releases. Both keys are published on keyserver.ubuntu.com and ship in /usr/share/keyrings/ubuntu-archive-keyring.gpg on Ubuntu hosts.",
+    vendorDocUrl: "https://help.ubuntu.com/community/VerifyIsoHowto",
+    citedAt: "2026-05-04"
+  },
+  debian: {
+    vendor: "debian",
+    sha256SumsUrlPattern: "https://cdimage.debian.org/debian-cd/current/{arch}/iso-cd/SHA256SUMS",
+    sha256SumsSignatureUrlPattern: "https://cdimage.debian.org/debian-cd/current/{arch}/iso-cd/SHA256SUMS.sign",
+    signaturePattern: "detached",
+    gpgKeys: [
+      {
+        name: "Debian CD signing key (DA87E80D6294BE9B)",
+        fingerprint: "DF9B9C49EAA9298432589D76DA87E80D6294BE9B",
+        role: "release-signing",
+        source: "https://www.debian.org/CD/verify"
+      }
+    ],
+    releaseCadence: "Stable release approximately every 2 years; point releases ~quarterly",
+    keyRotationNotes: "CD signing key rotates per stable release cycle. The vendor doc page lists the current fingerprint; older keys are kept in keyring.debian.org for historical verification.",
+    vendorDocUrl: "https://www.debian.org/CD/verify",
+    citedAt: "2026-05-04"
+  },
+  fedora: {
+    vendor: "fedora",
+    sha256SumsUrlPattern: "https://download.fedoraproject.org/pub/fedora/linux/releases/{release}/{edition}/{arch}/iso/Fedora-{edition}-{release}-{arch}-CHECKSUM",
+    /** Fedora ships clearsigned CHECKSUM files; signature is inline. */
+    signaturePattern: "clearsigned",
+    gpgKeys: [
+      {
+        name: "Fedora project release-signing keys (per-release)",
+        fingerprint: "see-source",
+        role: "release-signing",
+        source: "https://fedoraproject.org/security"
+      }
+    ],
+    releaseCadence: "Major release every ~6 months; supported for ~13 months",
+    keyRotationNotes: "Per-release signing keys. Fingerprints rotate every release and are published on the Fedora security page and in the fedora-gpg-keys package. Use `gpg --keyserver hkp://keys.fedoraproject.org --recv-keys <ID>` to fetch a specific release key.",
+    vendorDocUrl: "https://fedoraproject.org/security",
+    citedAt: "2026-05-04"
+  }
+};
+function isKnownVendor(vendor) {
+  return vendor in VENDOR_PUBLISHING_SEED;
+}
+function listKnownVendors() {
+  return Object.keys(VENDOR_PUBLISHING_SEED).sort();
+}
+
+// src/mcp/tools/vendor-publishing-audit.ts
+var VendorPublishingAuditInputSchema = z92.object({
+  vendor: z92.string().min(1).max(50).toLowerCase().describe('Vendor identifier, lowercase. e.g. "ubuntu", "debian", "fedora"')
+});
+function lookupVendor(vendor) {
+  if (isKnownVendor(vendor)) {
+    return { ...VENDOR_PUBLISHING_SEED[vendor], known: true };
+  }
+  const knownVendors = listKnownVendors();
+  return {
+    vendor,
+    known: false,
+    message: `No seed entry for vendor "${vendor}". Known vendors: ${knownVendors.join(", ")}. Adding a vendor is data-only \u2014 see packages/nexus-agents/src/mcp/tools/vendor-publishing-seed.ts.`,
+    knownVendors
+  };
+}
+function createVendorPublishingAuditHandler(deps) {
+  return async (args, ctx) => {
+    const validation = VendorPublishingAuditInputSchema.safeParse(args);
+    if (!validation.success) {
+      return toolError(`Validation error: ${formatZodError(validation.error)}`);
+    }
+    const logger56 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
+    ctx.logger.debug("Vendor publishing audit", { vendor: validation.data.vendor });
+    return withToolError("Vendor publishing audit failed", logger56, () => {
+      const result = lookupVendor(validation.data.vendor);
+      return Promise.resolve(toolSuccessStructured(result));
+    });
+  };
+}
+var VENDOR_PUBLISHING_OUTPUT_SCHEMA = {
+  vendor: z92.string(),
+  known: z92.boolean(),
+  // Fields below populate when known=true; permissive optional for known=false.
+  sha256SumsUrlPattern: z92.string().optional(),
+  sha256SumsSignatureUrlPattern: z92.string().optional(),
+  signaturePattern: z92.string().optional(),
+  gpgKeys: z92.array(z92.unknown()).optional(),
+  releaseCadence: z92.string().optional(),
+  keyRotationNotes: z92.string().optional(),
+  vendorDocUrl: z92.string().optional(),
+  citedAt: z92.string().optional(),
+  // Fields below populate when known=false.
+  message: z92.string().optional(),
+  knownVendors: z92.array(z92.string()).optional()
+};
+var VENDOR_PUBLISHING_DESCRIPTION = "Look up a vendor's published-artifact signing infrastructure: GPG key fingerprints, SHA256SUMS URL pattern, signature shape (clearsigned / detached / detached-on-iso), release cadence, key rotation notes, and the vendor doc citation. Static lookup against a curated seed dataset; the vendor doc URL is the authoritative source. Returns `{known: false, knownVendors: [...]}` for vendors without a seed entry. v1 covers ubuntu, debian, fedora.";
+function registerVendorPublishingAuditTool(server, deps) {
+  const logger56 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
+  const secureHandler = createSecureHandler(createVendorPublishingAuditHandler(deps), {
+    toolName: "vendor_publishing_audit",
+    rateLimiter: deps.rateLimiter,
+    logger: logger56
+  });
+  const timeoutMs = getToolTimeout("vendor_publishing_audit", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("vendor_publishing_audit", secureHandler, {
+    timeoutMs,
+    logger: logger56
+  });
+  server.registerTool(
+    "vendor_publishing_audit",
+    {
+      description: VENDOR_PUBLISHING_DESCRIPTION,
+      inputSchema: VendorPublishingAuditInputSchema.shape,
+      outputSchema: VENDOR_PUBLISHING_OUTPUT_SCHEMA
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger56.info("Registered vendor_publishing_audit tool");
+}
+
+// src/mcp/tools/compare-data-feeds.ts
+import { z as z93 } from "zod";
+import * as path10 from "path";
+import * as fs11 from "fs";
+import * as yaml3 from "yaml";
+var CompareDataFeedsInputSchema = z93.object({
+  feedAPath: z93.string().min(1).max(1e3).describe("Filesystem path to feed A (YAML or JSON, auto-detected by extension)"),
+  feedBPath: z93.string().min(1).max(1e3).describe("Filesystem path to feed B"),
+  keyPath: z93.string().min(1).max(200).describe(
+    'Dotted path to the entry key, e.g. "id" or "name". Each entry must have this field.'
+  ),
+  compareFields: z93.array(z93.string().min(1).max(200)).max(20).optional().describe(
+    'Optional dotted field paths to compare across matched entries (e.g. ["license", "sha256"])'
+  )
+});
+function readDottedPath(obj, dottedPath) {
+  const parts = dottedPath.split(".");
+  let cursor = obj;
+  for (const part of parts) {
+    if (cursor === null || cursor === void 0) return void 0;
+    if (typeof cursor !== "object") return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function parseFeedContent(content, sourcePath) {
+  const ext = path10.extname(sourcePath).toLowerCase();
+  if (ext === ".json") {
+    return JSON.parse(content);
+  }
+  return yaml3.parse(content);
+}
+function asEntryArray(parsed) {
+  if (Array.isArray(parsed)) return parsed;
+  if (parsed !== null && typeof parsed === "object") {
+    const obj = parsed;
+    const arrayValues = Object.values(obj).filter((v) => Array.isArray(v));
+    if (arrayValues.length === 1) {
+      const first = arrayValues[0];
+      if (first !== void 0) return first;
+    }
+  }
+  throw new Error(
+    "Feed must be a top-level array, or an object with exactly one array-valued field. Top-level objects with multiple array fields are ambiguous; flatten the feed first."
+  );
+}
+function indexByKey(entries, keyPath) {
+  const index = /* @__PURE__ */ new Map();
+  const missingKeyAt = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const key = readDottedPath(entry, keyPath);
+    if (key === void 0 || key === null) {
+      missingKeyAt.push(i);
+      continue;
+    }
+    if (typeof key === "object") {
+      missingKeyAt.push(i);
+      continue;
+    }
+    const keyStr = typeof key === "string" ? key : typeof key === "number" ? String(key) : typeof key === "bigint" ? key.toString() : typeof key === "boolean" ? String(key) : "";
+    if (keyStr === "") {
+      missingKeyAt.push(i);
+      continue;
+    }
+    index.set(keyStr, entry);
+  }
+  return { index, missingKeyAt };
+}
+function membershipDiff(indexA, indexB) {
+  const onlyInA = [];
+  const onlyInB = [];
+  const inBoth = [];
+  for (const key of indexA.keys()) {
+    if (indexB.has(key)) inBoth.push(key);
+    else onlyInA.push(key);
+  }
+  for (const key of indexB.keys()) {
+    if (!indexA.has(key)) onlyInB.push(key);
+  }
+  onlyInA.sort();
+  onlyInB.sort();
+  inBoth.sort();
+  return { onlyInA, onlyInB, inBoth };
+}
+function compareFields(inBothKeys, indexA, indexB, fields) {
+  const out = [];
+  for (const key of inBothKeys) {
+    const a = indexA.get(key);
+    const b = indexB.get(key);
+    for (const field of fields) {
+      const valueA = readDottedPath(a, field);
+      const valueB = readDottedPath(b, field);
+      if (!deepEqual(valueA, valueB)) {
+        out.push({ key, field, valueA, valueB });
+      }
+    }
+  }
+  return out;
+}
+function deepEqualArrays(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((v, i) => deepEqual(v, b[i]));
+}
+function deepEqualObjects(a, b) {
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length) return false;
+  if (!aKeys.every((k, i) => k === bKeys[i])) return false;
+  return aKeys.every((k) => deepEqual(a[k], b[k]));
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) return deepEqualArrays(a, b);
+  return deepEqualObjects(a, b);
+}
+function buildSummary(feedAPath, feedBPath, diff, fieldDiffs, fields) {
+  const lines = [];
+  lines.push(`Feed A: ${feedAPath} (${String(diff.onlyInA.length)} only-in-A)`);
+  lines.push(`Feed B: ${feedBPath} (${String(diff.onlyInB.length)} only-in-B)`);
+  lines.push(`In both: ${String(diff.inBoth.length)} entries`);
+  if (fields.length > 0) {
+    lines.push(
+      `Field comparison across ${String(fields.length)} field(s) found ${String(fieldDiffs.length)} differences in ${String(diff.inBoth.length)} matched entries`
+    );
+  }
+  return lines.join("\n");
+}
+function loadFeed(feedPath) {
+  const resolved = path10.resolve(feedPath);
+  const cwdRoot = path10.resolve(".");
+  if (!resolved.startsWith(cwdRoot)) {
+    throw new Error(`Path traversal denied: ${feedPath} must be within ${cwdRoot}`);
+  }
+  if (!fs11.existsSync(resolved)) {
+    throw new Error(`Feed file not found: ${resolved}`);
+  }
+  const content = fs11.readFileSync(resolved, "utf-8");
+  const parsed = parseFeedContent(content, resolved);
+  return asEntryArray(parsed);
+}
+function executeCompare(input) {
+  const entriesA = loadFeed(input.feedAPath);
+  const entriesB = loadFeed(input.feedBPath);
+  const indexA = indexByKey(entriesA, input.keyPath).index;
+  const indexB = indexByKey(entriesB, input.keyPath).index;
+  const diff = membershipDiff(indexA, indexB);
+  const fields = input.compareFields ?? [];
+  const fieldDiffs = compareFields(diff.inBoth, indexA, indexB, fields);
+  return {
+    feedAPath: input.feedAPath,
+    feedBPath: input.feedBPath,
+    keyPath: input.keyPath,
+    counts: {
+      entriesInA: indexA.size,
+      entriesInB: indexB.size,
+      onlyInA: diff.onlyInA.length,
+      onlyInB: diff.onlyInB.length,
+      inBoth: diff.inBoth.length,
+      fieldDifferences: fieldDiffs.length
+    },
+    coverage: {
+      onlyInA: diff.onlyInA,
+      onlyInB: diff.onlyInB,
+      inBoth: diff.inBoth
+    },
+    fieldDifferences: fieldDiffs,
+    summary: buildSummary(input.feedAPath, input.feedBPath, diff, fieldDiffs, fields)
+  };
+}
+function createCompareDataFeedsHandler(deps) {
+  return async (args, ctx) => {
+    const validation = CompareDataFeedsInputSchema.safeParse(args);
+    if (!validation.success) {
+      return toolError(`Validation error: ${formatZodError(validation.error)}`);
+    }
+    const logger56 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
+    ctx.logger.debug("Comparing data feeds", {
+      feedAPath: validation.data.feedAPath,
+      feedBPath: validation.data.feedBPath
+    });
+    return withToolError("Compare data feeds failed", logger56, () => {
+      const result = executeCompare(validation.data);
+      return Promise.resolve(toolSuccessStructured(result));
+    });
+  };
+}
+var COMPARE_OUTPUT_SCHEMA = {
+  feedAPath: z93.string(),
+  feedBPath: z93.string(),
+  keyPath: z93.string(),
+  counts: z93.object({
+    entriesInA: z93.number(),
+    entriesInB: z93.number(),
+    onlyInA: z93.number(),
+    onlyInB: z93.number(),
+    inBoth: z93.number(),
+    fieldDifferences: z93.number()
+  }),
+  coverage: z93.object({
+    onlyInA: z93.array(z93.string()),
+    onlyInB: z93.array(z93.string()),
+    inBoth: z93.array(z93.string())
+  }),
+  fieldDifferences: z93.array(z93.unknown()),
+  summary: z93.string()
+};
+var COMPARE_DESCRIPTION = "Diff two upstream data feeds (YAML or JSON files) along coverage and per-field axes. Returns which entries exist in A, B, both, plus optional field-level diffs across matched entries. v1 takes file paths only (no URL fetch \u2014 that needs an SSRF design pass). Both feeds must be a top-level array OR a top-level object with exactly one array field.";
+function registerCompareDataFeedsTool(server, deps) {
+  const logger56 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
+  const secureHandler = createSecureHandler(createCompareDataFeedsHandler(deps), {
+    toolName: "compare_data_feeds",
+    rateLimiter: deps.rateLimiter,
+    logger: logger56
+  });
+  const timeoutMs = getToolTimeout("compare_data_feeds", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("compare_data_feeds", secureHandler, {
+    timeoutMs,
+    logger: logger56
+  });
+  server.registerTool(
+    "compare_data_feeds",
+    {
+      description: COMPARE_DESCRIPTION,
+      inputSchema: CompareDataFeedsInputSchema.shape,
+      outputSchema: COMPARE_OUTPUT_SCHEMA
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger56.info("Registered compare_data_feeds tool");
+}
+
+// src/mcp/tools/query-task-state-tool.ts
+import { z as z94 } from "zod";
+var QueryTaskStateInputSchema = z94.object({
+  taskId: z94.string().min(1).max(128).describe("Task ID whose structured state log should be read")
 });
 function queryTaskStateHandler(args, ctx) {
   const parsed = QueryTaskStateInputSchema.safeParse(args);
@@ -43658,7 +44214,7 @@ function queryTaskStateHandler(args, ctx) {
 function registerQueryTaskStateTool(server, deps) {
   const logger56 = deps.logger ?? createLogger({ tool: "query_task_state" });
   const toolSchema = {
-    taskId: z91.string().min(1).max(128).describe("Task ID whose structured state log should be read")
+    taskId: z94.string().min(1).max(128).describe("Task ID whose structured state log should be read")
   };
   const description = "Read the structured state log for a task ID and return the current snapshot. Includes Magentic-One Task Ledger (facts/guesses/openQuestions) and Progress Ledger (per-step reflections with suggestedAction) when orchestrators have written them. Structured state is only written when NEXUS_TASK_STATE_ENABLED=1 was set during the orchestrate invocation.";
   const secureHandler = createSecureHandler(queryTaskStateHandler, {
@@ -43680,23 +44236,23 @@ function registerQueryTaskStateTool(server, deps) {
 }
 
 // src/mcp/tools/verify-audit-chain-tool.ts
-import * as fs11 from "fs/promises";
-import * as path10 from "path";
-import { z as z92 } from "zod";
-var VerifyAuditChainInputSchema = z92.object({
-  logDir: z92.string().min(1).max(512).describe(
+import * as fs12 from "fs/promises";
+import * as path11 from "path";
+import { z as z95 } from "zod";
+var VerifyAuditChainInputSchema = z95.object({
+  logDir: z95.string().min(1).max(512).describe(
     "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files in lexicographic order and verifies the combined chain."
   )
 });
 async function loadAuditEvents(dir, logger56) {
-  const entries = await fs11.readdir(dir);
+  const entries = await fs12.readdir(dir);
   const auditFiles = entries.filter((name) => name.startsWith("audit-") && name.endsWith(".jsonl")).sort();
   const events = [];
   for (const filename of auditFiles) {
-    const fullPath = path10.join(dir, filename);
+    const fullPath = path11.join(dir, filename);
     let content;
     try {
-      content = await fs11.readFile(fullPath, "utf-8");
+      content = await fs12.readFile(fullPath, "utf-8");
     } catch (cause) {
       const msg = cause instanceof Error ? cause.message : String(cause);
       logger56.warn("Skipping unreadable audit log file", { filename, error: msg });
@@ -43728,10 +44284,10 @@ async function handler2(args, ctx) {
   if (!parsed.success) {
     return toolError(`Validation error: ${formatZodError(parsed.error)}`);
   }
-  const resolvedDir = path10.resolve(parsed.data.logDir);
+  const resolvedDir = path11.resolve(parsed.data.logDir);
   let dirStats;
   try {
-    dirStats = await fs11.stat(resolvedDir);
+    dirStats = await fs12.stat(resolvedDir);
   } catch (cause) {
     const msg = cause instanceof Error ? cause.message : String(cause);
     return toolError(`Cannot access logDir "${resolvedDir}": ${msg}`);
@@ -43752,7 +44308,7 @@ async function handler2(args, ctx) {
 function registerVerifyAuditChainTool(server, deps) {
   const logger56 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
-    logDir: z92.string().min(1).max(512).describe(
+    logDir: z95.string().min(1).max(512).describe(
       "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files and verifies the combined hash chain."
     )
   };
@@ -43776,18 +44332,18 @@ function registerVerifyAuditChainTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z93 } from "zod";
-import * as fs12 from "fs";
-import * as path11 from "path";
-var PipelineInputSchema = z93.object({
+import { z as z96 } from "zod";
+import * as fs13 from "fs";
+import * as path12 from "path";
+var PipelineInputSchema = z96.object({
   /** The task to execute. */
-  task: z93.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z96.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
   /** Path to a spec file (.md, .yaml) to use as task input. */
-  specFile: z93.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z96.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
   /** Override template (dev, research, audit, greenfield). Auto-detected if omitted. */
-  template: z93.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z96.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z93.enum([
+  votingStrategy: z96.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -43798,13 +44354,13 @@ var PipelineInputSchema = z93.object({
     "Voting strategy for plan approval. simple_majority (default), supermajority (67%), unanimous, higher_order (Bayesian), proof_of_learning, opinion_wise"
   ),
   /** Use 3 agents instead of 6 for faster voting. */
-  quickMode: z93.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z96.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
   /** Maximum execution time per stage in milliseconds (min 30s, max 600s). */
-  timeoutMs: z93.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z96.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
   /** Stop after planning/voting (no implementation). */
-  dryRun: z93.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z96.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** TESTS ONLY — random output, must not be used for real decisions. (#2319) */
-  simulateVotes: z93.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+  simulateVotes: z96.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput2(result) {
   return {
@@ -43821,13 +44377,13 @@ function buildOutput2(result) {
 }
 async function resolveTask(task, specFile) {
   if (specFile === void 0) return task;
-  const resolved = path11.resolve(specFile);
-  const cwdRoot = path11.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}`);
   }
   try {
-    const specContent = await fs12.promises.readFile(resolved, "utf-8");
+    const specContent = await fs13.promises.readFile(resolved, "utf-8");
     return `${specContent}
 
 ---
@@ -43889,7 +44445,7 @@ function registerPipelineTool(server, _deps) {
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z94 } from "zod";
+import { z as z97 } from "zod";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -43899,16 +44455,16 @@ 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(
+var SupplyChainTradeoffPanelInputSchema = z97.object({
+  proposal: z97.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z97.array(z97.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(
+  context: z97.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)")
+  quickMode: z97.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z97.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
 
 // src/mcp/tools/tool-annotations.ts
@@ -44050,6 +44606,40 @@ var TOOL_ANNOTATIONS = {
       { category: "coupling", description: "Auto-catalogs discovered references" }
     ]
   },
+  survey_oss_landscape: {
+    annotations: {
+      title: "Survey OSS Landscape",
+      readOnlyHint: true,
+      destructiveHint: false,
+      // Same query may return different results day-to-day as star counts
+      // and last-commit dates evolve; idempotentHint=false matches reality.
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    sideEffects: [{ category: "implicit", description: "Queries the GitHub search API" }]
+  },
+  vendor_publishing_audit: {
+    annotations: {
+      title: "Vendor Publishing Audit",
+      readOnlyHint: true,
+      destructiveHint: false,
+      // Pure static lookup against the in-process seed dataset.
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [{ category: "implicit", description: "Consumes rate limit quota" }]
+  },
+  compare_data_feeds: {
+    annotations: {
+      title: "Compare Data Feeds",
+      readOnlyHint: true,
+      destructiveHint: false,
+      // Same input → same output; pure file diff with no external calls.
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [{ category: "implicit", description: "Reads two files from the workspace" }]
+  },
   research_analyze: {
     annotations: {
       title: "Research Analyze",
@@ -44290,48 +44880,52 @@ function wrapWithObservability(toolName, cb, eventBus) {
 }
 
 // src/mcp/tools/index.ts
+var REGISTERED_TOOL_NAMES = [
+  "orchestrate",
+  "create_expert",
+  "execute_expert",
+  "run_workflow",
+  "delegate_to_model",
+  "list_experts",
+  "list_workflows",
+  "consensus_vote",
+  "research_query",
+  "research_add",
+  "research_add_source",
+  "research_discover",
+  "research_analyze",
+  "research_catalog_review",
+  "research_synthesize",
+  "survey_oss_landscape",
+  "vendor_publishing_audit",
+  "compare_data_feeds",
+  "memory_query",
+  "memory_stats",
+  "memory_write",
+  "weather_report",
+  "issue_triage",
+  "run_graph_workflow",
+  "execute_spec",
+  "registry_import",
+  "query_trace",
+  "query_task_state",
+  "verify_audit_chain",
+  "repo_analyze",
+  "repo_security_plan",
+  "extract_symbols",
+  "search_codebase",
+  "run_dev_pipeline",
+  "run_pipeline",
+  "pr_review",
+  "supply_chain_tradeoff_panel"
+];
 function registerTools(server, options) {
   const logger56 = options?.logger ?? createMcpLogger({ component: "tools" });
   const rateLimiter = options?.rateLimiter ?? createDefaultRateLimiter("mcp-tools", logger56);
   logger56.info("Tool registration infrastructure initialized");
   void server;
   return {
-    tools: [
-      "orchestrate",
-      "create_expert",
-      "execute_expert",
-      "run_workflow",
-      "delegate_to_model",
-      "list_experts",
-      "list_workflows",
-      "consensus_vote",
-      "research_query",
-      "research_add",
-      "research_add_source",
-      "research_discover",
-      "research_analyze",
-      "research_catalog_review",
-      "research_synthesize",
-      "memory_query",
-      "memory_stats",
-      "memory_write",
-      "weather_report",
-      "issue_triage",
-      "run_graph_workflow",
-      "execute_spec",
-      "registry_import",
-      "query_trace",
-      "query_task_state",
-      "verify_audit_chain",
-      "repo_analyze",
-      "repo_security_plan",
-      "extract_symbols",
-      "search_codebase",
-      "run_dev_pipeline",
-      "run_pipeline",
-      "pr_review",
-      "supply_chain_tradeoff_panel"
-    ],
+    tools: [...REGISTERED_TOOL_NAMES],
     logger: logger56,
     rateLimiter
   };
@@ -44458,40 +45052,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-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()
+import { z as z98 } from "zod";
+var HazardCategorySchema = z98.enum(HazardCategory);
+var HazardSeveritySchema = z98.enum(HazardSeverity);
+var ConstraintPrioritySchema = z98.enum(ConstraintPriority);
+var RiskLevelSchema = z98.enum(RiskLevel);
+var TriggerPatternSchema = z98.object({
+  parameter: z98.string().min(1),
+  matchType: z98.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z98.string(),
+  reason: z98.string()
 });
-var HazardSchema = z95.object({
-  id: z95.string().min(1),
-  description: z95.string(),
+var HazardSchema = z98.object({
+  id: z98.string().min(1),
+  description: z98.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z95.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z95.array(z95.string()),
-  consequences: z95.array(z95.string())
+  likelihood: z98.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z98.array(z98.string()),
+  consequences: z98.array(z98.string())
 });
-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 UnsafeControlActionSchema = z98.object({
+  id: z98.string().min(1),
+  toolName: z98.string().min(1),
+  type: z98.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z98.string(),
+  unsafeContext: z98.string(),
+  relatedHazards: z98.array(z98.string()),
+  triggerPatterns: z98.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z95.object({
-  id: z95.string().min(1),
-  description: z95.string(),
-  mitigates: z95.array(z95.string()),
-  enforcement: z95.enum([
+var SafetyConstraintSchema = z98.object({
+  id: z98.string().min(1),
+  description: z98.string(),
+  mitigates: z98.array(z98.string()),
+  enforcement: z98.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -44499,54 +45093,54 @@ var SafetyConstraintSchema = z95.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z95.string().optional(),
+  validationFunction: z98.string().optional(),
   priority: ConstraintPrioritySchema
 });
-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 PropertySchemaSchema = z98.object({
+  type: z98.string(),
+  description: z98.string().optional(),
+  enum: z98.array(z98.unknown()).optional(),
+  pattern: z98.string().optional(),
+  minimum: z98.number().optional(),
+  maximum: z98.number().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 ToolInputSchemaSchema = z98.object({
+  type: z98.string(),
+  properties: z98.record(z98.string(), PropertySchemaSchema).optional(),
+  required: z98.array(z98.string()).optional(),
+  additionalProperties: z98.boolean().optional()
 });
-var ToolDefinitionSchema = z95.object({
-  name: z95.string().min(1),
-  description: z95.string(),
+var ToolDefinitionSchema = z98.object({
+  name: z98.string().min(1),
+  description: z98.string(),
   inputSchema: ToolInputSchemaSchema
 });
-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 AnalysisConfigurationSchema = z98.object({
+  includeLowSeverity: z98.boolean().default(true),
+  generateAllConstraints: z98.boolean().default(true),
+  checkInteractions: z98.boolean().default(true),
+  maxHazardsPerTool: z98.number().int().min(1).max(100).default(50),
+  categories: z98.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z95.object({
-  constraintId: z95.string().min(1),
-  constraintDescription: z95.string(),
+var ConstraintViolationSchema = z98.object({
+  constraintId: z98.string().min(1),
+  constraintDescription: z98.string(),
   severity: HazardSeveritySchema,
-  details: z95.string(),
-  remediation: z95.string()
+  details: z98.string(),
+  remediation: z98.string()
 });
-var ValidationWarningSchema = z95.object({
-  code: z95.string().min(1),
-  message: z95.string(),
-  affected: z95.string()
+var ValidationWarningSchema = z98.object({
+  code: z98.string().min(1),
+  message: z98.string(),
+  affected: z98.string()
 });
-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()
+var ValidationResultSchema = z98.object({
+  valid: z98.boolean(),
+  toolName: z98.string().min(1),
+  violations: z98.array(ConstraintViolationSchema),
+  passed: z98.array(z98.string()),
+  warnings: z98.array(ValidationWarningSchema),
+  validatedAt: z98.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -45631,22 +46225,22 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/task-analyzer.ts
-import { z as z96 } from "zod";
-var TaskProfileSchema = z96.object({
+import { z as z99 } from "zod";
+var TaskProfileSchema = z99.object({
   /** Estimated input tokens required */
-  contextRequired: z96.number().min(0),
+  contextRequired: z99.number().min(0),
   /** Reasoning complexity on 0-10 scale */
-  reasoningComplexity: z96.number().min(0).max(10),
+  reasoningComplexity: z99.number().min(0).max(10),
   /** Whether task involves code generation */
-  codeGeneration: z96.boolean(),
+  codeGeneration: z99.boolean(),
   /** Whether task involves multimodal content (images, etc.) */
-  multimodal: z96.boolean(),
+  multimodal: z99.boolean(),
   /** Whether task can be split into parallel subtasks */
-  parallelizable: z96.boolean(),
+  parallelizable: z99.boolean(),
   /** Whether cost should be minimized */
-  budgetSensitive: z96.boolean(),
+  budgetSensitive: z99.boolean(),
   /** Primary task type classification */
-  taskType: z96.enum([
+  taskType: z99.enum([
     "architecture",
     "code_implementation",
     "code_review",
@@ -45660,53 +46254,53 @@ var TaskProfileSchema = z96.object({
 });
 
 // src/cli-adapters/router-types.ts
-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)
+import { z as z100 } from "zod";
+var RouterConfigSchema = z100.object({
+  minCapacityThreshold: z100.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z100.boolean().default(false),
+  maxDecisionTimeMs: z100.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-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)
+import { z as z101 } from "zod";
+var AgreementCascadeConfigSchema = z101.object({
+  agreementThreshold: z101.number().min(0.5).max(1).default(0.7),
+  maxStages: z101.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z101.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 z99 } from "zod";
-var EncodedFeaturesSchema = z99.object({
+import { z as z102 } from "zod";
+var EncodedFeaturesSchema = z102.object({
   /** Lexical complexity score (vocabulary diversity, rare words) */
-  lexicalComplexity: z99.number().min(0).max(1),
+  lexicalComplexity: z102.number().min(0).max(1),
   /** Syntactic complexity score (sentence structure, nesting) */
-  syntacticComplexity: z99.number().min(0).max(1),
+  syntacticComplexity: z102.number().min(0).max(1),
   /** Semantic density score (concept density, abstraction level) */
-  semanticDensity: z99.number().min(0).max(1),
+  semanticDensity: z102.number().min(0).max(1),
   /** Technical specificity (domain-specific terminology) */
-  technicalSpecificity: z99.number().min(0).max(1),
+  technicalSpecificity: z102.number().min(0).max(1),
   /** Task scope (breadth of requirements) */
-  taskScope: z99.number().min(0).max(1),
+  taskScope: z102.number().min(0).max(1),
   /** Constraint complexity (constraints, edge cases, requirements) */
-  constraintComplexity: z99.number().min(0).max(1),
+  constraintComplexity: z102.number().min(0).max(1),
   /** Ambiguity level (inverse - higher means more clear/specific) */
-  clarity: z99.number().min(0).max(1),
+  clarity: z102.number().min(0).max(1),
   /** Output complexity expectation */
-  outputComplexity: z99.number().min(0).max(1)
+  outputComplexity: z102.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 FeatureWeightsSchema = z102.object({
+  lexicalComplexity: z102.number().min(0).max(1),
+  syntacticComplexity: z102.number().min(0).max(1),
+  semanticDensity: z102.number().min(0).max(1),
+  technicalSpecificity: z102.number().min(0).max(1),
+  taskScope: z102.number().min(0).max(1),
+  constraintComplexity: z102.number().min(0).max(1),
+  clarity: z102.number().min(0).max(1),
+  outputComplexity: z102.number().min(0).max(1)
 });
 var DEFAULT_FEATURE_WEIGHTS = {
   lexicalComplexity: 0.1,
@@ -45728,50 +46322,50 @@ var DEFAULT_DAAO_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DAAOConfigSchema = z99.object({
+var DAAOConfigSchema = z102.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z99.object({
-    easyUpperBound: z99.number().min(0).max(1),
-    hardLowerBound: z99.number().min(0).max(1)
+  thresholds: z102.object({
+    easyUpperBound: z102.number().min(0).max(1),
+    hardLowerBound: z102.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: z99.record(
-    z99.enum(["fast", "balanced", "powerful"]),
-    z99.array(z99.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z102.record(
+    z102.enum(["fast", "balanced", "powerful"]),
+    z102.array(z102.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_DAAO_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z99.boolean().default(true),
+  enableCalibration: z102.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z99.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z102.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z99.number().int().positive().default(50),
+  minCalibrationOutcomes: z102.number().int().positive().default(50),
   /** Reconstruction error threshold for typical patterns */
-  typicalPatternThreshold: z99.number().min(0).max(1).default(0.3),
+  typicalPatternThreshold: z102.number().min(0).max(1).default(0.3),
   /** Verbose logging */
-  verbose: z99.boolean().default(false)
+  verbose: z102.boolean().default(false)
 });
 
 // src/cli-adapters/task-classifier.ts
-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()
+import { z as z103 } from "zod";
+var ClassificationPatternsSchema = z103.object({
+  code: z103.array(z103.string()).readonly(),
+  research: z103.array(z103.string()).readonly(),
+  documentation: z103.array(z103.string()).readonly(),
+  analysis: z103.array(z103.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z101 } from "zod";
-var ResponseCacheConfigSchema = z101.object({
-  defaultTTL: z101.number().min(1e3).max(36e5).default(3e5),
+import { z as z104 } from "zod";
+var ResponseCacheConfigSchema = z104.object({
+  defaultTTL: z104.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  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),
+  maxEntries: z104.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z104.number().min(1).max(1e3).default(50),
+  cleanupInterval: z104.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z101.boolean().default(false)
+  enableLogging: z104.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -45779,12 +46373,12 @@ import { createHash as createHash4 } from "crypto";
 var logger43 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-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([
+import { z as z105 } from "zod";
+var UnifiedRoutingDecisionSchema = z105.object({
+  selectedCli: z105.string(),
+  confidence: z105.number().min(0).max(1),
+  reason: z105.string(),
+  strategy: z105.enum([
     "composite",
     "quality",
     "budget",
@@ -45796,57 +46390,57 @@ var UnifiedRoutingDecisionSchema = z102.object({
     "linucb",
     "direct"
   ]),
-  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()
+  decisionTimeMs: z105.number().nonnegative(),
+  alternatives: z105.array(z105.string()).readonly(),
+  stagesExecuted: z105.array(z105.string()).readonly(),
+  withinBudget: z105.boolean().optional(),
+  estimatedComplexity: z105.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z105.number().int().positive().optional(),
+  topsisScore: z105.number().optional(),
+  ucbScore: z105.number().optional(),
+  resolvedAtStage: z105.number().int().nonnegative().optional(),
+  consensusReached: z105.boolean().optional(),
+  agreementScore: z105.number().min(0).max(1).optional(),
+  metadata: z105.record(z105.string(), z105.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-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()
+import { z as z106 } from "zod";
+var QualitySignalsSchema = z106.object({
+  testsPass: z106.boolean().optional(),
+  lintErrors: z106.number().int().min(0).optional(),
+  userApproved: z106.boolean().optional(),
+  retryCount: z106.number().int().min(0).default(0),
+  completionRatio: z106.number().min(0).max(1).default(1),
+  validStructure: z106.boolean().optional(),
+  coherenceScore: z106.number().min(0).max(1).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 RoutingDecisionSchema = z106.object({
+  id: z106.uuid(),
+  timestamp: z106.iso.datetime(),
+  query: z106.string(),
+  routerType: z106.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z106.string(),
+  selectedTier: z106.enum(["strong", "weak"]).optional(),
+  armIndex: z106.number().int().min(0).optional(),
+  banditContext: z106.record(z106.string(), z106.unknown()).optional(),
+  queryFeatures: z106.record(z106.string(), z106.unknown()).optional(),
+  ucbScore: z106.number().optional(),
+  confidence: z106.number().min(0).max(1).optional(),
+  traceId: z106.string(),
+  domain: z106.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(),
+var TaskOutcomeSchema = z106.object({
+  routingDecisionId: z106.uuid(),
+  timestamp: z106.iso.datetime(),
+  outcomeClass: z106.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z106.boolean(),
+  qualityScore: z106.number().min(0).max(1),
+  durationMs: z106.number().min(0),
+  tokenUsage: z106.number().int().min(0),
+  errorMessage: z106.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z103.string()
+  traceId: z106.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -45861,17 +46455,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 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)
+var FeedbackCollectorConfigSchema = z106.object({
+  maxPendingDecisions: z106.number().int().positive().default(1e3),
+  pendingTimeoutMs: z106.number().positive().default(3e5),
+  enableAutoReward: z106.boolean().default(true),
+  qualityWeight: z106.number().min(0).max(1).default(0.5),
+  speedWeight: z106.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z106.number().min(0).max(1).default(0.2),
+  retryPenalty: z106.number().min(0).max(1).default(0.1),
+  targetDurationMs: z106.number().positive().default(5e3),
+  targetTokenUsage: z106.number().positive().default(2e3),
+  maxHistorySize: z106.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -46935,7 +47529,7 @@ function getPolicy(id) {
 // src/security/sandbox/sandbox-executor.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { resolve as resolve16, normalize as normalize2, sep as sep6 } from "path";
+import { resolve as resolve17, normalize as normalize2, sep as sep6 } from "path";
 var execFileAsync2 = promisify2(execFile2);
 var logger45 = createLogger({ component: "sandbox-executor" });
 function parseExecError(error) {
@@ -47015,9 +47609,9 @@ var PolicySandboxExecutor = class {
    */
   validateCwd(cwd, policy) {
     if (cwd === void 0) return null;
-    const normalizedCwd = normalize2(resolve16(cwd));
+    const normalizedCwd = normalize2(resolve17(cwd));
     const isAllowed = policy.pathRules.some((rule) => {
-      const normalizedRule = normalize2(resolve16(rule.path));
+      const normalizedRule = normalize2(resolve17(rule.path));
       const isUnderRule = normalizedCwd === normalizedRule || normalizedCwd.startsWith(normalizedRule + sep6);
       return isUnderRule && rule.access !== "none";
     });
@@ -47884,10 +48478,10 @@ var PredictionWriter = class {
    * Opens the output file for writing.
    */
   async open() {
-    const fs20 = await import("fs/promises");
+    const fs21 = await import("fs/promises");
     try {
       const flags = this.options.append ? "a" : "w";
-      this.fileHandle = await fs20.open(this.options.outputPath, flags);
+      this.fileHandle = await fs21.open(this.options.outputPath, flags);
       return { ok: true, value: void 0 };
     } catch (err2) {
       return {
@@ -47961,11 +48555,11 @@ var PredictionWriter = class {
   }
 };
 async function writePredictions(predictions, outputPath, options = {}) {
-  const fs20 = await import("fs/promises");
+  const fs21 = await import("fs/promises");
   try {
     const lines = predictions.map(formatPrediction).join("\n") + "\n";
     const flags = options.append === true ? "a" : "w";
-    await fs20.writeFile(outputPath, lines, { flag: flags });
+    await fs21.writeFile(outputPath, lines, { flag: flags });
     return { ok: true, value: predictions.length };
   } catch (err2) {
     return {
@@ -47990,9 +48584,9 @@ function parsePredictionLine(line) {
   }
 }
 async function readPredictions(inputPath) {
-  const fs20 = await import("fs/promises");
+  const fs21 = await import("fs/promises");
   try {
-    const content = await fs20.readFile(inputPath, "utf-8");
+    const content = await fs21.readFile(inputPath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     const predictions = [];
     for (const line of lines) {
@@ -48265,13 +48859,13 @@ function createEmptyContext() {
     approachHistory: []
   };
 }
-function assignRelevance(path19, response) {
+function assignRelevance(path20, response) {
   const lowerResponse = response.toLowerCase();
-  const lowerPath = path19.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 + path19.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";
@@ -48414,10 +49008,10 @@ var GIT_TIMEOUT_MS = 3e5;
 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 path19 = await import("path");
+  const fs21 = await import("fs/promises");
+  const path20 = await import("path");
   try {
-    await fs20.access(path19.join(repoDir, ".git"));
+    await fs21.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 {
@@ -48436,8 +49030,8 @@ async function tryExistingClone(repoDir, commit, exec5) {
   }
 }
 async function cloneRepository(repo, commit, workDir) {
-  const path19 = await import("path");
-  const fs20 = await import("fs/promises");
+  const path20 = await import("path");
+  const fs21 = await import("fs/promises");
   const childProcess = await import("child_process");
   const { promisify: promisify9 } = await import("util");
   const exec5 = promisify9(childProcess.exec);
@@ -48447,9 +49041,9 @@ async function cloneRepository(repo, commit, workDir) {
   if (!SAFE_COMMIT_RE.test(commit)) {
     return { ok: false, error: new AgentRunnerError(`Invalid commit hash: ${commit}`) };
   }
-  const repoDir = path19.join(workDir, repo.replaceAll("/", "__"));
+  const repoDir = path20.join(workDir, repo.replaceAll("/", "__"));
   try {
-    await fs20.mkdir(workDir, { recursive: true });
+    await fs21.mkdir(workDir, { recursive: true });
     const cloned = await tryExistingClone(repoDir, commit, exec5);
     if (cloned) return { ok: true, value: repoDir };
     await exec5(`git clone --filter=blob:none --no-tags https://github.com/${repo}.git ${repoDir}`, {
@@ -48465,19 +49059,19 @@ async function applyPatch(repoDir, patch) {
   const childProcess = await import("child_process");
   const { promisify: promisify9 } = await import("util");
   const exec5 = promisify9(childProcess.exec);
-  const fs20 = await import("fs/promises");
-  const path19 = await import("path");
-  const patchFile = path19.join(repoDir, ".agent_patch.diff");
+  const fs21 = await import("fs/promises");
+  const path20 = await import("path");
+  const patchFile = path20.join(repoDir, ".agent_patch.diff");
   try {
-    await fs20.writeFile(patchFile, patch);
+    await fs21.writeFile(patchFile, patch);
     await exec5(`git apply --whitespace=fix ${patchFile}`, {
       cwd: repoDir,
       timeout: GIT_TIMEOUT_MS
     });
-    await fs20.unlink(patchFile);
+    await fs21.unlink(patchFile);
     return { ok: true, value: void 0 };
   } catch (err2) {
-    await fs20.unlink(patchFile).catch((e) => {
+    await fs21.unlink(patchFile).catch((e) => {
       logger50.debug("Failed to clean up patch file", {
         error: e instanceof Error ? e.message : String(e)
       });
@@ -49501,7 +50095,7 @@ async function getDockerVersion(logger56) {
 }
 
 // src/swe-bench/harness-output-parsing.ts
-import * as fs13 from "fs/promises";
+import * as fs14 from "fs/promises";
 function parseHarnessOutput(output2, logger56) {
   try {
     const parsed = JSON.parse(output2);
@@ -49522,7 +50116,7 @@ function isValidHarnessOutput(obj) {
 }
 async function parseHarnessLogFile(logPath, logger56) {
   try {
-    const content = await fs13.readFile(logPath, "utf-8");
+    const content = await fs14.readFile(logPath, "utf-8");
     return parseHarnessOutput(content, logger56);
   } catch (err2) {
     logger56?.warn("Failed to read harness log file", { logPath, error: String(err2) });
@@ -49604,8 +50198,8 @@ function transformHarnessOutput(raw) {
 
 // src/swe-bench/harness-file-operations.ts
 import { spawn } from "child_process";
-import * as fs14 from "fs/promises";
-import * as path12 from "path";
+import * as fs15 from "fs/promises";
+import * as path13 from "path";
 var capitalizeFirst = capitalize;
 function buildHarnessArgs(config) {
   const args = [
@@ -49647,11 +50241,11 @@ function countValidPredictions(content) {
 }
 async function validatePredictionsFile(predictionsPath, logger56) {
   try {
-    const stat6 = await fs14.stat(predictionsPath);
+    const stat6 = await fs15.stat(predictionsPath);
     if (!stat6.isFile()) {
       return { valid: false, lineCount: 0, error: "Path is not a file" };
     }
-    const content = await fs14.readFile(predictionsPath, "utf-8");
+    const content = await fs15.readFile(predictionsPath, "utf-8");
     const validCount = countValidPredictions(content);
     if (validCount === 0) {
       return { valid: false, lineCount: 0, error: "No valid predictions found" };
@@ -49665,7 +50259,7 @@ async function validatePredictionsFile(predictionsPath, logger56) {
 }
 async function ensureOutputDir(outputDir, logger56) {
   try {
-    await fs14.mkdir(outputDir, { recursive: true });
+    await fs15.mkdir(outputDir, { recursive: true });
     logger56?.debug("Output directory ensured", { path: outputDir });
   } catch (err2) {
     logger56?.warn("Failed to create output directory", { path: outputDir, error: String(err2) });
@@ -49702,7 +50296,7 @@ function createInitialProgress(totalCount) {
   };
 }
 function getResultsFilePath(config) {
-  return path12.join(config.outputDir, config.runId, "results.json");
+  return path13.join(config.outputDir, config.runId, "results.json");
 }
 
 // src/swe-bench/harness-process-runner.ts
@@ -49752,13 +50346,13 @@ function handleStdoutChunk(chunk, currentProgress, startTime, onProgress) {
   }
 }
 function handleProcessClose(options) {
-  const { code, config, stderr, context, resolve: resolve18, reject } = options;
+  const { code, config, stderr, context, resolve: resolve19, reject } = options;
   if (context.isCancelled) {
     reject(new HarnessExecutorError("Execution cancelled", "CANCELLED"));
     return;
   }
   handleProcessExitAsync(code, config, stderr, context.logger).then((result) => {
-    resolve18(result);
+    resolve19(result);
   }).catch((err2) => {
     if (err2 instanceof HarnessExecutorError) {
       reject(err2);
@@ -49799,7 +50393,7 @@ async function parseResultsFile(config, logger56) {
   };
 }
 function runHarnessProcess(config, totalInstances, context, onProgress) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     const startTime = performance.now();
     let progress = createInitialProgress(totalInstances);
     progress = { ...progress, state: "starting" };
@@ -49821,7 +50415,7 @@ function runHarnessProcess(config, totalInstances, context, onProgress) {
         config,
         stderr: stderrCollector.value,
         context,
-        resolve: resolve18,
+        resolve: resolve19,
         reject
       });
     });
@@ -49975,7 +50569,7 @@ var HarnessExecutor = class {
     const proc = this.currentProcess;
     if (proc !== null) {
       proc.kill("SIGTERM");
-      await new Promise((resolve18) => setTimeout(resolve18, 1e3));
+      await new Promise((resolve19) => setTimeout(resolve19, 1e3));
       if (!proc.killed) {
         proc.kill("SIGKILL");
       }
@@ -51097,8 +51691,8 @@ var SWEBenchRunner = class {
       return { ok: true, value: null };
     }
     try {
-      const fs20 = await import("fs/promises");
-      const content = await fs20.readFile(this.config.checkpointPath, "utf-8");
+      const fs21 = await import("fs/promises");
+      const content = await fs21.readFile(this.config.checkpointPath, "utf-8");
       const checkpoint = JSON.parse(content);
       this.config.onMessage?.(
         `Resuming from checkpoint: ${String(checkpoint.completed_instances.length)} completed`
@@ -51127,8 +51721,8 @@ var SWEBenchRunner = class {
       last_updated: getTimeProvider().nowIso()
     };
     try {
-      const fs20 = await import("fs/promises");
-      await fs20.writeFile(this.config.checkpointPath, JSON.stringify(checkpoint, null, 2));
+      const fs21 = await import("fs/promises");
+      await fs21.writeFile(this.config.checkpointPath, JSON.stringify(checkpoint, null, 2));
       return { ok: true, value: void 0 };
     } catch (err2) {
       return {
@@ -51439,18 +52033,18 @@ function parsePatch(patch) {
 // src/swe-bench/patch-applicator-executor.ts
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify7 } from "util";
-import * as fs15 from "fs/promises";
-import * as path13 from "path";
+import * as fs16 from "fs/promises";
+import * as path14 from "path";
 var execFileAsync5 = promisify7(execFile5);
 var MAX_OUTPUT_BUFFER = 5 * 1024 * 1024;
 async function writeTempPatch(patch, workDir) {
-  const tempPath = path13.join(workDir, `.patch-${String(getTimeProvider().now())}.patch`);
-  await fs15.writeFile(tempPath, patch, "utf-8");
+  const tempPath = path14.join(workDir, `.patch-${String(getTimeProvider().now())}.patch`);
+  await fs16.writeFile(tempPath, patch, "utf-8");
   return tempPath;
 }
 async function cleanupTempFile(patchPath) {
   try {
-    await fs15.unlink(patchPath);
+    await fs16.unlink(patchPath);
   } catch (cleanupErr) {
     void cleanupErr;
   }
@@ -51694,12 +52288,12 @@ var TestRunnerError = class extends Error {
 };
 
 // src/swe-bench/test-runner-parser.ts
-import * as fs16 from "fs/promises";
-import * as path14 from "path";
+import * as fs17 from "fs/promises";
+import * as path15 from "path";
 async function readJsonResults(workDir) {
-  const jsonPath = path14.join(workDir, "test-results.json");
+  const jsonPath = path15.join(workDir, "test-results.json");
   try {
-    const content = await fs16.readFile(jsonPath, "utf-8");
+    const content = await fs17.readFile(jsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -51860,7 +52454,7 @@ function executeInDocker(options) {
   const image = config.dockerImage ?? "python:3.11-slim";
   logger56.debug("Executing tests in Docker", { image, command });
   const dockerArgs = buildDockerArgs(command, config, image);
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const proc = spawn2("docker", dockerArgs, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -51873,17 +52467,17 @@ function executeInDocker(options) {
       clearTimeout(timeoutId);
       state.currentProcess = null;
       if (state.isCancelled) {
-        resolve18(createCancelledResult2(startTime));
+        resolve19(createCancelledResult2(startTime));
         return;
       }
       const output2 = `${getStdout()}
 ${getStderr()}`.trim();
-      void parseTestResults(output2, startTime, config.workDir).then(resolve18);
+      void parseTestResults(output2, startTime, config.workDir).then(resolve19);
     });
     proc.on("error", (err2) => {
       clearTimeout(timeoutId);
       state.currentProcess = null;
-      resolve18(handleTestError(err2, startTime));
+      resolve19(handleTestError(err2, startTime));
     });
   });
 }
@@ -51891,8 +52485,8 @@ ${getStderr()}`.trim();
 // src/swe-bench/test-runner.ts
 import { exec as exec3 } from "child_process";
 import { promisify as promisify8 } from "util";
-import * as fs17 from "fs/promises";
-import * as path15 from "path";
+import * as fs18 from "fs/promises";
+import * as path16 from "path";
 var execAsync3 = promisify8(exec3);
 var FRAMEWORK_CONFIG_FILES = {
   pytest: ["pytest.ini", "pyproject.toml", "setup.cfg", "conftest.py", "tox.ini"],
@@ -51998,9 +52592,9 @@ var TestRunner = class {
   async findConfigFiles(workDir, configFiles) {
     const found = [];
     for (const file of configFiles) {
-      const filePath = path15.join(workDir, file);
+      const filePath = path16.join(workDir, file);
       try {
-        await fs17.access(filePath);
+        await fs18.access(filePath);
         found.push(file);
       } catch (accessErr) {
         void accessErr;
@@ -52150,8 +52744,8 @@ async function detectTestFramework(workDir) {
 }
 
 // src/swe-bench/report-generator.ts
-import * as fs18 from "fs/promises";
-import * as path16 from "path";
+import * as fs19 from "fs/promises";
+import * as path17 from "path";
 
 // src/swe-bench/report-renderer.ts
 function renderReport(report, format) {
@@ -52507,8 +53101,8 @@ 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(path16.dirname(config.outputPath), { recursive: true });
-    await fs18.writeFile(config.outputPath, content, "utf-8");
+    await fs19.mkdir(path17.dirname(config.outputPath), { recursive: true });
+    await fs19.writeFile(config.outputPath, content, "utf-8");
     this.logger.info("Report saved", { path: config.outputPath, format: config.format });
   }
   /**
@@ -52727,14 +53321,14 @@ async function exportReport(result, outputPath, config) {
 
 // src/swe-bench/trace-logger.ts
 import { appendFile, writeFile as writeFile6 } from "fs/promises";
-import * as path17 from "path";
+import * as path18 from "path";
 function deriveTracePath(outputPath) {
-  const ext = path17.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 = path17.extname(outputPath);
+  const ext = path18.extname(outputPath);
   const base = outputPath.slice(0, outputPath.length - ext.length);
   return `${base}-status.json`;
 }
@@ -52939,8 +53533,8 @@ function getStdinLifecycleMonitor() {
 }
 
 // src/pipeline/task-tracker.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+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");
@@ -53018,8 +53612,8 @@ var JsonTaskTracker = class {
   outputPath;
   constructor(config) {
     const dir = config.outputDir ?? ".nexus-pipeline";
-    this.outputPath = path18.resolve(dir, "tasks.json");
-    fs19.mkdirSync(path18.dirname(this.outputPath), { recursive: true });
+    this.outputPath = path19.resolve(dir, "tasks.json");
+    fs20.mkdirSync(path19.dirname(this.outputPath), { recursive: true });
   }
   async createTask(title, body) {
     const id = String(this.nextId++);
@@ -53051,7 +53645,7 @@ var JsonTaskTracker = class {
       comments: Object.fromEntries(this.comments),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs19.writeFileSync(this.outputPath, JSON.stringify(data, null, 2));
+    fs20.writeFileSync(this.outputPath, JSON.stringify(data, null, 2));
   }
 };
 async function detectBackend() {
@@ -53525,6 +54119,9 @@ export {
   registerResearchAddTool,
   ResearchAddSourceInputSchema,
   registerResearchAddSourceTool,
+  registerSurveyOssLandscapeTool,
+  registerVendorPublishingAuditTool,
+  registerCompareDataFeedsTool,
   ResearchDiscoverInputSchema,
   registerResearchDiscoverTool,
   ResearchAnalyzeInputSchema,
@@ -53779,4 +54376,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-CUGQAPGY.js.map
+//# sourceMappingURL=chunk-RLLMWZAE.js.map