nexus-agents 2.26.1 → 2.28.0

package/dist/cli.js

@@ -40,6 +40,7 @@ import {
   createFeedbackIntegration,
   createFullGitHubProvider,
   createGatewayServerProxy,
+  createHarnessExecutor,
   createLearnablePolicy,
   createMockTechLead,
   createRealWorkflowEngine,
@@ -123,6 +124,7 @@ import {
   registerResearchCatalogReviewTool,
   registerResearchDiscoverTool,
   registerResearchQueryTool,
+  registerResearchSynthesizeTool,
   registerResources,
   registerRunGraphWorkflowTool,
   registerRunWorkflowTool,
@@ -134,17 +136,17 @@ import {
   sanitizeInput,
   setGlobalToolRateLimiterFactory,
   shutdownToolMemory,
+  synthesizeResearch,
   validateArgs,
   validateCommand,
   validateNexusEnv,
   validateTimeout,
   validateWorkflow,
   wrapInMarkdownFence
-} from "./chunk-L3LQ3RP5.js";
+} from "./chunk-QZEAD6AG.js";
 import {
-  doctorCommand,
   setupCommandAsync
-} from "./chunk-UVQ7R4C4.js";
+} from "./chunk-YSDUVCCZ.js";
 import {
   VERSION,
   capitalize,
@@ -153,11 +155,13 @@ import {
   connectTransport,
   createAllAdapters,
   createServer,
+  doctorCommand,
   getAvailableClis,
+  initDataDirectories,
   isRecord,
   truncateSentence
-} from "./chunk-ARNVVQ5W.js";
-import "./chunk-LCHCASB7.js";
+} from "./chunk-LKSTILEE.js";
+import "./chunk-UGNLR4NZ.js";
 import {
   calculateConsensus,
   countByCategory,
@@ -175,28 +179,23 @@ import {
   CATEGORY_DISPLAY_NAMES,
   DEFAULT_PR_REVIEW_CONFIG
 } from "./chunk-X2M7OF27.js";
-import "./chunk-X33QNBGA.js";
-import {
-  getAdaptiveBonus,
-  parseTierOverrides
-} from "./chunk-PGNRXCYY.js";
+import "./chunk-E7EX2KQJ.js";
 import {
   API_TIMEOUTS,
-  CLI_SUBPROCESS_TIMEOUTS,
-  MCP_TIMEOUTS
-} from "./chunk-LCDOP543.js";
-import {
   AgentCapability,
   AgentError,
   CLI_NAMES,
+  CLI_SUBPROCESS_TIMEOUTS,
   DEFAULT_CLI,
   DEFAULT_MODEL_CAPABILITIES,
   DEFAULT_MODEL_PROFILES,
   ErrorCode,
   INPUT_MODALITIES,
   LinUCBBandit,
+  MCP_TIMEOUTS,
   NexusError,
   OUTPUT_MODALITIES,
+  OutcomeStore,
   SPECIAL_FEATURES,
   SecurityError,
   TASK_CATEGORIES,
@@ -220,6 +219,8 @@ import {
   formatPercentage,
   formatStatus,
   formatZodError,
+  generateWeatherReport,
+  getAdaptiveBonus,
   getErrorMessage,
   getModelCapabilities,
   getOutcomeStore,
@@ -227,16 +228,18 @@ import {
   getTimeProvider,
   logger,
   ok,
+  parseTierOverrides,
   resetOutcomeStore,
   runWarmUp,
   safeRegex,
+  setOutcomeStore,
   summarizeTaskProfile,
   symbols,
   taskAnalysisResultToTaskProfile,
   toError,
   writeEmptyLine,
   writeLine
-} from "./chunk-BOWNZMPH.js";
+} from "./chunk-L2SHSW4T.js";
 import "./chunk-UP2VWCW5.js";
 
 // src/cli.ts
@@ -420,8 +423,8 @@ function resolveOutputPath(output2) {
   }
   return resolve(process.cwd(), DEFAULT_CONFIG_FILE);
 }
-function fileExists(path23) {
-  return existsSync(path23);
+function fileExists(path24) {
+  return existsSync(path24);
 }
 async function ensureDirectory(filePath) {
   const dir = dirname(filePath);
@@ -429,9 +432,9 @@ async function ensureDirectory(filePath) {
     await mkdir(dir, { recursive: true });
   }
 }
-async function writeConfigFile(path23) {
-  await ensureDirectory(path23);
-  await writeFile(path23, CONFIG_TEMPLATE, "utf-8");
+async function writeConfigFile(path24) {
+  await ensureDirectory(path24);
+  await writeFile(path24, CONFIG_TEMPLATE, "utf-8");
 }
 async function runConfigInit(options = {}) {
   const outputPath = resolveOutputPath(options.output);
@@ -1400,14 +1403,14 @@ ${colors.dim}Session ended.${colors.reset}
     });
   });
   rl.prompt();
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     rl.on("line", (line) => {
       void (async () => {
         try {
           const shouldExit = await processLine(line, session, logger17);
           if (shouldExit) {
             rl.close();
-            resolve11();
+            resolve12();
             return;
           }
         } catch (error) {
@@ -1419,7 +1422,7 @@ ${colors.dim}Session ended.${colors.reset}
       })();
     });
     rl.on("close", () => {
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -2413,9 +2416,9 @@ async function evaluateDirectory(target, timeoutMs) {
   }
   const aggregator = createAggregator();
   const results = [];
-  for (const [path23, evaluations] of evaluationsByComponent) {
+  for (const [path24, evaluations] of evaluationsByComponent) {
     if (evaluations.length > 0) {
-      results.push(aggregator.aggregate(path23, evaluations));
+      results.push(aggregator.aggregate(path24, evaluations));
     }
   }
   const priority = { deprecate: 0, refactor: 1, review: 2, retain: 3 };
@@ -3562,21 +3565,22 @@ function printSuccessMessage(durationMs) {
 
 // src/cli/routing-audit-logic.ts
 var logger5 = createLogger({ component: "routing-audit" });
+var sharedAnalyzer = createSharedTaskAnalyzer();
 var CLI_NAMES2 = ["claude", "gemini", "codex", "opencode"];
+var CONTEXT_NORMALIZATION_TOKENS = 1e5;
 function analyzeTaskString(taskStr) {
   const task = {
     id: "audit-" + String(getTimeProvider().now()),
     description: taskStr,
     context: {}
   };
-  const analyzer = createSharedTaskAnalyzer();
-  const analysis = analyzer.analyze(task);
+  const analysis = sharedAnalyzer.analyze(task);
   return taskAnalysisResultToTaskProfile(analysis);
 }
 function taskProfileToBanditContextFromProfile(profile) {
   return {
     taskComplexity: profile.reasoningComplexity / 10,
-    contextLengthNormalized: Math.min(profile.contextRequired / 1e5, 1),
+    contextLengthNormalized: Math.min(profile.contextRequired / CONTEXT_NORMALIZATION_TOKENS, 1),
     isCodeTask: profile.codeGeneration ? 1 : 0,
     isReasoningTask: profile.taskType === "architecture" || profile.reasoningComplexity > 5 ? 1 : 0,
     budgetUtilization: 0.5,
@@ -3926,27 +3930,27 @@ var CliAdapterAgent = class {
 };
 
 // src/cli/orchestrate-puppeteer.ts
-function loadPolicyParameters(path23, logger17) {
+function loadPolicyParameters(path24, logger17) {
   try {
-    if (fs2.existsSync(path23)) {
-      const content = fs2.readFileSync(path23, "utf-8");
+    if (fs2.existsSync(path24)) {
+      const content = fs2.readFileSync(path24, "utf-8");
       const params = JSON.parse(content);
-      logger17.info("Loaded policy parameters", { path: path23 });
+      logger17.info("Loaded policy parameters", { path: path24 });
       return params;
     }
   } catch (error) {
     const message = getErrorMessage(error);
-    logger17.warn("Failed to load policy parameters", { path: path23, error: message });
+    logger17.warn("Failed to load policy parameters", { path: path24, error: message });
   }
   return void 0;
 }
-function savePolicyParameters(path23, params, logger17) {
+function savePolicyParameters(path24, params, logger17) {
   try {
-    fs2.writeFileSync(path23, JSON.stringify(params, null, 2));
-    logger17.info("Saved policy parameters", { path: path23 });
+    fs2.writeFileSync(path24, JSON.stringify(params, null, 2));
+    logger17.info("Saved policy parameters", { path: path24 });
   } catch (error) {
     const message = getErrorMessage(error);
-    logger17.warn("Failed to save policy parameters", { path: path23, error: message });
+    logger17.warn("Failed to save policy parameters", { path: path24, error: message });
   }
 }
 function createAgentsFromAdapters(adapters) {
@@ -4874,38 +4878,33 @@ async function handleList(args, log) {
   const format = args.includes("--json") ? "json" : "table";
   const result = await sessionList({ limit, format, logger: log });
   if (!result.ok) {
-    console.error("Error: " + result.error.message);
-    process.exit(1);
+    throw new Error(result.error.message);
   }
   printSessionList(result.value, format);
 }
 async function handleShow(args, log) {
   const sessionId = args[0];
   if (sessionId === void 0) {
-    console.error("Error: Session ID required");
-    process.exit(1);
+    throw new Error("Session ID required");
   }
   const format = args.includes("--json") ? "json" : "text";
   const result = await sessionShow({ sessionId, format, logger: log });
   if (!result.ok) {
-    console.error("Error: " + result.error.message);
-    process.exit(1);
+    throw new Error(result.error.message);
   }
   printSessionShow(result.value, format);
 }
 async function handleExport(args, log) {
   const sessionId = args[0];
   if (sessionId === void 0) {
-    console.error("Error: Session ID required");
-    process.exit(1);
+    throw new Error("Session ID required");
   }
   const outputIdx = args.indexOf("--output");
   const outputPath = outputIdx >= 0 ? args[outputIdx + 1] : void 0;
   const format = args.includes("--markdown") ? "markdown" : "json";
   const result = await sessionExport({ sessionId, output: outputPath, format, logger: log });
   if (!result.ok) {
-    console.error("Error: " + result.error.message);
-    process.exit(1);
+    throw new Error(result.error.message);
   }
   if (outputPath === void 0) output(result.value);
   else output("Exported to " + outputPath);
@@ -4913,28 +4912,24 @@ async function handleExport(args, log) {
 async function handleDelete(args, log) {
   const sessionId = args[0];
   if (sessionId === void 0) {
-    console.error("Error: Session ID required");
-    process.exit(1);
+    throw new Error("Session ID required");
   }
   const result = await sessionDelete({ sessionId, logger: log });
   if (!result.ok) {
-    console.error("Error: " + result.error.message);
-    process.exit(1);
+    throw new Error(result.error.message);
   }
   output(result.value ? "Session deleted." : "Session not found.");
 }
 async function handlePrune(args, log) {
   const daysArg = args[0];
   if (daysArg === void 0) {
-    console.error("Error: Days argument required");
-    process.exit(1);
+    throw new Error("Days argument required");
   }
   const days = parseInt(daysArg, 10);
   const dryRun = args.includes("--dry-run");
   const result = await sessionPrune({ days, dryRun, logger: log });
   if (!result.ok) {
-    console.error("Error: " + result.error.message);
-    process.exit(1);
+    throw new Error(result.error.message);
   }
   const count = String(result.value);
   output(dryRun ? "Would delete " + count + " sessions." : "Deleted " + count + " sessions.");
@@ -5129,9 +5124,9 @@ _Generated by \`nexus-agents system-review\`_`;
 }
 function createIssue(result) {
   const date = getTimeProvider().nowDateString();
-  const body = createIssueBody(result).replace(/"/g, '\\"');
+  const body = createIssueBody(result).replace(/'/g, "'\\''");
   const out = safeExecSandboxed(
-    `gh issue create --title "System Review: ${date}" --body "${body}" --label system-review`,
+    `gh issue create --title 'System Review: ${date}' --body '${body}' --label 'system-review'`,
     { context: "gh" }
   );
   if (out !== null) {
@@ -5658,7 +5653,7 @@ function validateGitHubIssue(issueNumber) {
   return output2 !== null;
 }
 function escapeForShell(text) {
-  return text.replace(/"/g, '\\"').replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  return text.replace(/'/g, "'\\''");
 }
 function formatVoteComment(result) {
   const now = new Date(getTimeProvider().now()).toLocaleDateString("en-US", {
@@ -5698,7 +5693,7 @@ function recordVoteToGitHub(issueNumber, result) {
   const comment = formatVoteComment(result);
   const escapedComment = escapeForShell(comment);
   const output2 = safeExecSandboxed(
-    `gh issue comment ${String(issueNumber)} --body "${escapedComment}"`,
+    `gh issue comment ${String(issueNumber)} --body '${escapedComment}'`,
     { context: "gh" }
   );
   if (output2 !== null) {
@@ -6526,9 +6521,10 @@ function generateProposal(issues, options) {
 }
 function createSprintIssue(proposal) {
   try {
-    const escapedBody = proposal.body.replace(/"/g, '\\"').replace(/`/g, "\\`").replace(/\$/g, "\\$");
+    const escapedTitle = proposal.title.replace(/'/g, "'\\''");
+    const escapedBody = proposal.body.replace(/'/g, "'\\''");
     const output2 = safeExecSandboxed(
-      `gh issue create --title "${proposal.title}" --body "${escapedBody}" --label "epic"`,
+      `gh issue create --title '${escapedTitle}' --body '${escapedBody}' --label 'epic'`,
       { context: "gh" }
     );
     if (output2 === null) {
@@ -6818,7 +6814,7 @@ var ResearchPaperSchema = z2.object({
   /** arXiv ID (e.g., '2501.06322') */
   arxiv_id: z2.string().optional(),
   /** URL to the paper */
-  url: z2.string().url().optional(),
+  url: z2.url().optional(),
   /** Publication date (YYYY-MM format) */
   publication_date: z2.string().optional(),
   /** Publication venue */
@@ -6865,7 +6861,7 @@ var ResearchTechniqueSchema = z2.object({
   /** Tags for searching */
   tags: z2.array(z2.string()).optional().default([]),
   /** Metrics associated with this technique */
-  metrics: z2.record(z2.string()).optional().default({}),
+  metrics: z2.record(z2.string(), z2.string()).optional().default({}),
   /** Implementation status (required) */
   status: TechniqueStatusSchema,
   /** Priority level */
@@ -6887,11 +6883,11 @@ var ResearchTechniqueSchema = z2.object({
 });
 var PapersRegistrySchema = z2.object({
   schema_version: z2.string(),
-  papers: z2.record(ResearchPaperSchema)
+  papers: z2.record(z2.string(), ResearchPaperSchema)
 });
 var TechniquesRegistrySchema = z2.object({
   schema_version: z2.string(),
-  techniques: z2.record(ResearchTechniqueSchema)
+  techniques: z2.record(z2.string(), ResearchTechniqueSchema)
 });
 function getIntegrationFilePath(file) {
   if (typeof file === "string") {
@@ -7815,9 +7811,20 @@ async function researchIndexCommand(options) {
 }
 
 // src/cli/research-command.ts
+function optString(options, key) {
+  const val = options[key];
+  return typeof val === "string" ? val : void 0;
+}
+function optNumber(options, key) {
+  const val = options[key];
+  return typeof val === "number" ? val : void 0;
+}
+function optBoolean(options, key) {
+  return options[key] === true;
+}
 async function handleStatusCommand(args, options) {
-  const status = options["status"] ?? "all";
-  const format = options["format"] ?? "table";
+  const status = optString(options, "status") ?? "all";
+  const format = optString(options, "format") ?? "table";
   const statusOptions = {
     techniqueId: args[0],
     status,
@@ -7831,10 +7838,10 @@ async function handleOverlapCommand(args, options) {
   if (techniqueId === void 0 || techniqueId === "") {
     return "Error: technique-id is required for overlap command";
   }
-  const format = options["format"] ?? "table";
+  const format = optString(options, "format") ?? "table";
   const overlapOptions = {
     techniqueId,
-    threshold: options["threshold"] ?? 0.3,
+    threshold: optNumber(options, "threshold") ?? 0.3,
     format
   };
   const result = await findOverlaps(overlapOptions);
@@ -7847,9 +7854,9 @@ async function handleAddCommand(args, options) {
   }
   const addOptions = {
     arxivId,
-    topic: options["topic"],
-    priority: options["priority"],
-    dryRun: options["dryRun"] ?? false
+    topic: optString(options, "topic"),
+    priority: optString(options, "priority"),
+    dryRun: optBoolean(options, "dryRun")
   };
   const result = await addResearchPaper(addOptions);
   return result.message;
@@ -7898,23 +7905,23 @@ function formatDiscoverResults(topic, items, errors, maxResults) {
   return lines.join("\n");
 }
 async function handleDiscoverCommand(args, options) {
-  const topic = args[0] ?? options["topic"];
+  const topic = args[0] ?? optString(options, "topic");
   if (topic === void 0 || topic === "") {
     return "Error: --topic is required for discover command";
   }
-  const source = options["source"] ?? "all";
-  const maxResults = options["maxResults"] ?? 10;
+  const source = optString(options, "source") ?? "all";
+  const maxResults = optNumber(options, "maxResults") ?? 10;
   const { results, errors } = await queryDiscoverSources(topic, source, maxResults);
   return formatDiscoverResults(topic, results, errors, maxResults);
 }
 async function handleReviewCommand(args, options) {
-  const topic = args[0] ?? options["topic"];
+  const topic = args[0] ?? optString(options, "topic");
   if (topic === void 0 || topic === "") {
     return "Error: --topic is required for review command";
   }
-  const maxResults = options["maxResults"] ?? 10;
-  const createIssues = options["createIssues"] ?? false;
-  const vote = options["vote"] ?? false;
+  const maxResults = optNumber(options, "maxResults") ?? 10;
+  const createIssues = optBoolean(options, "createIssues");
+  const vote = optBoolean(options, "vote");
   const result = await executeReview(
     { topic, maxResults, createIssues, vote },
     (t, max) => queryDiscoverSources(t, "all", max)
@@ -7922,10 +7929,89 @@ async function handleReviewCommand(args, options) {
   return formatReviewResults(result);
 }
 async function handlePrioritizeCommand(args, options) {
-  const topic = args[0] ?? options["topic"];
-  const vote = options["vote"] ?? false;
+  const topic = args[0] ?? optString(options, "topic");
+  const vote = optBoolean(options, "vote");
   return executePrioritize({ topic, vote });
 }
+async function handleSynthesizeCommand(args, options) {
+  const topic = args[0] ?? optString(options, "topic");
+  const result = await synthesizeResearch(topic);
+  if (!result.ok) {
+    return `Error: ${result.error.message}`;
+  }
+  return formatSynthesisResult(result.value);
+}
+function formatSynthesisResult(synthesis) {
+  const lines = [
+    `Research Synthesis: ${String(synthesis.totalPapers)} papers across ${String(synthesis.topicCount)} topics`,
+    ""
+  ];
+  for (const cluster of synthesis.clusters) {
+    formatCluster(cluster, lines);
+  }
+  if (synthesis.crossCuttingThemes.length > 0) {
+    lines.push("## Cross-Cutting Themes");
+    for (const theme of synthesis.crossCuttingThemes) {
+      lines.push(`  - ${theme}`);
+    }
+    lines.push("");
+  }
+  formatAlignmentSummary(synthesis.alignmentSummary, lines);
+  formatFeatureGates(synthesis.featureGates, lines);
+  return lines.join("\n");
+}
+function formatCluster(cluster, lines) {
+  lines.push(`## ${cluster.topic} (${String(cluster.paperCount)} papers)`);
+  lines.push(`Papers: ${cluster.papers.join(", ")}`);
+  if (cluster.commonThemes.length > 0) lines.push(`Themes: ${cluster.commonThemes.join(", ")}`);
+  if (cluster.keyInsights.length > 0) {
+    lines.push("Key insights:");
+    for (const insight of cluster.keyInsights.slice(0, 5)) lines.push(`  - ${insight}`);
+  }
+  if (cluster.implementationOpportunities.length > 0) {
+    lines.push(`Opportunities: ${cluster.implementationOpportunities.join(", ")}`);
+  }
+  if (cluster.gaps.length > 0) lines.push(`Gaps: ${cluster.gaps.join("; ")}`);
+  const partial = cluster.alignedTechniques.filter((a) => a.status === "partial");
+  if (partial.length > 0) {
+    lines.push("Improvement opportunities:");
+    for (const a of partial.slice(0, 3)) {
+      const hint = a.improvementHint !== void 0 ? ` \u2014 ${a.improvementHint}` : "";
+      lines.push(`  - ${a.technique} (${a.canonicalPath ?? "unknown"})${hint}`);
+    }
+  }
+  lines.push("");
+}
+function formatFeatureGates(gates, lines) {
+  if (gates.length === 0) return;
+  const linked = gates.filter((g) => g.linkedTechniqueCount > 0);
+  const unlinked = gates.filter((g) => g.linkedTechniqueCount === 0);
+  lines.push("");
+  lines.push(
+    `## Feature Gates (${String(gates.length)} total, ${String(linked.length)} research-linked)`
+  );
+  for (const g of linked) {
+    lines.push(
+      `  ${g.envVar}=${g.defaultValue} \u2014 ${g.description} [${String(g.linkedTechniqueCount)} techniques]`
+    );
+  }
+  if (unlinked.length > 0) {
+    lines.push(
+      `  + ${String(unlinked.length)} infrastructure gates (auth, logging, rate limiting, etc.)`
+    );
+  }
+}
+function formatAlignmentSummary(summary, lines) {
+  if (summary.total === 0) return;
+  lines.push("## Alignment Summary");
+  lines.push(
+    `Implemented: ${String(summary.implemented)} | Partial: ${String(summary.partial)} | Not started: ${String(summary.notStarted)} | Total: ${String(summary.total)}`
+  );
+  if (summary.topOpportunities.length > 0) {
+    lines.push("Top improvement opportunities:");
+    for (const opp of summary.topOpportunities.slice(0, 5)) lines.push(`  - ${opp}`);
+  }
+}
 var VALID_SUBCOMMANDS = [
   "status",
   "overlap",
@@ -7936,7 +8022,8 @@ var VALID_SUBCOMMANDS = [
   "index",
   "discover",
   "review",
-  "prioritize"
+  "prioritize",
+  "synthesize"
 ];
 function isValidResearchSubcommand(value) {
   return value !== void 0 && VALID_SUBCOMMANDS.includes(value);
@@ -7956,7 +8043,8 @@ var SUBCOMMAND_HANDLERS = {
   index: (args) => handleIndexCommand(args),
   discover: handleDiscoverCommand,
   review: handleReviewCommand,
-  prioritize: handlePrioritizeCommand
+  prioritize: handlePrioritizeCommand,
+  synthesize: handleSynthesizeCommand
 };
 async function researchCommand(subcommand, args, options) {
   const handler = SUBCOMMAND_HANDLERS[subcommand];
@@ -9030,6 +9118,16 @@ function extractToolsFromFile(sourceFile, relativePath) {
   }
   return tools;
 }
+function resolvePropertyValue(prop, sourceFile) {
+  const propAssign = prop.asKind(SyntaxKind2.PropertyAssignment);
+  if (propAssign !== void 0) return propAssign.getInitializer();
+  const shorthand = prop.asKind(SyntaxKind2.ShorthandPropertyAssignment);
+  if (shorthand !== void 0 && sourceFile !== void 0) {
+    const varDecl = sourceFile.getVariableDeclaration(shorthand.getName());
+    return varDecl?.getInitializer();
+  }
+  return void 0;
+}
 function extractToolMeta(callText, args, _sourceFile) {
   let description = "";
   let schemaArg;
@@ -9040,14 +9138,12 @@ function extractToolMeta(callText, args, _sourceFile) {
       if (configObj !== void 0) {
         const descProp = configObj.getProperty("description");
         if (descProp !== void 0) {
-          const propAssign = descProp.asKind(SyntaxKind2.PropertyAssignment);
-          const init = propAssign?.getInitializer();
+          const init = resolvePropertyValue(descProp, _sourceFile);
           description = init?.getText().replace(/^['"]|['"]$/g, "") ?? "";
         }
         const schemaProp = configObj.getProperty("inputSchema");
         if (schemaProp !== void 0) {
-          const propAssign = schemaProp.asKind(SyntaxKind2.PropertyAssignment);
-          schemaArg = propAssign?.getInitializer();
+          schemaArg = resolvePropertyValue(schemaProp, _sourceFile);
         }
       }
     }
@@ -9514,8 +9610,9 @@ function getLinkType(url) {
   }
   return "internal";
 }
+var DANGEROUS_SCHEME_REGEX = /^[\s\x00-\x1f\x7f]*(mailto|javascript|data|file|ftp)[\s\x00-\x1f\x7f]*:/i;
 function shouldSkipUrl(url) {
-  return url.startsWith("mailto:") || url.startsWith("javascript:");
+  return DANGEROUS_SCHEME_REGEX.test(url);
 }
 function buildReferenceMap(content) {
   const references = /* @__PURE__ */ new Map();
@@ -9787,7 +9884,8 @@ async function getActualModules(srcPath) {
   try {
     const entries = await fs12.readdir(srcPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("__")).map((e) => e.name);
-  } catch {
+  } catch (error) {
+    logger9.debug("Failed to read source modules", { srcPath, error: getErrorMessage(error) });
     return [];
   }
 }
@@ -10249,6 +10347,8 @@ async function verifyCommand(options) {
 }
 
 // src/cli/swe-bench-command.ts
+import * as os2 from "os";
+import * as path19 from "path";
 function runInfo(options) {
   console.log(`
 SWE-bench Dataset: ${options.variant}`);
@@ -10299,7 +10399,9 @@ function buildConfig(options) {
     ...DEFAULT_SWE_BENCH_CONFIG,
     variant: options.variant,
     output_path: options.output,
-    resume: options.resume
+    resume: options.resume,
+    concurrency: options.concurrency,
+    memory_dir: "/tmp/swe-bench-memory"
   };
   return options.limit !== void 0 ? { ...base, limit: options.limit } : base;
 }
@@ -10332,7 +10434,10 @@ async function runBenchmark(options) {
   console.log(`
 SWE-bench Run: ${options.variant}`);
   console.log("=".repeat(40));
-  const executorResult = await createExecutor(options.verbose);
+  const executorResult = await createExecutor({
+    verbose: options.verbose,
+    mcpEnabled: options.mcp
+  });
   if (!executorResult.ok) {
     console.error(`
 Error: ${executorResult.error.message}`);
@@ -10355,38 +10460,102 @@ Error: ${executorResult.error.message}`);
   });
   return { success: result.success, message: result.message, details: { ...result } };
 }
-async function commandExists(cmd) {
-  const { exec } = await import("child_process");
-  const { promisify } = await import("util");
-  try {
-    await promisify(exec)(`which ${cmd}`);
-    return true;
-  } catch {
-    return false;
+function isValidRunId(runId) {
+  return /^[a-zA-Z0-9_-]{1,64}$/.test(runId);
+}
+function isValidOutputDir(dir) {
+  const resolved = path19.resolve(dir);
+  return !resolved.includes("..") && resolved === path19.normalize(resolved);
+}
+function formatProgress(progress) {
+  const pct = progress.totalCount > 0 ? Math.round(progress.completedCount / progress.totalCount * 100) : 0;
+  const base = `[${String(progress.completedCount)}/${String(progress.totalCount)}] ${String(pct)}%`;
+  if (progress.currentInstanceId !== void 0) {
+    return `${base} - ${progress.currentInstanceId}`;
+  }
+  return base;
+}
+function buildHarnessConfig(options) {
+  const predictionsPath = options.predictions ?? options.output;
+  const runId = options.runId ?? `eval-${String(Date.now())}`;
+  return {
+    predictionsPath: path19.resolve(predictionsPath),
+    datasetName: options.variant,
+    maxWorkers: options.maxWorkers,
+    runId,
+    timeoutSeconds: 1800,
+    outputDir: path19.resolve(options.outputDir),
+    useDocker: true,
+    cacheLevel: options.cacheLevel
+  };
+}
+function validateEvaluateInputs(options) {
+  if (options.runId !== void 0 && !isValidRunId(options.runId)) {
+    return "Invalid run-id: alphanumeric, hyphens, underscores only";
+  }
+  if (!isValidOutputDir(options.outputDir)) {
+    return "Invalid output-dir: path traversal detected";
+  }
+  return null;
+}
+function displayEvaluateResults(result, verbose) {
+  console.log("\n");
+  console.log(`Resolved: ${String(result.resolvedInstances)}/${String(result.totalInstances)}`);
+  console.log(`Resolution rate: ${(result.resolutionRate * 100).toFixed(1)}%`);
+  if (result.logPath !== void 0) console.log(`Logs: ${result.logPath}`);
+  if (verbose && result.instanceResults.length > 0) {
+    console.log("\nPer-instance results:");
+    for (const inst of result.instanceResults) {
+      console.log(`  [${inst.resolved ? "PASS" : "FAIL"}] ${inst.instanceId}`);
+    }
   }
 }
 async function runEvaluate(options) {
   console.log(`
 SWE-bench Evaluate`);
   console.log("=".repeat(40));
-  const idsResult = await getCompletedInstanceIds(options.output);
+  const predictionsPath = options.predictions ?? options.output;
+  const idsResult = await getCompletedInstanceIds(predictionsPath);
   if (!idsResult.ok) {
     console.log('No predictions file. Run "nexus-agents swe-bench run" first.');
     return { success: false, message: "No predictions file" };
   }
   const count = idsResult.value.size;
   if (count === 0) return { success: false, message: "No predictions" };
-  console.log("\nChecking dependencies...");
-  const hasPython = await commandExists("python3");
-  const hasDocker = await commandExists("docker");
-  if (!hasPython) return { success: false, message: "python3 not found" };
-  if (!hasDocker) return { success: false, message: "docker not found" };
-  console.log("  [OK] python3, docker");
-  console.log("\nManual evaluation:");
-  console.log(`  python -m swebench.harness.run_evaluation \\`);
-  console.log(`    --predictions_path ${options.output} \\`);
-  console.log(`    --swe_bench_tasks princeton-nlp/SWE-bench_Lite`);
-  return { success: true, message: `${String(count)} predictions ready` };
+  const inputError = validateEvaluateInputs(options);
+  if (inputError !== null) return { success: false, message: inputError };
+  console.log(`Predictions: ${String(count)} instances`);
+  console.log(`Cache level: ${options.cacheLevel}`);
+  console.log(`Max workers: ${String(options.maxWorkers)}`);
+  const executor = createHarnessExecutor();
+  const validation = await executor.validate();
+  if (!validation.ready) {
+    console.error("\nEnvironment not ready:");
+    for (const err2 of validation.errors) console.error(`  - ${err2}`);
+    return { success: false, message: validation.errors.join("; ") };
+  }
+  console.log(
+    `
+Environment OK (Python ${validation.pythonVersion ?? "?"}, Docker ${validation.dockerVersion ?? "?"})`
+  );
+  const config = buildHarnessConfig(options);
+  console.log(`
+Running evaluation (run_id: ${config.runId})...`);
+  const result = await executor.execute(config, (progress) => {
+    if (progress.state === "running") process.stdout.write(`\r  ${formatProgress(progress)}`);
+  });
+  displayEvaluateResults(result, options.verbose);
+  const rateStr = (result.resolutionRate * 100).toFixed(1);
+  return {
+    success: true,
+    message: `${String(result.resolvedInstances)}/${String(result.totalInstances)} resolved (${rateStr}%)`,
+    details: {
+      resolved: result.resolvedInstances,
+      total: result.totalInstances,
+      resolutionRate: result.resolutionRate,
+      runId: result.runId
+    }
+  };
 }
 function parseSubcommand(arg) {
   if (arg === "status") return "status";
@@ -10399,13 +10568,53 @@ function parseVariant(arg) {
   if (v === "lite" || v === "verified" || v === "full") return v;
   return "lite";
 }
+var MAX_WORKERS_CAP = Math.min(Math.floor(os2.cpus().length * 0.75), 24);
+var VALID_CACHE_LEVELS = /* @__PURE__ */ new Set(["none", "base", "env", "instance"]);
+var BOOLEAN_FLAGS = {
+  "--resume": "resume",
+  "--verbose": "verbose",
+  "-v": "verbose",
+  "--mcp": "mcp"
+};
+function parseCacheLevel(value) {
+  const level = value;
+  return VALID_CACHE_LEVELS.has(level) ? level : "env";
+}
+function parseMaxWorkers(value) {
+  const parsed = parseInt(value, 10);
+  if (Number.isNaN(parsed) || parsed < 1) return 4;
+  return Math.min(parsed, MAX_WORKERS_CAP);
+}
+var STRING_FLAGS = [
+  ["--output=", "output", (v) => v],
+  ["--predictions=", "predictions", (v) => v],
+  ["--run-id=", "runId", (v) => v],
+  ["--output-dir=", "outputDir", (v) => v],
+  ["--limit=", "limit", (v) => parseInt(v, 10)],
+  ["--concurrency=", "concurrency", (v) => Math.max(1, parseInt(v, 10) || 1)],
+  ["--cache-level=", "cacheLevel", parseCacheLevel],
+  ["--max-workers=", "maxWorkers", parseMaxWorkers]
+];
 function parseArg(arg, state) {
-  if (arg.startsWith("--variant=")) state.variant = parseVariant(arg);
-  else if (arg.startsWith("--limit=")) state.limit = parseInt(arg.slice("--limit=".length), 10);
-  else if (arg.startsWith("--output=")) state.output = arg.slice("--output=".length);
-  else if (arg === "--resume") state.resume = true;
-  else if (arg === "--verbose" || arg === "-v") state.verbose = true;
-  else if (arg.startsWith("--instance=")) state.instances.push(arg.slice("--instance=".length));
+  const boolKey = BOOLEAN_FLAGS[arg];
+  if (boolKey !== void 0) {
+    state[boolKey] = true;
+    return;
+  }
+  if (arg.startsWith("--variant=")) {
+    state.variant = parseVariant(arg);
+    return;
+  }
+  if (arg.startsWith("--instance=")) {
+    state.instances.push(arg.slice("--instance=".length));
+    return;
+  }
+  for (const [prefix, key, transform] of STRING_FLAGS) {
+    if (arg.startsWith(prefix)) {
+      state[key] = transform(arg.slice(prefix.length));
+      return;
+    }
+  }
 }
 function parseSweBenchArgs(args) {
   const subcommand = parseSubcommand(args[0]);
@@ -10415,7 +10624,14 @@ function parseSweBenchArgs(args) {
     output: "predictions.jsonl",
     resume: false,
     verbose: false,
-    instances: []
+    concurrency: 1,
+    instances: [],
+    mcp: false,
+    predictions: void 0,
+    cacheLevel: "env",
+    maxWorkers: 4,
+    runId: void 0,
+    outputDir: "./logs/run_evaluation"
   };
   for (const arg of args.slice(1)) parseArg(arg, state);
   const base = {
@@ -10424,9 +10640,17 @@ function parseSweBenchArgs(args) {
     output: state.output,
     resume: state.resume,
     verbose: state.verbose,
-    instances: state.instances
+    concurrency: state.concurrency,
+    instances: state.instances,
+    mcp: state.mcp,
+    cacheLevel: state.cacheLevel,
+    maxWorkers: state.maxWorkers,
+    outputDir: state.outputDir,
+    ...state.limit !== void 0 ? { limit: state.limit } : {},
+    ...state.predictions !== void 0 ? { predictions: state.predictions } : {},
+    ...state.runId !== void 0 ? { runId: state.runId } : {}
   };
-  return state.limit !== void 0 ? { ...base, limit: state.limit } : base;
+  return base;
 }
 function printSweBenchHelp() {
   console.log(`
@@ -10444,7 +10668,16 @@ Options:
   --output=<path>                 Output predictions file (default: predictions.jsonl)
   --resume                        Skip already completed instances
   --instance=<id>                 Run specific instance (can be repeated)
+  --concurrency=<n>               Parallel workers (default: 1, sequential)
+  --mcp                           Enable MCP tools (memory, research) in child sessions
   --verbose, -v                   Enable verbose output
+
+Evaluate options:
+  --predictions=<path>            Predictions file (default: --output value)
+  --cache-level=<level>           Docker cache: none|base|env|instance (default: env)
+  --max-workers=<n>               Parallel Docker workers (default: 4, max: ${String(MAX_WORKERS_CAP)})
+  --run-id=<id>                   Custom run identifier
+  --output-dir=<path>             Harness log directory (default: ./logs/run_evaluation)
 `);
 }
 async function sweBenchCommand(args) {
@@ -10834,7 +11067,7 @@ function isValidConfigAction(value) {
 
 // src/cli/config-command-helpers.ts
 import * as fs13 from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 import { existsSync as existsSync10 } from "fs";
 
 // src/cli/config-command-formatting.ts
@@ -11102,10 +11335,10 @@ function parseValueFromString(stringValue, defaultValue) {
 }
 function resolveFilePath(filePath, allowedBase) {
   const base = allowedBase ?? process.cwd();
-  const resolved = path19.isAbsolute(filePath) ? filePath : path19.resolve(base, filePath);
-  const normalizedResolved = path19.normalize(resolved);
-  const normalizedBase = path19.normalize(base);
-  const isWithinBase = normalizedResolved === normalizedBase || normalizedResolved.startsWith(normalizedBase + path19.sep);
+  const resolved = path20.isAbsolute(filePath) ? filePath : path20.resolve(base, filePath);
+  const normalizedResolved = path20.normalize(resolved);
+  const normalizedBase = path20.normalize(base);
+  const isWithinBase = normalizedResolved === normalizedBase || normalizedResolved.startsWith(normalizedBase + path20.sep);
   if (!isWithinBase) {
     throw new ConfigCommandError(
       "PATH_TRAVERSAL",
@@ -11116,7 +11349,7 @@ function resolveFilePath(filePath, allowedBase) {
 }
 function getDefaultExportPath(format) {
   const extension = format === "json" ? "json" : "yaml";
-  return path19.resolve(process.cwd(), `nexus-config.${extension}`);
+  return path20.resolve(process.cwd(), `nexus-config.${extension}`);
 }
 
 // src/cli/config-command-handlers.ts
@@ -11531,20 +11764,20 @@ var SessionEndInputSchema = HookInputBaseSchema.extend({
 var PreToolUseInputSchema = HookInputBaseSchema.extend({
   hook_event_name: z6.literal("PreToolUse"),
   tool_name: z6.string(),
-  tool_input: z6.record(z6.unknown()),
+  tool_input: z6.record(z6.string(), z6.unknown()),
   tool_use_id: z6.string()
 });
 var PostToolUseInputSchema = HookInputBaseSchema.extend({
   hook_event_name: z6.literal("PostToolUse"),
   tool_name: z6.string(),
-  tool_input: z6.record(z6.unknown()),
-  tool_response: z6.record(z6.unknown()),
+  tool_input: z6.record(z6.string(), z6.unknown()),
+  tool_response: z6.record(z6.string(), z6.unknown()),
   tool_use_id: z6.string()
 });
 var PostToolUseFailureInputSchema = HookInputBaseSchema.extend({
   hook_event_name: z6.literal("PostToolUseFailure"),
   tool_name: z6.string(),
-  tool_input: z6.record(z6.unknown()),
+  tool_input: z6.record(z6.string(), z6.unknown()),
   tool_use_id: z6.string(),
   error: z6.string().optional()
 });
@@ -11592,7 +11825,7 @@ var SubagentStartInputSchema = HookInputBaseSchema.extend({
 var PermissionRequestInputSchema = HookInputBaseSchema.extend({
   hook_event_name: z6.literal("PermissionRequest"),
   tool_name: z6.string(),
-  tool_input: z6.record(z6.unknown()),
+  tool_input: z6.record(z6.string(), z6.unknown()),
   tool_use_id: z6.string()
 });
 var HookInputSchema = z6.discriminatedUnion("hook_event_name", [
@@ -11623,7 +11856,7 @@ var PreToolUseOutputSchema = HookOutputBaseSchema.extend({
     hookEventName: z6.literal("PreToolUse"),
     permissionDecision: PermissionDecision.optional(),
     permissionDecisionReason: z6.string().optional(),
-    updatedInput: z6.record(z6.unknown()).optional(),
+    updatedInput: z6.record(z6.string(), z6.unknown()).optional(),
     additionalContext: z6.string().optional()
   }).optional()
 });
@@ -11658,7 +11891,7 @@ var PermissionRequestOutputSchema = HookOutputBaseSchema.extend({
     hookEventName: z6.literal("PermissionRequest"),
     decision: z6.object({
       behavior: z6.enum(["allow", "deny"]),
-      updatedInput: z6.record(z6.unknown()).optional(),
+      updatedInput: z6.record(z6.string(), z6.unknown()).optional(),
       message: z6.string().optional(),
       interrupt: z6.boolean().optional()
     })
@@ -11746,34 +11979,35 @@ function writeResultAndExit(result) {
 
 // src/cli/hooks/hook-router.ts
 async function readStdin() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("readable", () => {
       let chunk;
       while ((chunk = process.stdin.read()) !== null) {
+        if (typeof chunk !== "string") continue;
         data += chunk;
       }
     });
     process.stdin.on("end", () => {
-      resolve11(data);
+      resolve12(data);
     });
     process.stdin.on("error", (err2) => {
       reject(err2);
     });
     if (process.stdin.isTTY) {
-      resolve11("");
+      resolve12("");
     }
   });
 }
 async function readStdinWithTimeout(timeoutMs = 5e3) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const timeout2 = setTimeout(() => {
       reject(new Error(`Stdin read timeout after ${String(timeoutMs)}ms`));
     }, timeoutMs);
     readStdin().then((data) => {
       clearTimeout(timeout2);
-      resolve11(data);
+      resolve12(data);
     }).catch((err2) => {
       clearTimeout(timeout2);
       reject(err2 instanceof Error ? err2 : new Error(String(err2)));
@@ -11829,7 +12063,7 @@ async function processHook(handlers) {
     return exitError(`Hook processing error: ${message}`);
   }
 }
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Map([
+var BOOLEAN_FLAGS2 = /* @__PURE__ */ new Map([
   ["--validate", "validate"],
   ["--load-context", "loadContext"],
   ["--track-metrics", "trackMetrics"],
@@ -11850,7 +12084,7 @@ function parseHookArgs(args) {
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === void 0) continue;
-    const booleanKey = BOOLEAN_FLAGS.get(arg);
+    const booleanKey = BOOLEAN_FLAGS2.get(arg);
     if (booleanKey !== void 0) {
       setBooleanOption(options, booleanKey);
       continue;
@@ -13429,7 +13663,8 @@ function getLatestTag() {
   try {
     const result = execSync2("git describe --tags --abbrev=0", {
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: CLI_SUBPROCESS_TIMEOUTS.ghCommandMs
     }).trim();
     return result || void 0;
   } catch {
@@ -13440,7 +13675,8 @@ function getCommitsBetween(from, to = "HEAD") {
   try {
     const result = execSync2(`git log ${from}..${to} --oneline --format="%h %s"`, {
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: CLI_SUBPROCESS_TIMEOUTS.ghCommandMs
     }).trim();
     return result ? result.split("\n").filter(Boolean) : [];
   } catch {
@@ -13485,7 +13721,7 @@ function groupCommitsByCategory(commits) {
   const categoryMap = /* @__PURE__ */ new Map();
   for (const commit of commits) {
     const category = mapTypeToCategory(commit.type);
-    const existing = categoryMap.get(category) || [];
+    const existing = categoryMap.get(category) ?? [];
     existing.push(commit);
     categoryMap.set(category, existing);
   }
@@ -13548,8 +13784,8 @@ function generateMarkdownFormat(version, categories) {
   const lines = [];
   lines.push(`# Release ${version}`);
   lines.push("");
-  const featCount = categories.find((c) => c.name === "Added")?.commits.length || 0;
-  const fixCount = categories.find((c) => c.name === "Fixed")?.commits.length || 0;
+  const featCount = categories.find((c) => c.name === "Added")?.commits.length ?? 0;
+  const fixCount = categories.find((c) => c.name === "Fixed")?.commits.length ?? 0;
   const totalCount = categories.reduce((sum, c) => sum + c.commits.length, 0);
   lines.push("## Highlights");
   lines.push("");
@@ -13695,7 +13931,8 @@ async function validateSecurity(options) {
   try {
     execSync3("npm audit --audit-level=high 2>/dev/null", {
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: CLI_SUBPROCESS_TIMEOUTS.ghCommandMs
     });
   } catch {
     findings.push({
@@ -13718,7 +13955,11 @@ async function validateSecurity(options) {
   try {
     const result = execSync3(
       'git diff HEAD~10..HEAD -- "*.ts" "*.js" | grep -iE "(api[_-]?key|secret|password|token)" | head -5',
-      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: CLI_SUBPROCESS_TIMEOUTS.ghCommandMs
+      }
     );
     if (result.trim()) {
       findings.push({
@@ -13745,10 +13986,11 @@ async function validateArchitecture2(options) {
   try {
     const result = execSync3("npx nexus-agents fitness-audit --format=json 2>/dev/null", {
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: CLI_SUBPROCESS_TIMEOUTS.releaseValidateMs
     });
     const audit = JSON.parse(result);
-    const fitnessScore = audit.score || 0;
+    const fitnessScore = typeof audit["score"] === "number" ? audit["score"] : 0;
     if (fitnessScore < 90) {
       findings.push({
         severity: "error",
@@ -13765,13 +14007,14 @@ async function validateArchitecture2(options) {
         description: "Fitness score meets release threshold."
       });
     }
-    if (audit.findings) {
-      for (const finding of audit.findings) {
+    const auditFindings = audit["findings"];
+    if (Array.isArray(auditFindings)) {
+      for (const finding of auditFindings) {
         findings.push({
           severity: "info",
           category: "architecture",
-          title: finding.message || "Fitness finding",
-          description: finding.suggestion || ""
+          title: typeof finding["message"] === "string" ? finding["message"] : "Fitness finding",
+          description: typeof finding["suggestion"] === "string" ? finding["suggestion"] : ""
         });
       }
     }
@@ -14080,7 +14323,7 @@ function getBlueskyConfig() {
 }
 async function loadAtproto() {
   try {
-    const mod = await import("./dist-Y5F6UM2N.js");
+    const mod = await import("./dist-H5XNXVAV.js");
     return { AtpAgent: mod.AtpAgent, RichText: mod.RichText };
   } catch {
     return void 0;
@@ -14146,9 +14389,9 @@ function generateBlogPost(options) {
     return parseConventionalCommit(line.substring(0, spaceIndex), line.substring(spaceIndex + 1));
   });
   const categories = groupCommitsByCategory(parsedCommits);
-  const featCount = categories.find((c) => c.name === "Added")?.commits.length || 0;
-  const fixCount = categories.find((c) => c.name === "Fixed")?.commits.length || 0;
-  const refactorCount = categories.find((c) => c.name === "Changed")?.commits.length || 0;
+  const featCount = categories.find((c) => c.name === "Added")?.commits.length ?? 0;
+  const fixCount = categories.find((c) => c.name === "Fixed")?.commits.length ?? 0;
+  const refactorCount = categories.find((c) => c.name === "Changed")?.commits.length ?? 0;
   const frontmatter = {
     title: `nexus-agents v${options.version} Released: Multi-Agent Orchestration Improvements`,
     date: today,
@@ -14413,7 +14656,7 @@ async function releaseAnnounceCommand(args) {
 
 // src/cli/scaffold.ts
 import * as fs15 from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 
 // src/cli/scaffold-templates.ts
 function toolImportsAndSchema(name, pascal) {
@@ -14440,7 +14683,7 @@ import { createSecureHandler, type HandlerContext } from '../middleware/secure-h
  */
 export const ${pascal}InputSchema = z.object({
   input: z.string().min(1).describe('Primary input for ${name} operation'),
-  options: z.record(z.unknown()).optional().describe('Additional options'),
+  options: z.record(z.string(), z.unknown()).optional().describe('Additional options'),
 });
 
 export type ${pascal}Input = z.infer<typeof ${pascal}InputSchema>;
@@ -14749,8 +14992,8 @@ ${lines}`;
 function writeFiles(files) {
   const createdPaths = [];
   for (const file of files) {
-    const fullPath = path20.resolve(process.cwd(), file.path);
-    const dir = path20.dirname(fullPath);
+    const fullPath = path21.resolve(process.cwd(), file.path);
+    const dir = path21.dirname(fullPath);
     fs15.mkdirSync(dir, { recursive: true });
     if (fs15.existsSync(fullPath)) {
       return {
@@ -14865,7 +15108,7 @@ function getCliRole(cli, category) {
     ["devops", "gemini"],
     ["research", "claude"],
     ["documentation", "claude"],
-    ["exploration", "claude"]
+    ["exploration", "codex"]
   ]);
   return cli === secondaryMap.get(category) ? "secondary" : "other";
 }
@@ -14945,7 +15188,10 @@ function buildDetails(taskCount, counts, nonZero, score, passed) {
 function runE2EEval(config, logger17) {
   const log = logger17 ?? createLogger({ component: "e2e-eval" });
   const taskCount = config?.taskCount ?? 50;
-  if (config?.resetStore !== false) resetOutcomeStore();
+  if (config?.resetStore !== false) {
+    resetOutcomeStore();
+    setOutcomeStore(new OutcomeStore());
+  }
   const counts = generateOutcomes(taskCount);
   log.info("E2E eval: outcomes recorded", { taskCount });
   const { bonuses, nonZeroCount } = checkAdaptiveBonuses();
@@ -15567,6 +15813,7 @@ COMMANDS:
   visualize       Generate Mermaid diagrams and ASCII dashboards (architecture, swarm, flow)
   capabilities    Show model capabilities matrix (modalities, tools, features)
   status          At-a-glance project health dashboard (fitness, adapters, version)
+  health          Swarm health metrics dashboard (utilization, routing accuracy, failures)
   auth            Manage MCP authentication tokens (init, show, rotate)
 
 OPTIONS:
@@ -15887,6 +16134,8 @@ EXAMPLES:
   nexus-agents capabilities list --format=json       Output capabilities as JSON
   nexus-agents status                                 Show project health dashboard
   nexus-agents status --format=json                   Output status as JSON
+  nexus-agents health                                 Show swarm health metrics
+  nexus-agents health --format=json                   Output health metrics as JSON
   nexus-agents auth init                              Generate initial auth token
   nexus-agents auth show                              Check token status
   nexus-agents auth rotate                            Rotate to new token
@@ -16033,6 +16282,33 @@ var PARSE_ARGS_CONFIG = {
       type: "boolean",
       default: false
     },
+    concurrency: {
+      type: "string",
+      default: "1"
+    },
+    mcp: {
+      type: "boolean",
+      default: false
+    },
+    // SWE-bench evaluate options
+    predictions: {
+      type: "string"
+    },
+    "cache-level": {
+      type: "string",
+      default: "env"
+    },
+    "max-workers": {
+      type: "string",
+      default: "4"
+    },
+    "run-id": {
+      type: "string"
+    },
+    "output-dir": {
+      type: "string",
+      default: "./logs/run_evaluation"
+    },
     // Learning-metrics command options
     period: {
       type: "string",
@@ -16138,7 +16414,8 @@ function isValidCommand(value) {
     "warm-up",
     "e2e-eval",
     "routing-ab",
-    "memory-eval"
+    "memory-eval",
+    "health"
   ];
   return validCommands.includes(value);
 }
@@ -16453,6 +16730,10 @@ function registerResearchTools(ctx) {
     ...researchDeps,
     rateLimiter: ctx.rateLimiterFactory.getForTool("research_catalog_review")
   });
+  registerResearchSynthesizeTool(ctx.server, {
+    ...researchDeps,
+    rateLimiter: ctx.rateLimiterFactory.getForTool("research_synthesize")
+  });
 }
 function registerMemoryTools(ctx) {
   const memoryDeps = {
@@ -16736,7 +17017,7 @@ function logFinalEventBusStats(logger17) {
 // src/cli-orchestrator.ts
 import * as readline2 from "readline";
 function runOrchestratorRepl(options, logger17) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -16772,7 +17053,7 @@ function runOrchestratorRepl(options, logger17) {
     });
     rl.on("close", () => {
       logger17.info("Orchestrator REPL closed");
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -17919,7 +18200,7 @@ function initializeFeedbackIntegration(options) {
 
 // src/cli-server-rest.ts
 import * as fs16 from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 import * as crypto3 from "crypto";
 import { homedir as homedir3 } from "os";
 var DEFAULT_REST_CONFIG = {
@@ -17955,12 +18236,12 @@ function extractRestConfig(_config) {
 var AUTH_DIR = "auth";
 var API_KEY_FILE = "rest-api-key";
 function getAuthDir(baseDir) {
-  const home = baseDir ?? path21.join(homedir3(), ".nexus-agents");
-  return path21.join(home, AUTH_DIR);
+  const home = baseDir ?? path22.join(homedir3(), ".nexus-agents");
+  return path22.join(home, AUTH_DIR);
 }
 function loadOrGenerateApiKey(logger17, baseDir) {
   const authDir = getAuthDir(baseDir);
-  const keyPath = path21.join(authDir, API_KEY_FILE);
+  const keyPath = path22.join(authDir, API_KEY_FILE);
   if (fs16.existsSync(keyPath)) {
     const key2 = fs16.readFileSync(keyPath, "utf-8").trim();
     if (key2.length > 0) {
@@ -18611,31 +18892,32 @@ async function handleOrchestrateCommand(args) {
   });
   process.exit(exitCode === 0 ? EXIT_CODES.SUCCESS : EXIT_CODES.SERVER_START_FAILED);
 }
-async function handleSweBenchCommand(args) {
-  const subArgs = [];
-  const subcommand = args.positionals[1] ?? "run";
-  subArgs.push(subcommand);
-  if (args.options.variant !== void 0) {
-    subArgs.push(`--variant=${args.options.variant}`);
-  }
-  if (args.options.limit !== void 0) {
-    subArgs.push(`--limit=${String(args.options.limit)}`);
-  }
-  if (args.options.output !== void 0) {
-    subArgs.push(`--output=${args.options.output}`);
-  }
-  if (args.options.resume) {
-    subArgs.push("--resume");
-  }
-  if (args.options.verbose) {
-    subArgs.push("--verbose");
-  }
-  if (args.options.instance !== void 0) {
-    for (const inst of args.options.instance) {
-      subArgs.push(`--instance=${inst}`);
-    }
+function buildSweBenchSubArgs(args) {
+  const opts = args.options;
+  const subArgs = [args.positionals[1] ?? "run"];
+  const valueFlags = [
+    ["variant", "variant"],
+    ["limit", "limit"],
+    ["output", "output"],
+    ["concurrency", "concurrency"],
+    ["predictions", "predictions"],
+    ["cacheLevel", "cache-level"],
+    ["maxWorkers", "max-workers"],
+    ["runId", "run-id"],
+    ["outputDir", "output-dir"]
+  ];
+  for (const [key, flag] of valueFlags) {
+    const val = opts[key];
+    if (val !== void 0) subArgs.push(`--${flag}=${String(val)}`);
   }
-  const exitCode = await sweBenchCommand(subArgs);
+  if (opts.resume) subArgs.push("--resume");
+  if (opts.verbose) subArgs.push("--verbose");
+  if (opts.mcp === true) subArgs.push("--mcp");
+  for (const inst of opts.instance ?? []) subArgs.push(`--instance=${inst}`);
+  return subArgs;
+}
+async function handleSweBenchCommand(args) {
+  const exitCode = await sweBenchCommand(buildSweBenchSubArgs(args));
   process.exit(exitCode === 0 ? EXIT_CODES.SUCCESS : EXIT_CODES.SERVER_START_FAILED);
 }
 
@@ -18827,7 +19109,7 @@ async function handleVerifyCommand(args) {
 async function handleDoctorCommand(args) {
   const exitCode = await doctorCommand({ fix: args.options.fix });
   if (args.options.deep) {
-    const { runDeepDiagnostics: runDeepDiagnostics2, formatDeepDiagnostics: formatDeepDiagnostics2 } = await import("./doctor-deep-I2J5CRFG.js");
+    const { runDeepDiagnostics: runDeepDiagnostics2, formatDeepDiagnostics: formatDeepDiagnostics2 } = await import("./doctor-deep-BDE2PHVX.js");
     const diag = runDeepDiagnostics2();
     process.stdout.write(formatDeepDiagnostics2(diag) + "\n");
   }
@@ -19079,13 +19361,13 @@ function handleScaffoldCommand(args) {
 
 // src/cli/visualize-summary.ts
 import * as fs17 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 import { fileURLToPath } from "url";
 function findPackageRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 5; i++) {
-    if (fs17.existsSync(path22.join(dir, "package.json"))) return dir;
-    const parent = path22.dirname(dir);
+    if (fs17.existsSync(path23.join(dir, "package.json"))) return dir;
+    const parent = path23.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -19096,7 +19378,7 @@ function countFiles(dir, pattern) {
   let count = 0;
   for (const entry of fs17.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
-      count += countFiles(path22.join(dir, entry.name), pattern);
+      count += countFiles(path23.join(dir, entry.name), pattern);
     } else if (entry.isFile() && pattern.test(entry.name)) {
       count++;
     }
@@ -19105,7 +19387,7 @@ function countFiles(dir, pattern) {
 }
 function readVersion(pkgRoot) {
   try {
-    const raw = fs17.readFileSync(path22.join(pkgRoot, "package.json"), "utf-8");
+    const raw = fs17.readFileSync(path23.join(pkgRoot, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return pkg.version ?? "unknown";
   } catch {
@@ -19126,13 +19408,13 @@ var LAYER_DIRS = [
 ];
 function gatherSystemSummary() {
   const thisFile = fileURLToPath(import.meta.url);
-  const pkgRoot = findPackageRoot(path22.dirname(thisFile));
-  const srcDir = path22.resolve(pkgRoot, "src");
+  const pkgRoot = findPackageRoot(path23.dirname(thisFile));
+  const srcDir = path23.resolve(pkgRoot, "src");
   const allTs = countFiles(srcDir, /\.ts$/);
   const testTs = countFiles(srcDir, /\.test\.ts$/);
   const layers = LAYER_DIRS.map(({ name, dir }) => ({
     name,
-    files: countFiles(path22.join(srcDir, dir), /\.ts$/)
+    files: countFiles(path23.join(srcDir, dir), /\.ts$/)
   })).filter((l) => l.files > 0);
   return {
     version: readVersion(pkgRoot),
@@ -20281,7 +20563,7 @@ function handleStatusCommand2(args) {
 
 // src/cli/scenario-command.ts
 import { readdir as readdir4 } from "fs/promises";
-import { join as join19, resolve as resolve10 } from "path";
+import { join as join19, resolve as resolve11 } from "path";
 
 // src/testing/e2e/scenario-runner.ts
 import { readFile as readFile6 } from "fs/promises";
@@ -20412,9 +20694,9 @@ function checkCircularDependencies(workflow) {
   for (const step of workflow.steps) {
     stepMap.set(step.id, step);
   }
-  const visit = (stepId, path23) => {
+  const visit = (stepId, path24) => {
     if (visiting.has(stepId)) {
-      errors.push(`Circular dependency detected: ${[...path23, stepId].join(" -> ")}`);
+      errors.push(`Circular dependency detected: ${[...path24, stepId].join(" -> ")}`);
       return false;
     }
     if (visited.has(stepId)) return true;
@@ -20422,7 +20704,7 @@ function checkCircularDependencies(workflow) {
     const step = stepMap.get(stepId);
     if (step?.dependsOn) {
       for (const dep of step.dependsOn) {
-        if (!visit(dep, [...path23, stepId])) {
+        if (!visit(dep, [...path24, stepId])) {
           return false;
         }
       }
@@ -20441,7 +20723,7 @@ function checkCircularDependencies(workflow) {
 var defaultStubFactory = {
   createAgentStub(agentType, action) {
     return async (inputs) => {
-      await new Promise((resolve11) => setTimeout(resolve11, 10));
+      await new Promise((resolve12) => setTimeout(resolve12, 10));
       return {
         stepId: `${agentType}-${action}`,
         status: "success",
@@ -20466,8 +20748,8 @@ var ScenarioRunner = class {
   /**
    * Load a scenario fixture from a YAML file.
    */
-  async loadFixture(path23) {
-    const content = await readFile6(path23, "utf-8");
+  async loadFixture(path24) {
+    const content = await readFile6(path24, "utf-8");
     const data = yaml7.parse(content);
     return ScenarioFixtureSchema.parse(data);
   }
@@ -20600,7 +20882,7 @@ function createScenarioRunner(stubFactory) {
 }
 
 // src/cli/scenario-command.ts
-var FIXTURES_DIR = resolve10(import.meta.dirname, "../testing/e2e/fixtures");
+var FIXTURES_DIR = resolve11(import.meta.dirname, "../testing/e2e/fixtures");
 var SCENARIO_SUFFIX = ".scenario.yaml";
 async function listScenarios() {
   try {
@@ -20681,6 +20963,137 @@ async function handleScenarioCommand(args) {
   process.exit(EXIT_CODES.SERVER_START_FAILED);
 }
 
+// src/cli/health-command.ts
+function collectHealth() {
+  const report = generateWeatherReport({});
+  return {
+    swarmHealth: report.swarmHealth,
+    overallSuccessRate: report.overall.successRate,
+    totalTasks: report.overall.totalTasks,
+    failureBreakdown: report.failureBreakdown ?? [],
+    cliCount: report.cliWeather.length,
+    cliHealth: report.cliWeather.map(toCliSummary),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function toCliSummary(cw) {
+  return {
+    cli: cw.cli,
+    successRate: cw.successRate,
+    totalTasks: cw.totalTasks,
+    avgDurationMs: cw.avgDurationMs
+  };
+}
+function renderMetricBar(value, max) {
+  const width = 20;
+  const filled = Math.round(value / max * width);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+  return bar;
+}
+function renderSwarmMetrics(w, health) {
+  const c = colors;
+  const pct = (v) => `${(v * 100).toFixed(1)}%`;
+  w(`  ${c.bold}Swarm Health Metrics${c.reset}
+`);
+  w(
+    `  Agent Utilization:       ${renderMetricBar(health.agentUtilization, 1)} ${pct(health.agentUtilization)}
+`
+  );
+  w(
+    `  Collaboration Efficiency:${renderMetricBar(health.collaborationEfficiency, 1)} ${pct(health.collaborationEfficiency)}
+`
+  );
+  w(
+    `  Routing Accuracy:        ${renderMetricBar(health.routingAccuracy, 1)} ${pct(health.routingAccuracy)}
+`
+  );
+  w(`  Weekly Regret:           ${health.weeklyRegret.toFixed(3)}
+`);
+  w(`  Adaptation Speed:        ${String(health.adaptationSpeed)} tasks
+`);
+  w(`  Observed Categories:     ${String(health.observedCategories)}
+`);
+  w(`  Observed Roles:          ${String(health.observedRoles)}
+`);
+  w("\n");
+}
+function renderCliHealth(w, entries) {
+  const c = colors;
+  w(`  ${c.bold}Per-CLI Performance${c.reset}
+`);
+  for (const entry of entries) {
+    const rateColor = entry.successRate >= 0.8 ? c.green : entry.successRate >= 0.6 ? c.yellow : c.red;
+    const pct = `${(entry.successRate * 100).toFixed(0)}%`;
+    const dur = entry.avgDurationMs >= 1e3 ? `${(entry.avgDurationMs / 1e3).toFixed(1)}s` : `${String(Math.round(entry.avgDurationMs))}ms`;
+    w(
+      `  ${entry.cli.padEnd(12)} ${rateColor}${pct.padStart(4)}${c.reset}  ${String(entry.totalTasks).padStart(5)} tasks  ${c.dim}avg ${dur}${c.reset}
+`
+    );
+  }
+  w("\n");
+}
+function renderFailureBreakdown(w, entries) {
+  const c = colors;
+  if (entries.length === 0) {
+    w(`  ${c.green}No failures recorded${c.reset}
+
+`);
+    return;
+  }
+  w(`  ${c.bold}Failure Breakdown${c.reset}
+`);
+  for (const entry of entries) {
+    const color2 = entry.category === "unknown" ? c.yellow : c.dim;
+    w(
+      `  ${color2}${entry.category.padEnd(22)}${c.reset} ${String(entry.count).padStart(4)}  (${String(entry.percentage)}%)
+`
+    );
+  }
+  w("\n");
+}
+function renderTable2(health) {
+  const c = colors;
+  const s = symbols;
+  const w = process.stdout.write.bind(process.stdout);
+  w(`
+${c.bold}nexus-agents${c.reset}`);
+  w(` ${c.dim}\u2014 Swarm Health Dashboard${c.reset}
+
+`);
+  const rateColor = health.overallSuccessRate >= 0.8 ? c.green : health.overallSuccessRate >= 0.6 ? c.yellow : c.red;
+  const rateSym = health.overallSuccessRate >= 0.8 ? s.check : s.warn;
+  const pctStr = `${(health.overallSuccessRate * 100).toFixed(1)}%`;
+  w(`  Success Rate:  ${rateColor}${pctStr}${c.reset}  ${rateSym}
+`);
+  w(`  Total Tasks:   ${c.cyan}${String(health.totalTasks)}${c.reset}
+`);
+  w(`  Active CLIs:   ${c.cyan}${String(health.cliCount)}${c.reset}
+
+`);
+  if (health.cliHealth.length > 0) {
+    renderCliHealth(w, health.cliHealth);
+  }
+  if (health.swarmHealth !== void 0) {
+    renderSwarmMetrics(w, health.swarmHealth);
+  } else {
+    w(`  ${c.dim}No swarm metrics available (requires task history)${c.reset}
+
+`);
+  }
+  renderFailureBreakdown(w, health.failureBreakdown);
+}
+function renderJson2(health) {
+  process.stdout.write(JSON.stringify(health, null, 2) + "\n");
+}
+function handleHealthCommand(args) {
+  const health = collectHealth();
+  if (args.options.format === "json") {
+    renderJson2(health);
+  } else {
+    renderTable2(health);
+  }
+}
+
 // src/cli-commands.ts
 function printHelp() {
   process.stdout.write(HELP_TEXT + "\n");
@@ -20714,7 +21127,9 @@ var SYNC_COMMAND_HANDLERS = {
   "warm-up": handleWarmUpCommand,
   "e2e-eval": handleE2EEvalCommand,
   "routing-ab": handleRoutingABCommand,
-  "memory-eval": handleMemoryEvalCommand
+  "memory-eval": handleMemoryEvalCommand,
+  // Issue #1403: Health Command
+  health: handleHealthCommand
 };
 function handleSyncCommand(args) {
   if (args.command === "help") {
@@ -20769,6 +21184,7 @@ async function handleAsyncCommand(args) {
   }
 }
 async function dispatchCommand(args) {
+  initDataDirectories();
   if (!handleSyncCommand(args)) {
     await handleAsyncCommand(args);
   }
@@ -21051,16 +21467,28 @@ function parseSweBenchVariant(value) {
   }
   return void 0;
 }
+var SWE_BENCH_STRING_MAPPINGS = [
+  ["predictions", "predictions"],
+  ["cache-level", "cacheLevel"],
+  ["max-workers", "maxWorkers"],
+  ["run-id", "runId"],
+  ["output-dir", "outputDir"]
+];
 function buildSweBenchOptions(values) {
   const variant = parseSweBenchVariant(values.variant);
   const limit = parseNumericOption(values.limit);
-  const base = {
-    resume: values.resume
-  };
+  const concurrency = parseNumericOption(values.concurrency);
+  const base = { resume: values.resume };
   if (variant !== void 0) base.variant = variant;
   if (limit !== void 0) base.limit = limit;
+  if (concurrency !== void 0) base.concurrency = concurrency;
+  if (values.mcp) base.mcp = true;
+  for (const [src, tgt] of SWE_BENCH_STRING_MAPPINGS) {
+    const val = values[src];
+    if (val !== void 0) base[tgt] = val;
+  }
   if (values.instance !== void 0 && values.instance.length > 0) {
-    return { ...base, instance: values.instance };
+    base.instance = values.instance;
   }
   return base;
 }