nexus-agents 2.83.1 → 2.85.0

package/dist/{chunk-ODKIRXN7.js → chunk-IF6TXCSE.js}

@@ -4,21 +4,21 @@ import {
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-JA6ON2RP.js";
+} from "./chunk-6QKMUPDP.js";
 import {
   CUSTOM_API_BASE_URL_ENV,
   PROVIDER_ENV_KEYS,
   validateCustomApiBaseUrl
-} from "./chunk-6XRNFLPI.js";
+} from "./chunk-POTGGTJD.js";
 import {
   getToolMemory
-} from "./chunk-7V367KT4.js";
+} from "./chunk-4SU4Q37U.js";
 import {
   getDefaultAvailableModelsCache
-} from "./chunk-VXIHHHLQ.js";
+} from "./chunk-FOG7PMGM.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-DWOSFYI2.js";
+} from "./chunk-25AQZKMN.js";
 import {
   createCliAdapter,
   createCliDetectionCache,
@@ -27,7 +27,7 @@ import {
   isCliAvailable,
   sanitizeOutput,
   withTimeout
-} from "./chunk-ELRNVADA.js";
+} from "./chunk-RTAIMK6P.js";
 import {
   AgentError,
   CACHE_TIMEOUTS,
@@ -70,47 +70,48 @@ import {
   resolveCliAlias,
   resolveVoteTimeout,
   toRateLimitError
-} from "./chunk-6UI4NKT4.js";
+} from "./chunk-YLMB5MFQ.js";
 import {
   ensureLearningDir,
   getNexusDataDir,
   getOutcomesFile,
-  nexusDataPath
-} from "./chunk-I2HMWH4R.js";
+  nexusDataPath,
+  nexusDataPathEnsure
+} from "./chunk-2WCYG75B.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 
 // src/mcp/mcp-notifier.ts
 import { AsyncLocalStorage } from "async_hooks";
 var internalLogger = createLogger({ component: "mcp-notifier" });
 function createMcpNotifier(server) {
-  function send(level, logger8, data) {
+  function send(level, logger11, data) {
     try {
-      server.sendLoggingMessage({ level, logger: logger8, data }).catch((error) => {
+      server.sendLoggingMessage({ level, logger: logger11, data }).catch((error) => {
         internalLogger.debug("Failed to send MCP notification", {
           level,
-          logger: logger8,
+          logger: logger11,
           error: getErrorMessage(error)
         });
       });
     } catch (error) {
       internalLogger.debug("Failed to send MCP notification", {
         level,
-        logger: logger8,
+        logger: logger11,
         error: getErrorMessage(error)
       });
     }
   }
   return {
-    info: (logger8, data) => {
-      send("info", logger8, data);
+    info: (logger11, data) => {
+      send("info", logger11, data);
     },
-    debug: (logger8, data) => {
-      send("debug", logger8, data);
+    debug: (logger11, data) => {
+      send("debug", logger11, data);
     },
-    warn: (logger8, data) => {
-      send("warning", logger8, data);
+    warn: (logger11, data) => {
+      send("warning", logger11, data);
     }
   };
 }
@@ -240,7 +241,7 @@ var RateLimiter = class {
     this.logger.debug("Rate limiter reset", { tokens: this.tokens });
   }
 };
-function createDefaultRateLimiter(name, logger8) {
+function createDefaultRateLimiter(name, logger11) {
   const config = {
     capacity: 100,
     refillRate: 10,
@@ -249,8 +250,8 @@ function createDefaultRateLimiter(name, logger8) {
   if (name !== void 0) {
     config.name = name;
   }
-  if (logger8 !== void 0) {
-    config.logger = logger8;
+  if (logger11 !== void 0) {
+    config.logger = logger11;
   }
   return new RateLimiter(config);
 }
@@ -888,6 +889,10 @@ var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
   "weather_report",
   "query_trace",
   "query_task_state",
+  // Async-mode result polling (#3042 / epic #2631)
+  "get_job_result",
+  // Async-mode job discovery (#3046 / epic #2631 Stage 5)
+  "list_jobs",
   // Codebase intelligence (read-only over local files)
   "search_codebase",
   "extract_symbols",
@@ -1235,13 +1240,13 @@ function buildMiddlewareStack(config) {
   return middlewares;
 }
 function createMiddlewareChain(config) {
-  const logger8 = config.logger ?? createLogger({ tool: config.toolName });
+  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
   const middlewares = buildMiddlewareStack(config);
   const composed = composeMiddleware(middlewares);
   return (handler) => {
     return async (args) => {
       const requestContext = createRequestContext({ toolName: config.toolName });
-      const requestLogger = logger8.child(contextForLogging(requestContext));
+      const requestLogger = logger11.child(contextForLogging(requestContext));
       const ctx = { requestContext, logger: requestLogger };
       return composed(args, ctx, (finalArgs, finalCtx) => handler(finalArgs, finalCtx));
     };
@@ -1428,8 +1433,8 @@ async function runMismatchedCall(ctx) {
     throw err2;
   }
 }
-function toSdkCallbackWithBudgetCheck(handler, toolName, configuredTimeoutMs, logger8) {
-  const log = logger8 ?? wrapperLogger;
+function toSdkCallbackWithBudgetCheck(handler, toolName, configuredTimeoutMs, logger11) {
+  const log = logger11 ?? wrapperLogger;
   return (args, extra) => {
     const progressCtx = extractProgressContext(extra);
     const signal = extra?.signal;
@@ -1553,15 +1558,15 @@ function sanitizeToolInput(args) {
     detectedPatterns: uniquePatterns
   };
 }
-function logSanitizationResult(result, logger8, toolName) {
+function logSanitizationResult(result, logger11, toolName) {
   if (result.wasModified) {
-    logger8.warn("Tool input sanitized \u2014 XML injection tags stripped", {
+    logger11.warn("Tool input sanitized \u2014 XML injection tags stripped", {
       tool: toolName,
       modifiedFields: result.modifiedCount
     });
   }
   if (result.detectedPatterns.length > 0) {
-    logger8.warn("Injection patterns detected in tool input", {
+    logger11.warn("Injection patterns detected in tool input", {
       tool: toolName,
       patterns: result.detectedPatterns
     });
@@ -1601,11 +1606,11 @@ var SECRET_PATTERNS = [
   // password= or token= in output
   /(?:password|token|secret|apikey|api_key)\s*[=:]\s*\S{8,}/i
 ];
-function sanitizeOutput2(text, logger8) {
+function sanitizeOutput2(text, logger11) {
   let sanitized = text;
   for (const pattern of SECRET_PATTERNS) {
     if (pattern.test(sanitized)) {
-      logger8.warn("Potential secret detected in tool output, redacting", {
+      logger11.warn("Potential secret detected in tool output, redacting", {
         pattern: pattern.source.slice(0, 30)
       });
       sanitized = sanitized.replace(pattern, "[REDACTED]");
@@ -1613,25 +1618,25 @@ function sanitizeOutput2(text, logger8) {
   }
   return sanitized;
 }
-function sanitizeToolResult(result, logger8) {
+function sanitizeToolResult(result, logger11) {
   for (const item of result.content) {
-    item.text = sanitizeOutput2(item.text, logger8);
+    item.text = sanitizeOutput2(item.text, logger11);
   }
 }
-function checkInputSize(args, logger8, requestId) {
+function checkInputSize(args, logger11, requestId) {
   if (args === void 0) return null;
   const inputSize = JSON.stringify(args).length;
   if (inputSize > MAX_INPUT_SIZE_BYTES) {
-    logger8.warn("Input size exceeds limit", { inputSize, limit: MAX_INPUT_SIZE_BYTES });
+    logger11.warn("Input size exceeds limit", { inputSize, limit: MAX_INPUT_SIZE_BYTES });
     return internalError("Input too large", requestId);
   }
   return null;
 }
-function checkRateLimit(rateLimiter, logger8) {
+function checkRateLimit(rateLimiter, logger11) {
   const acquired = rateLimiter.tryAcquire();
   if (!acquired) {
     const state = rateLimiter.getState();
-    logger8.warn("Rate limit exceeded");
+    logger11.warn("Rate limit exceeded");
     return rateLimitError(state.nextTokenMs);
   }
   return null;
@@ -1652,14 +1657,14 @@ function checkPolicy(opts) {
   opts.logger.debug("Policy check passed", { reason: decision.reason });
   return null;
 }
-async function executeHandler(handler, args, ctx, logger8) {
+async function executeHandler(handler, args, ctx, logger11) {
   const startTime = getTimeProvider().now();
   const result = handler.length >= 2 ? await handler(args, ctx) : await handler(args);
   const durationMs = getTimeProvider().now() - startTime;
   if (result.isError === true) {
-    logger8.warn("Tool execution completed with error", { durationMs });
+    logger11.warn("Tool execution completed with error", { durationMs });
   } else {
-    logger8.info("Tool execution completed", { durationMs });
+    logger11.info("Tool execution completed", { durationMs });
   }
   return result;
 }
@@ -1705,12 +1710,12 @@ function emitRateLimitAudit(auditLogger, toolName, ctx) {
     requestId: ctx.requestId
   });
 }
-function checkSecurityTier(config, sanitizeResult, logger8) {
+function checkSecurityTier(config, sanitizeResult, logger11) {
   const tier = config.securityTier ?? "standard";
   if (tier === "standard" || sanitizeResult.detectedPatterns.length === 0) {
     return null;
   }
-  logger8.warn("Input rejected by security tier validation", {
+  logger11.warn("Input rejected by security tier validation", {
     tier,
     patterns: sanitizeResult.detectedPatterns
   });
@@ -1719,16 +1724,16 @@ function checkSecurityTier(config, sanitizeResult, logger8) {
     message: `Input validation failed: detected patterns [${sanitizeResult.detectedPatterns.join(", ")}]. Remove prompt injection patterns and retry.`
   });
 }
-function runPreChecks(config, args, mode, requestContext, logger8) {
-  const sizeResult = checkInputSize(args, logger8, requestContext.requestId);
+function runPreChecks(config, args, mode, requestContext, logger11) {
+  const sizeResult = checkInputSize(args, logger11, requestContext.requestId);
   if (sizeResult) return { error: sizeResult, sanitizedArgs: args };
   const sanitizeResult = sanitizeToolInput(args);
-  logSanitizationResult(sanitizeResult, logger8, config.toolName);
+  logSanitizationResult(sanitizeResult, logger11, config.toolName);
   const sanitizedArgs = sanitizeResult.wasModified ? sanitizeResult.sanitized : args;
-  const tierError = checkSecurityTier(config, sanitizeResult, logger8);
+  const tierError = checkSecurityTier(config, sanitizeResult, logger11);
   if (tierError !== null) return { error: tierError, sanitizedArgs };
   if (config.rateLimiter) {
-    const rlResult = checkRateLimit(config.rateLimiter, logger8);
+    const rlResult = checkRateLimit(config.rateLimiter, logger11);
     if (rlResult) {
       if (config.auditLogger)
         emitRateLimitAudit(config.auditLogger, config.toolName, requestContext);
@@ -1742,7 +1747,7 @@ function runPreChecks(config, args, mode, requestContext, logger8) {
       args: sanitizedArgs,
       mode,
       allowedPaths: config.allowedPaths,
-      logger: logger8,
+      logger: logger11,
       requestId: requestContext.requestId
     });
     if (pResult) {
@@ -1754,7 +1759,7 @@ function runPreChecks(config, args, mode, requestContext, logger8) {
   return { error: null, sanitizedArgs };
 }
 function createSecureHandler(handler, config) {
-  const logger8 = config.logger ?? createLogger({ tool: config.toolName });
+  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
   const mode = config.executionMode ?? "read-only";
   return async (args) => {
     const ctxOpts = {
@@ -1762,7 +1767,7 @@ function createSecureHandler(handler, config) {
       ...config.callerInfo && { caller: config.callerInfo }
     };
     const requestContext = createRequestContext(ctxOpts);
-    const requestLogger = logger8.child(contextForLogging(requestContext));
+    const requestLogger = logger11.child(contextForLogging(requestContext));
     requestLogger.info("Tool invocation started");
     const { error: preCheckError, sanitizedArgs } = runPreChecks(
       config,
@@ -2225,7 +2230,7 @@ var ClaudeAdapter = class extends BaseAdapter {
    */
   async executeCompletion(request) {
     const params = this.buildRequestParams(request);
-    const response = await this.client.messages.create(params);
+    const response = request.signal !== void 0 ? await this.client.messages.create(params, { signal: request.signal }) : await this.client.messages.create(params);
     return this.mapResponse(response);
   }
   /**
@@ -2360,10 +2365,10 @@ var ClaudeAdapter = class extends BaseAdapter {
       return this.modelsCache.value;
     }
     if (this.modelsInFlight !== null) return this.modelsInFlight;
-    const inFlight = this.fetchModels();
-    this.modelsInFlight = inFlight;
+    const inFlight2 = this.fetchModels();
+    this.modelsInFlight = inFlight2;
     try {
-      const value = await inFlight;
+      const value = await inFlight2;
       this.modelsCache = { value, fetchedAt: Date.now() };
       return value;
     } finally {
@@ -2463,13 +2468,13 @@ var SdkAdapter = class extends BaseAdapter {
   customBaseUrl;
   /** Inflight init promise for coalescing concurrent calls (Issue #1438). */
   initPromise;
-  constructor(config, logger8) {
+  constructor(config, logger11) {
     const apiKey = resolveApiKey(config.providerId, config.apiKey);
     super({
       providerId: `sdk-${config.providerId}`,
       modelId: config.modelId,
       capabilities: [ModelCapability.COMPLETION, ModelCapability.STREAMING],
-      logger: logger8 ?? createLogger({ adapter: `sdk-${config.providerId}` }),
+      logger: logger11 ?? createLogger({ adapter: `sdk-${config.providerId}` }),
       ...apiKey !== void 0 ? { apiKey } : {},
       ...config.timeout !== void 0 ? { timeout: config.timeout } : {},
       ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {}
@@ -2649,19 +2654,19 @@ var SdkAdapter = class extends BaseAdapter {
 
 // src/adapters/auto-adapter.ts
 var defaultLogger = createLogger({ component: "auto-adapter" });
-function resolveCache(config, logger8) {
+function resolveCache(config, logger11) {
   if (config.cache !== void 0) {
     return config.cache;
   }
   const enableCache = config.enableCache ?? true;
-  return enableCache ? createCliDetectionCache({ logger: logger8 }) : void 0;
+  return enableCache ? createCliDetectionCache({ logger: logger11 }) : void 0;
 }
-async function tryCliAdapter(config, logger8, cache) {
+async function tryCliAdapter(config, logger11, cache) {
   const preferredCli = config.preferredCli;
   const bridgeConfig = config.defaultCliTimeoutMs !== void 0 ? { defaultTimeoutMs: config.defaultCliTimeoutMs } : void 0;
   if (preferredCli !== void 0 && await isCliAvailable(preferredCli, cache)) {
-    logger8.info("Using preferred CLI", { cli: preferredCli });
-    const cliAdapter2 = createCliAdapter({ cli: preferredCli, logger: logger8 });
+    logger11.info("Using preferred CLI", { cli: preferredCli });
+    const cliAdapter2 = createCliAdapter({ cli: preferredCli, logger: logger11 });
     await cliAdapter2.initialize();
     return {
       adapter: createCliToModelAdapter(cliAdapter2, bridgeConfig),
@@ -2673,15 +2678,15 @@ async function tryCliAdapter(config, logger8, cache) {
   }
   const availableClis = await getAvailableClis(cache);
   if (availableClis.length === 0) {
-    logger8.info("No CLI adapters available");
+    logger11.info("No CLI adapters available");
     return null;
   }
   const selectedCli = availableClis[0];
   if (selectedCli === void 0) {
     return null;
   }
-  logger8.info("Auto-selected CLI", { cli: selectedCli, available: availableClis });
-  const cliAdapter = createCliAdapter({ cli: selectedCli, logger: logger8 });
+  logger11.info("Auto-selected CLI", { cli: selectedCli, available: availableClis });
+  const cliAdapter = createCliAdapter({ cli: selectedCli, logger: logger11 });
   await cliAdapter.initialize();
   return {
     adapter: createCliToModelAdapter(cliAdapter, bridgeConfig),
@@ -2695,13 +2700,13 @@ function resolveApiKeyFromEnv(configKey, envVar) {
   const key = configKey ?? process.env[envVar];
   return key !== void 0 && key.length > 0 ? key : void 0;
 }
-function tryApiAdapter(config, logger8) {
+function tryApiAdapter(config, logger11) {
   const claudeModelId = getCliModelName(getDefaultModelForCli("claude"));
   const codexModelId = getCliModelName(getDefaultModelForCli("codex"));
   const geminiModelId = getCliModelName(getDefaultModelForCli("gemini"));
   const anthropicKey = resolveApiKeyFromEnv(config.anthropicApiKey, "ANTHROPIC_API_KEY");
   if (anthropicKey !== void 0) {
-    logger8.info("Using Anthropic API adapter", { model: claudeModelId });
+    logger11.info("Using Anthropic API adapter", { model: claudeModelId });
     return {
       adapter: createClaudeAdapter({ modelId: claudeModelId, apiKey: anthropicKey }),
       source: "api",
@@ -2711,7 +2716,7 @@ function tryApiAdapter(config, logger8) {
   }
   const openaiKey = resolveApiKeyFromEnv(config.openaiApiKey, "OPENAI_API_KEY");
   if (openaiKey !== void 0) {
-    logger8.info("Using OpenAI API adapter (AI SDK)", { model: codexModelId });
+    logger11.info("Using OpenAI API adapter (AI SDK)", { model: codexModelId });
     return {
       adapter: new SdkAdapter({ providerId: "openai", modelId: codexModelId, apiKey: openaiKey }),
       source: "api",
@@ -2721,7 +2726,7 @@ function tryApiAdapter(config, logger8) {
   }
   const googleKey = resolveApiKeyFromEnv(config.googleApiKey, "GOOGLE_AI_API_KEY");
   if (googleKey !== void 0) {
-    logger8.info("Using Google AI API adapter (AI SDK)", { model: geminiModelId });
+    logger11.info("Using Google AI API adapter (AI SDK)", { model: geminiModelId });
     return {
       adapter: new SdkAdapter({
         providerId: "google",
@@ -2733,19 +2738,19 @@ function tryApiAdapter(config, logger8) {
       reason: `Using Google AI API via AI SDK (model: ${geminiModelId})`
     };
   }
-  const custom = tryCustomOpenAiAdapter(logger8);
+  const custom = tryCustomOpenAiAdapter(logger11);
   if (custom !== null) return custom;
-  logger8.info("No API keys available for any provider");
+  logger11.info("No API keys available for any provider");
   return null;
 }
-function tryCustomOpenAiAdapter(logger8) {
+function tryCustomOpenAiAdapter(logger11) {
   const customKey = resolveApiKeyFromEnv(void 0, "NEXUS_CUSTOM_API_KEY");
   const customBaseUrl = process.env["NEXUS_CUSTOM_API_BASE_URL"];
   if (customKey === void 0 || customBaseUrl === void 0 || customBaseUrl === "") {
     return null;
   }
   const customModelId = process.env["NEXUS_CUSTOM_MODEL"] ?? CUSTOM_API_DEFAULT_MODEL;
-  logger8.info("Using custom-openai SDK adapter", {
+  logger11.info("Using custom-openai SDK adapter", {
     model: customModelId,
     baseUrl: customBaseUrl
   });
@@ -2761,52 +2766,52 @@ function tryCustomOpenAiAdapter(logger8) {
     reason: `Using custom OpenAI-compatible gateway at ${customBaseUrl} (model: ${customModelId})`
   };
 }
-async function selectCliFirst(config, logger8, cache) {
-  const cliResult = await tryCliAdapter(config, logger8, cache);
+async function selectCliFirst(config, logger11, cache) {
+  const cliResult = await tryCliAdapter(config, logger11, cache);
   if (cliResult !== null) return cliResult;
-  const apiResult = tryApiAdapter(config, logger8);
+  const apiResult = tryApiAdapter(config, logger11);
   if (apiResult !== null) return apiResult;
   throw new Error(
     "No adapters available. Install a CLI (claude/gemini/codex) or set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_API_KEY."
   );
 }
-async function selectApiFirst(config, logger8, cache) {
-  const apiResult = tryApiAdapter(config, logger8);
+async function selectApiFirst(config, logger11, cache) {
+  const apiResult = tryApiAdapter(config, logger11);
   if (apiResult !== null) return apiResult;
-  const cliResult = await tryCliAdapter(config, logger8, cache);
+  const cliResult = await tryCliAdapter(config, logger11, cache);
   if (cliResult !== null) return cliResult;
   throw new Error(
     "No adapters available. Set ANTHROPIC_API_KEY/OPENAI_API_KEY/GOOGLE_AI_API_KEY or install a CLI (claude/gemini/codex)."
   );
 }
-async function selectCliOnly(config, logger8, cache) {
-  const cliResult = await tryCliAdapter(config, logger8, cache);
+async function selectCliOnly(config, logger11, cache) {
+  const cliResult = await tryCliAdapter(config, logger11, cache);
   if (cliResult !== null) return cliResult;
   throw new Error(
     "No CLI adapters available. Install and authenticate claude, gemini, or codex CLI."
   );
 }
-function selectApiOnly(config, logger8) {
-  const apiResult = tryApiAdapter(config, logger8);
+function selectApiOnly(config, logger11) {
+  const apiResult = tryApiAdapter(config, logger11);
   if (apiResult !== null) return apiResult;
   throw new Error(
     "No API key available. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_API_KEY."
   );
 }
 async function createAutoAdapter(config = {}) {
-  const logger8 = config.logger ?? defaultLogger;
+  const logger11 = config.logger ?? defaultLogger;
   const priority = config.priority ?? "cli-first";
-  const cache = resolveCache(config, logger8);
-  logger8.info("Auto-selecting adapter", { priority, cacheEnabled: cache !== void 0 });
+  const cache = resolveCache(config, logger11);
+  logger11.info("Auto-selecting adapter", { priority, cacheEnabled: cache !== void 0 });
   switch (priority) {
     case "cli-first":
-      return selectCliFirst(config, logger8, cache);
+      return selectCliFirst(config, logger11, cache);
     case "api-first":
-      return selectApiFirst(config, logger8, cache);
+      return selectApiFirst(config, logger11, cache);
     case "cli-only":
-      return selectCliOnly(config, logger8, cache);
+      return selectCliOnly(config, logger11, cache);
     case "api-only":
-      return selectApiOnly(config, logger8);
+      return selectApiOnly(config, logger11);
     default: {
       const exhaustive = priority;
       throw new Error(`Unknown priority: ${String(exhaustive)}`);
@@ -4402,21 +4407,21 @@ async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
   }
 }
 async function executeWithRetries(opts) {
-  const { role, proposal, adapter, logger: logger8, timeoutMs, maxRetries } = opts;
+  const { role, proposal, adapter, logger: logger11, timeoutMs, maxRetries } = opts;
   let lastError = "";
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0) {
       const isRateLimit = isRateLimitError(lastError);
       const baseDelay = isRateLimit ? RATE_LIMIT_RETRY_DELAY_MS : INITIAL_RETRY_DELAY_MS;
       const delayMs = baseDelay * Math.pow(2, attempt - 1);
-      logger8.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
+      logger11.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
       await delay(delayMs);
     }
     const attemptStart = Date.now();
     const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs);
     const attemptMs = Date.now() - attemptStart;
     if (result.ok) {
-      logger8.info("Vote attempt timing", {
+      logger11.info("Vote attempt timing", {
         role,
         attempt: attempt + 1,
         attemptMs,
@@ -4426,14 +4431,14 @@ async function executeWithRetries(opts) {
     }
     lastError = result.error;
     const rateLimited = isRateLimitError(lastError);
-    logger8.info("Vote attempt timing", {
+    logger11.info("Vote attempt timing", {
       role,
       attempt: attempt + 1,
       attemptMs,
       succeeded: false,
       rateLimited
     });
-    logger8.warn("Vote attempt failed", {
+    logger11.warn("Vote attempt failed", {
       role,
       attempt: attempt + 1,
       maxRetries: maxRetries + 1,
@@ -4463,7 +4468,7 @@ async function launchVotesWithOverallDeadline(input) {
     proposal,
     roleAdapters,
     fallbackAdapter,
-    logger: logger8,
+    logger: logger11,
     voteOptions,
     interDelay,
     overallDeadlineMs,
@@ -4475,12 +4480,12 @@ async function launchVotesWithOverallDeadline(input) {
     const adapter = roleAdapters.get(role) ?? fallbackAdapter;
     const elapsed = Date.now() - startedAt;
     const remaining = Math.max(1, overallDeadlineMs - elapsed);
-    return raceWithDeadline(voteFn(role, proposal, adapter, logger8, voteOptions), role, remaining);
+    return raceWithDeadline(voteFn(role, proposal, adapter, logger11, voteOptions), role, remaining);
   });
   const results = await Promise.all(wrapped);
   const expired = results.filter((r) => r.source === "error" && r.error === DEADLINE_MESSAGE);
   if (expired.length > 0) {
-    logger8.warn("Consensus overall deadline reached; returning partial results", {
+    logger11.warn("Consensus overall deadline reached; returning partial results", {
       totalRoles: roles.length,
       expiredRoles: expired.map((r) => r.role),
       overallDeadlineMs
@@ -4497,32 +4502,32 @@ function computeOverallConsensusDeadlineMs(timeoutMs, maxRetries, roleCount, int
 }
 var DEFAULT_INTER_AGENT_DELAY_MS = 2e3;
 var defaultLogger2 = createLogger({ component: "voter-agents" });
-async function executeAgentVote(role, proposal, adapter, logger8, options) {
+async function executeAgentVote(role, proposal, adapter, logger11, options) {
   const start = getTimeProvider().now();
   const timeoutMs = options?.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options?.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   const allowSimulation = options?.allowSimulation ?? false;
-  logger8.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
+  logger11.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
   const result = await executeWithRetries({
     role,
     proposal,
     adapter,
-    logger: logger8,
+    logger: logger11,
     timeoutMs,
     maxRetries
   });
   const processingTimeMs = getTimeProvider().now() - start;
   if (result.ok) {
-    logger8.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
+    logger11.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
     return { role, vote: result.vote, processingTimeMs, source: "llm", cli: adapter.providerId };
   }
-  logger8.error("Vote execution failed after all retries", void 0, {
+  logger11.error("Vote execution failed after all retries", void 0, {
     role,
     model: adapter.modelId,
     errorMessage: result.error
   });
   if (allowSimulation) {
-    logger8.warn("Falling back to simulation (allowSimulation=true)", { role });
+    logger11.warn("Falling back to simulation (allowSimulation=true)", { role });
     return createSimulationVoteResult(role, proposal, processingTimeMs, result.error);
   }
   return createErrorVoteResult(role, result.error, processingTimeMs);
@@ -4533,22 +4538,22 @@ var NoAdapterError = class extends Error {
     this.name = "NoAdapterError";
   }
 };
-function resolveAdapter(options, logger8) {
+function resolveAdapter(options, logger11) {
   try {
     if (options.adapter !== void 0) return { adapter: options.adapter };
-    const registry = getGlobalRegistry({ logger: logger8 });
+    const registry = getGlobalRegistry({ logger: logger11 });
     return { adapter: registry.getDefault() };
   } catch (error) {
     return { error: getErrorMessage(error) };
   }
 }
-function warnIfCodexConcurrencyExceeded(roleAdapters, logger8) {
+function warnIfCodexConcurrencyExceeded(roleAdapters, logger11) {
   const codexBound = [...roleAdapters.values()].filter(
     (a) => a.name === "codex"
   ).length;
   const warning = checkCodexConcurrency(codexBound);
   if (warning !== null) {
-    logger8.warn("Codex concurrency limit may be exceeded", { detail: warning });
+    logger11.warn("Codex concurrency limit may be exceeded", { detail: warning });
   }
 }
 function assignUniformAdapter(roles, adapter) {
@@ -4556,29 +4561,29 @@ function assignUniformAdapter(roles, adapter) {
   for (const role of roles) adapters.set(role, adapter);
   return adapters;
 }
-function createCliAdapterMap(clis, logger8) {
-  const registry = getGlobalRegistry({ logger: logger8 });
+function createCliAdapterMap(clis, logger11) {
+  const registry = getGlobalRegistry({ logger: logger11 });
   const result = /* @__PURE__ */ new Map();
   for (const cli of clis) {
     result.set(cli, registry.getAdapterForCli(cli));
   }
   return result;
 }
-async function resolveDiverseAdapters(roles, logger8, fallbackAdapter) {
+async function resolveDiverseAdapters(roles, logger11, fallbackAdapter) {
   let availableClis;
   try {
     availableClis = await getAvailableClis();
   } catch (e) {
-    logger8.warn("Failed to resolve available CLIs; falling back to single adapter", {
+    logger11.warn("Failed to resolve available CLIs; falling back to single adapter", {
       error: String(e)
     });
     availableClis = [];
   }
   if (availableClis.length <= 1) {
-    logger8.info("Using single adapter for all roles", { cliCount: availableClis.length });
+    logger11.info("Using single adapter for all roles", { cliCount: availableClis.length });
     return assignUniformAdapter(roles, fallbackAdapter);
   }
-  const cliAdapters = createCliAdapterMap(availableClis, logger8);
+  const cliAdapters = createCliAdapterMap(availableClis, logger11);
   if (cliAdapters.size <= 1) return assignUniformAdapter(roles, fallbackAdapter);
   const cliList = [...cliAdapters.entries()];
   const adapters = /* @__PURE__ */ new Map();
@@ -4590,7 +4595,7 @@ async function resolveDiverseAdapters(roles, logger8, fallbackAdapter) {
     adapters.set(role, entry[1]);
     assignments[role] = entry[0];
   }
-  logger8.info("Diverse adapters assigned", {
+  logger11.info("Diverse adapters assigned", {
     cliCount: cliAdapters.size,
     clis: [...cliAdapters.keys()],
     roleAssignments: assignments
@@ -4598,7 +4603,7 @@ async function resolveDiverseAdapters(roles, logger8, fallbackAdapter) {
   return adapters;
 }
 async function launchStaggeredVotes(input) {
-  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger8, voteOptions, interDelay } = input;
+  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger11, voteOptions, interDelay } = input;
   const computedDeadlineMs = computeOverallConsensusDeadlineMs(
     voteOptions.timeoutMs,
     voteOptions.maxRetries,
@@ -4607,7 +4612,7 @@ async function launchStaggeredVotes(input) {
   );
   const overallDeadlineMs = getMcpSafeDeadlineMs(computedDeadlineMs, "consensus_vote");
   if (overallDeadlineMs < computedDeadlineMs) {
-    logger8.debug("Consensus deadline clamped to MCP wrapper timeout", {
+    logger11.debug("Consensus deadline clamped to MCP wrapper timeout", {
       computedDeadlineMs,
       overallDeadlineMs
     });
@@ -4617,7 +4622,7 @@ async function launchStaggeredVotes(input) {
     proposal,
     roleAdapters,
     fallbackAdapter,
-    logger: logger8,
+    logger: logger11,
     voteOptions,
     interDelay,
     overallDeadlineMs,
@@ -4625,27 +4630,27 @@ async function launchStaggeredVotes(input) {
   });
 }
 async function collectRealVotes(options) {
-  const logger8 = options.logger ?? defaultLogger2;
+  const logger11 = options.logger ?? defaultLogger2;
   const { roles, proposal, simulate, allowSimulation } = options;
   const timeoutMs = options.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   if (simulate === true) {
-    logger8.info("Using simulation mode (explicitly requested)");
+    logger11.info("Using simulation mode (explicitly requested)");
     return createSimulatedVotes(roles, proposal);
   }
-  const adapterResult = resolveAdapter(options, logger8);
+  const adapterResult = resolveAdapter(options, logger11);
   if ("error" in adapterResult) {
-    logger8.error("No adapter available for voting", void 0, { error: adapterResult.error });
+    logger11.error("No adapter available for voting", void 0, { error: adapterResult.error });
     if (allowSimulation === true) {
-      logger8.warn("Falling back to simulation (allowSimulation=true)");
+      logger11.warn("Falling back to simulation (allowSimulation=true)");
       return createSimulatedVotes(roles, proposal, "No adapter available");
     }
     throw new NoAdapterError(
       `No adapter available for voting: ${adapterResult.error}. Install a CLI (claude/gemini/codex) or set ANTHROPIC_API_KEY.`
     );
   }
-  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger8, adapterResult.adapter);
-  warnIfCodexConcurrencyExceeded(roleAdapters, logger8);
+  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger11, adapterResult.adapter);
+  warnIfCodexConcurrencyExceeded(roleAdapters, logger11);
   const voteOptions = { timeoutMs, maxRetries, allowSimulation: allowSimulation ?? false };
   const interDelay = options.interAgentDelayMs ?? DEFAULT_INTER_AGENT_DELAY_MS;
   return launchStaggeredVotes({
@@ -4653,7 +4658,7 @@ async function collectRealVotes(options) {
     proposal,
     roleAdapters,
     fallbackAdapter: adapterResult.adapter,
-    logger: logger8,
+    logger: logger11,
     voteOptions,
     interDelay
   });
@@ -5642,11 +5647,11 @@ var ConsensusEngine = class {
   logger;
   metrics;
   voterExpansionCallback;
-  constructor(config, logger8) {
+  constructor(config, logger11) {
     this.config = { ...DEFAULT_CONSENSUS_CONFIG, ...config };
     this.cacheConfig = { ...DEFAULT_PROPOSAL_CACHE_CONFIG, ...config?.proposalCache };
     this.quorumConfig = { ...DEFAULT_INCREMENTAL_QUORUM_CONFIG, ...config?.incrementalQuorum };
-    this.logger = logger8 ?? createLogger({ component: "ConsensusEngine" });
+    this.logger = logger11 ?? createLogger({ component: "ConsensusEngine" });
     this.strategyFactory = new VotingStrategyFactory();
     this.metrics = this.createInitialMetrics();
   }
@@ -6088,8 +6093,8 @@ var ConsensusEngine = class {
     this.logger.debug("Proposal cache cleared");
   }
 };
-function createConsensusEngine(config, logger8) {
-  return new ConsensusEngine(config, logger8);
+function createConsensusEngine(config, logger11) {
+  return new ConsensusEngine(config, logger11);
 }
 
 // src/consensus/quorum-validator.ts
@@ -6097,8 +6102,8 @@ var DEFAULT_MIN_TRUST = 0.3;
 var DEFAULT_MIN_WEIGHT = 0.1;
 var QuorumValidator = class {
   logger;
-  constructor(logger8) {
-    this.logger = logger8 ?? createLogger({ component: "QuorumValidator" });
+  constructor(logger11) {
+    this.logger = logger11 ?? createLogger({ component: "QuorumValidator" });
   }
   validateQuorum(input) {
     const { votes, config } = input;
@@ -6325,8 +6330,8 @@ var QuorumValidator = class {
     };
   }
 };
-function createQuorumValidator(logger8) {
-  return new QuorumValidator(logger8);
+function createQuorumValidator(logger11) {
+  return new QuorumValidator(logger11);
 }
 
 // src/consensus/voting-protocol-helpers.ts
@@ -7906,6 +7911,35 @@ var ConsensusVoteInputSchema = z9.object({
   quickMode: z9.boolean().optional().default(false).describe("Use 3 agents instead of 5 for faster execution"),
   simulateVotes: z9.boolean().optional().default(false).describe(
     "TESTS ONLY \u2014 when true, voters return random decisions. Output must not be used for real decisions. (#2319)"
+  ),
+  /**
+   * Async-mode dispatch (#3045, Stage 4 of epic #2631). Default `sync` —
+   * backward-compat invariant. `async` returns `{ status: 'pending', jobId }`
+   * immediately; caller polls `get_job_result(jobId)`. Per-tool cap via
+   * `NEXUS_JOB_MAX_CONCURRENT_CONSENSUS_VOTE` (default 2 — voting is
+   * 7-fan-out so concurrent jobs multiply adapter load fast).
+   *
+   * Cancellation semantics (#3041 vote deferred this to Stage 4): when
+   * a polling client calls `cancel_job` mid-vote, the dispatcher aborts
+   * in-flight voters via the AbortSignal plumbing from #3038. The
+   * resulting job result is `{ status: 'cancelled', partialVotes: [...] }`
+   * with whatever voters completed before the abort signal — preserves
+   * audit visibility into who voted before the cancel landed.
+   *
+   * Kept optional (no `.default()`) so the inferred type doesn't force
+   * `mode: 'sync'` on every existing call site / test fixture.
+   */
+  mode: z9.enum(["sync", "async"]).optional().describe(
+    'Dispatch mode (default: sync). Use "async" for higher-order strategies with 7 voters.'
+  ),
+  /**
+   * Idempotency key for async-mode replay-safety (#3042 Stage 1c / epic
+   * #2631). When set: identical (key, inputs) returns the existing job;
+   * same key with different inputs fails closed with
+   * `idempotency_key_collision`. Sync mode ignores this.
+   */
+  idempotencyKey: z9.string().min(1).max(256).optional().describe(
+    "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId."
   )
 });
 function toAgentVoteSummary(result) {
@@ -8012,10 +8046,10 @@ import { appendFileSync as appendFileSync3, readFileSync as readFileSync2, write
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
-  constructor(config, logger8) {
+  constructor(config, logger11) {
     super(config);
     this.filePath = config?.filePath ?? getOutcomesFile();
-    this.logger = logger8 ?? createLogger({ component: "PersistentOutcomeStore" });
+    this.logger = logger11 ?? createLogger({ component: "PersistentOutcomeStore" });
     const dataDir = config?.dataDir;
     ensureLearningDir(dataDir);
     this.hydrate();
@@ -8209,11 +8243,11 @@ var WARNED = /* @__PURE__ */ new Set();
 function isTestRunner() {
   return process.env.VITEST === "true" || process.env.NODE_ENV === "test";
 }
-function warnIfSimulatedOutsideTests(toolName, logger8) {
+function warnIfSimulatedOutsideTests(toolName, logger11) {
   if (isTestRunner()) return;
   if (WARNED.has(toolName)) return;
   WARNED.add(toolName);
-  logger8.warn(
+  logger11.warn(
     `[${toolName}] simulateVotes=true: output is RANDOM and reserved for tests/demos. Do not treat the result as a real decision.`
   );
 }
@@ -8457,6 +8491,20 @@ var TOOL_ANNOTATIONS = {
     idempotentHint: true,
     openWorldHint: false
   },
+  /** Reads job-result sidecar file for an async-mode dispatch (#3042 / #2631). */
+  get_job_result: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Lists async-mode job summaries from the sidecar dir (#3046 / #2631 Stage 5). */
+  list_jobs: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   /** Verifies hash chain of audit log files. */
   verify_audit_chain: {
     readOnlyHint: true,
@@ -8530,7 +8578,321 @@ function getToolAnnotations(name) {
   return a;
 }
 
+// src/mcp/jobs/job-result-store.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { z as z10 } from "zod";
+var logger8 = createLogger({ component: "job-result-store" });
+var JobStatusSchema = z10.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z10.object({
+  /** Format version. Currently `1` — bump if the shape changes. */
+  v: z10.literal(1),
+  jobId: z10.string().min(1),
+  /** Tool that was invoked (e.g. `orchestrate`). */
+  toolName: z10.string().min(1),
+  status: JobStatusSchema,
+  createdAt: z10.iso.datetime(),
+  /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
+  completedAt: z10.iso.datetime().optional(),
+  /**
+   * Structured payload the synchronous mode would have returned. Present
+   * only when `status === 'complete'`. Shape is tool-specific — readers
+   * cast to the tool's known output type after status check.
+   */
+  result: z10.unknown().optional(),
+  /**
+   * Failure message when `status === 'failed'`. Cannot be paired with
+   * `result` — the discriminator is `status`.
+   */
+  error: z10.string().optional()
+});
+function jobResultPath(jobId) {
+  return nexusDataPathEnsure("jobs", `result-${jobId}.json`);
+}
+function writeJobPending(jobId, toolName) {
+  const path = jobResultPath(jobId);
+  if (existsSync4(path)) {
+    logger8.debug("Job result file already exists \u2014 leaving in place", { jobId });
+    return;
+  }
+  const record = {
+    v: 1,
+    jobId,
+    toolName,
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync3(path, JSON.stringify(record, null, 2));
+  logger8.debug("Wrote pending job record", { jobId, toolName });
+}
+function writeJobComplete(jobId, toolName, result) {
+  const record = {
+    v: 1,
+    jobId,
+    toolName,
+    status: "complete",
+    createdAt: readJobResult(jobId)?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    result
+  };
+  writeFileSync3(jobResultPath(jobId), JSON.stringify(record, null, 2));
+  logger8.debug("Wrote complete job record", { jobId, toolName });
+}
+function writeJobFailed(jobId, toolName, error) {
+  const record = {
+    v: 1,
+    jobId,
+    toolName,
+    status: "failed",
+    createdAt: readJobResult(jobId)?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    error
+  };
+  writeFileSync3(jobResultPath(jobId), JSON.stringify(record, null, 2));
+  logger8.debug("Wrote failed job record", { jobId, toolName, error });
+}
+function readJobResult(jobId) {
+  const path = nexusDataPath("jobs", `result-${jobId}.json`);
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync3(path, "utf-8"));
+    const parsed = JobResultSchema.safeParse(raw);
+    if (!parsed.success) {
+      logger8.warn("Job result file failed schema check", { jobId, path });
+      return null;
+    }
+    return parsed.data;
+  } catch (err2) {
+    logger8.warn("Job result file unreadable", {
+      jobId,
+      path,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return null;
+  }
+}
+function listJobs() {
+  const dir = nexusDataPath("jobs");
+  if (!existsSync4(dir)) return [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch (err2) {
+    logger8.warn("jobs directory unreadable", {
+      dir,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return [];
+  }
+  const summaries = [];
+  for (const entry of entries) {
+    const match = /^result-(.+)\.json$/.exec(entry);
+    if (match === null) continue;
+    const jobId = match[1];
+    if (jobId === void 0) continue;
+    const record = readJobResult(jobId);
+    if (record === null) continue;
+    const summary = {
+      jobId: record.jobId,
+      toolName: record.toolName,
+      status: record.status,
+      createdAt: record.createdAt,
+      hasError: record.error !== void 0,
+      ...record.completedAt !== void 0 ? { completedAt: record.completedAt } : {}
+    };
+    summaries.push(summary);
+  }
+  return summaries.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+// src/mcp/jobs/job-idempotency.ts
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { z as z11 } from "zod";
+var logger9 = createLogger({ component: "job-idempotency" });
+var IdempotencyIndexEntrySchema = z11.object({
+  v: z11.literal(1),
+  /** MCP tool name (e.g. `orchestrate`, `run_workflow`, `consensus_vote`). */
+  tool: z11.string().min(1),
+  /** Caller-supplied idempotency key. */
+  key: z11.string().min(1),
+  /** sha256 of the canonical input JSON. */
+  inputsHash: z11.string().length(64),
+  /** Existing jobId for this (tool, key, inputs) tuple. */
+  jobId: z11.string().min(1),
+  /** ISO timestamp of first dispatch. */
+  createdAt: z11.iso.datetime()
+});
+function sha256Hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function canonicalJsonStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJsonStringify).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJsonStringify(v)}`).join(",")}}`;
+}
+function computeInputsHash(inputs) {
+  return sha256Hex(canonicalJsonStringify(inputs));
+}
+function indexFilePath(tool, key) {
+  const filename = `key-${sha256Hex(`${tool}:${key}`)}.json`;
+  return nexusDataPathEnsure("jobs", filename);
+}
+function indexFilePathReadOnly(tool, key) {
+  const filename = `key-${sha256Hex(`${tool}:${key}`)}.json`;
+  return nexusDataPath("jobs", filename);
+}
+function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = randomUUID3) {
+  if (idempotencyKey === void 0 || idempotencyKey === "") {
+    return { kind: "fresh", jobId: randomFallback() };
+  }
+  const incomingInputsHash = computeInputsHash(inputs);
+  const path = indexFilePathReadOnly(tool, idempotencyKey);
+  if (existsSync5(path)) {
+    const entry = readIndexEntry(path);
+    if (entry !== null) {
+      if (entry.inputsHash === incomingInputsHash) {
+        return { kind: "replay", jobId: entry.jobId, entry };
+      }
+      return {
+        kind: "collision",
+        existingInputsHash: entry.inputsHash,
+        incomingInputsHash,
+        existingJobId: entry.jobId
+      };
+    }
+    logger9.warn("Idempotency index file unreadable; treating as fresh dispatch", { tool, path });
+  }
+  const jobId = `job-${tool}-${sha256Hex(`${tool}:${idempotencyKey}:${incomingInputsHash}`).slice(0, 16)}`;
+  return { kind: "fresh", jobId };
+}
+function registerIdempotentJob(params) {
+  const path = indexFilePath(params.tool, params.idempotencyKey);
+  if (existsSync5(path)) {
+    logger9.debug("Idempotency index entry already present; skipping write", {
+      tool: params.tool,
+      jobId: params.jobId
+    });
+    return;
+  }
+  const entry = {
+    v: 1,
+    tool: params.tool,
+    key: params.idempotencyKey,
+    inputsHash: computeInputsHash(params.inputs),
+    jobId: params.jobId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync4(path, JSON.stringify(entry, null, 2));
+  logger9.debug("Wrote idempotency index entry", { tool: params.tool, jobId: params.jobId });
+}
+function shortCircuitOrFreshJobId(params) {
+  const r = resolveIdempotency(
+    params.tool,
+    params.idempotencyKey,
+    params.inputs,
+    params.freshJobId
+  );
+  if (r.kind === "collision") {
+    return { kind: "shortCircuit", value: params.collisionEnvelope(r.existingJobId) };
+  }
+  if (r.kind === "replay") {
+    return { kind: "shortCircuit", value: params.replayEnvelope(r.jobId) };
+  }
+  return { kind: "continue", jobId: r.jobId };
+}
+function readIndexEntry(path) {
+  try {
+    const raw = JSON.parse(readFileSync4(path, "utf-8"));
+    const parsed = IdempotencyIndexEntrySchema.safeParse(raw);
+    if (!parsed.success) {
+      logger9.warn("Idempotency index file failed schema check", { path });
+      return null;
+    }
+    return parsed.data;
+  } catch (err2) {
+    logger9.warn("Idempotency index file read failed", {
+      path,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return null;
+  }
+}
+
+// src/mcp/jobs/job-concurrency.ts
+var logger10 = createLogger({ component: "job-concurrency" });
+var DEFAULT_JOB_CAPS = {
+  orchestrate: 3,
+  run_workflow: 3,
+  consensus_vote: 2,
+  execute_expert: 4
+};
+var DEFAULT_GLOBAL_JOB_CAP = 10;
+var inFlight = /* @__PURE__ */ new Map();
+function getJobCap(toolName) {
+  const envKey = `NEXUS_JOB_MAX_CONCURRENT_${toolName.toUpperCase()}`;
+  const envValue = process.env[envKey];
+  if (envValue !== void 0 && envValue !== "") {
+    const parsed = Number(envValue);
+    if (Number.isInteger(parsed) && parsed >= 0) {
+      return parsed;
+    }
+    logger10.warn("Invalid env override for job cap \u2014 ignoring", {
+      tool: toolName,
+      envKey,
+      envValue
+    });
+  }
+  return DEFAULT_JOB_CAPS[toolName] ?? DEFAULT_GLOBAL_JOB_CAP;
+}
+function getGlobalJobCap() {
+  const envValue = process.env["NEXUS_JOB_MAX_CONCURRENT_TOTAL"];
+  if (envValue !== void 0 && envValue !== "") {
+    const parsed = Number(envValue);
+    if (Number.isInteger(parsed) && parsed >= 0) {
+      return parsed;
+    }
+    logger10.warn("Invalid env override for global job cap \u2014 ignoring", {
+      envKey: "NEXUS_JOB_MAX_CONCURRENT_TOTAL",
+      envValue
+    });
+  }
+  return DEFAULT_GLOBAL_JOB_CAP;
+}
+function getTotalInFlight() {
+  let total = 0;
+  for (const count of inFlight.values()) total += count;
+  return total;
+}
+function tryAcquire(toolName) {
+  const cap = getJobCap(toolName);
+  if (cap === 0) return false;
+  const current = inFlight.get(toolName) ?? 0;
+  if (current >= cap) return false;
+  const globalCap = getGlobalJobCap();
+  if (globalCap === 0) return false;
+  if (getTotalInFlight() >= globalCap) return false;
+  inFlight.set(toolName, current + 1);
+  return true;
+}
+function release(toolName) {
+  const current = inFlight.get(toolName) ?? 0;
+  if (current === 0) {
+    logger10.warn("release() called with no in-flight count \u2014 caller bug", { tool: toolName });
+    return;
+  }
+  inFlight.set(toolName, current - 1);
+}
+function suggestRetryAfterMs(toolName) {
+  const cap = getJobCap(toolName);
+  if (cap === 0) return 0;
+  const current = inFlight.get(toolName) ?? 0;
+  const base = 3e4 * (current / Math.max(1, cap));
+  return Math.min(6e4, Math.max(5e3, base));
+}
+
 // src/mcp/tools/consensus-vote.ts
+import { randomUUID as randomUUID4 } from "crypto";
 var persistentCorrelationTracker;
 function getOrCreateCorrelationTracker() {
   persistentCorrelationTracker ??= createPersistentCorrelationTracker();
@@ -8639,22 +9001,22 @@ async function processVotesThroughEngine(engineVotes, proposal, algorithm) {
     });
   return resultRes.value;
 }
-function runHigherOrderVoting(strategy, voteMap, logger8) {
+function runHigherOrderVoting(strategy, voteMap, logger11) {
   if (strategy !== "higher_order") return void 0;
   const hovStrategy = new HigherOrderVotingStrategy();
   const tracker = getOrCreateCorrelationTracker();
   const result = hovStrategy.aggregate(voteMap, tracker);
-  logger8.info("Higher-Order Voting complete", {
+  logger11.info("Higher-Order Voting complete", {
     method: result.method,
     decision: result.decision,
     posteriorApproval: result.posteriorApproval.toFixed(3)
   });
   return result;
 }
-function recordVotesToTracker(votes, voteMap, outcome, logger8) {
+function recordVotesToTracker(votes, voteMap, outcome, logger11) {
   const allVotesReal = votes.every((v) => v.source === "llm");
   if (!allVotesReal) {
-    logger8.warn("Skipping correlation recording due to non-LLM votes", {
+    logger11.warn("Skipping correlation recording due to non-LLM votes", {
       count: votes.filter((v) => v.source !== "llm").length
     });
     return;
@@ -8662,16 +9024,16 @@ function recordVotesToTracker(votes, voteMap, outcome, logger8) {
   const tracker = getOrCreateCorrelationTracker();
   const id = `consensus-${String(getTimeProvider().now())}-${getRandomProvider().random().toString(36).slice(2, 9)}`;
   tracker.recordProposalVotes(id, voteMap, outcome);
-  logger8.debug("Recorded votes to tracker", { proposalId: id, outcome });
+  logger11.debug("Recorded votes to tracker", { proposalId: id, outcome });
   try {
     const persisted = createPersistedProposal(id, voteMap, outcome);
     const saveResult = saveCorrelationData([persisted]);
     if (!saveResult.ok) {
-      logger8.warn("Failed to persist correlation data", { error: saveResult.error.message });
+      logger11.warn("Failed to persist correlation data", { error: saveResult.error.message });
     }
   } catch (error) {
     const message = getErrorMessage(error);
-    logger8.warn("Error persisting correlation data", { error: message });
+    logger11.warn("Error persisting correlation data", { error: message });
   }
 }
 async function processVotesWithCascade(engineVotes, opts) {
@@ -8696,7 +9058,7 @@ async function processVotesWithCascade(engineVotes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-7LPGCPPR.js");
+    const { executeExpert } = await import("./expert-bridge-22UVN5TB.js");
     const prompt = [
       "You are a contrarian analyst. Your job is to find reasons this proposal should be REJECTED.",
       "Look for: YAGNI (not needed), MISALIGNED (wrong tech/architecture), SECURITY_RISK, SCOPE_CREEP.",
@@ -8746,23 +9108,23 @@ function buildPolicyShortCircuitResult(args) {
     strategy: args.strategy
   };
 }
-async function maybeEscalateContrarian(input, outcome, logger8, opts) {
+async function maybeEscalateContrarian(input, outcome, logger11, opts) {
   if (!input.quickMode || outcome !== "approved" || input.simulateVotes) return void 0;
-  const escalation = await runContrarianCheck(input.proposal, logger8);
+  const escalation = await runContrarianCheck(input.proposal, logger11);
   if (!escalation.shouldEscalate) return void 0;
-  logger8.warn("Contrarian escalation: re-running with full vote", {
+  logger11.warn("Contrarian escalation: re-running with full vote", {
     reason: escalation.reason,
     confidence: escalation.confidence
   });
-  return executeVoting({ ...input, quickMode: false }, logger8, opts);
+  return executeVoting({ ...input, quickMode: false }, logger11, opts);
 }
-async function executeVoting(input, logger8, opts) {
+async function executeVoting(input, logger11, opts) {
   const strategy = resolveStrategy(input);
   const algorithm = strategyToAlgorithm(strategy);
   const roles = getVoterRoles(input.quickMode);
   const startTime = getTimeProvider().now();
   const errorPolicy = input.errorPolicy ?? getDefaultErrorPolicy(strategy);
-  logger8.info("Starting consensus vote", {
+  logger11.info("Starting consensus vote", {
     strategy,
     algorithm,
     roleCount: roles.length,
@@ -8784,7 +9146,7 @@ async function executeVoting(input, logger8, opts) {
       errorPolicy,
       reason: policyDecision.reason ?? "error policy short-circuit",
       startTime,
-      logger: logger8
+      logger: logger11
     });
   }
   const { engineResult, voteMap, higherOrderResult, outcome, cascaded } = await processVotesWithCascade(policyDecision.engineVotes, {
@@ -8792,10 +9154,10 @@ async function executeVoting(input, logger8, opts) {
     proposal: input.proposal,
     algorithm,
     strategy,
-    log: logger8
+    log: logger11
   });
-  recordVotesToTracker(votes, voteMap, outcome, logger8);
-  const escalated = await maybeEscalateContrarian(input, outcome, logger8, opts);
+  recordVotesToTracker(votes, voteMap, outcome, logger11);
+  const escalated = await maybeEscalateContrarian(input, outcome, logger11, opts);
   if (escalated !== void 0) return escalated;
   return finalizeVotingResult({
     input,
@@ -8807,7 +9169,7 @@ async function executeVoting(input, logger8, opts) {
     outcome,
     cascaded,
     startTime,
-    logger: logger8
+    logger: logger11
   });
 }
 function finalizeVotingResult(args) {
@@ -8831,15 +9193,15 @@ function finalizeVotingResult(args) {
   return result;
 }
 async function handleConsensusVote(deps, args) {
-  const logger8 = deps.logger ?? createLogger({ tool: "consensus_vote" });
-  if (args.simulateVotes) warnIfSimulatedOutsideTests("consensus_vote", logger8);
+  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  if (args.simulateVotes) warnIfSimulatedOutsideTests("consensus_vote", logger11);
   try {
-    const result = await executeVoting(args, logger8);
+    const result = await executeVoting(args, logger11);
     const strategy = args.strategy ?? "simple_majority";
     const errorVotes = result.votes.filter((v) => v.source === "error");
     if (errorVotes.length === result.votes.length && result.votes.length > 0) {
       const failures = errorVotes.map((v) => `${v.role}: ${v.error ?? "unknown error"}`).join("; ");
-      logger8.warn("All voters failed", { failureCount: errorVotes.length, failures });
+      logger11.warn("All voters failed", { failureCount: errorVotes.length, failures });
       recordVoteError(args.proposal, `All ${String(errorVotes.length)} voters failed: ${failures}`);
       return {
         ok: false,
@@ -8857,11 +9219,109 @@ async function handleConsensusVote(deps, args) {
   } catch (error) {
     const message = getErrorMessage(error);
     const cause = error instanceof Error ? error : new Error(message);
-    logger8.error("Consensus vote failed", cause);
+    logger11.error("Consensus vote failed", cause);
     recordVoteError(args.proposal, message);
     return { ok: false, error: `Voting failed: ${message}` };
   }
 }
+function buildConsensusVoteReplayEnvelope(jobId) {
+  return toolSuccess(
+    JSON.stringify({
+      status: "replay",
+      jobId,
+      pollTool: "get_job_result",
+      note: "Idempotency key matched a prior dispatch \u2014 poll get_job_result for current status."
+    })
+  );
+}
+function buildConsensusVoteCollisionEnvelope(existingJobId) {
+  return toolStructuredError({
+    errorCategory: "validation",
+    message: `Idempotency key already used with different inputs. Existing jobId: ${existingJobId}. Use a fresh key or omit it.`
+  });
+}
+function dispatchAsyncConsensusVote(deps, args) {
+  const idempotency = shortCircuitOrFreshJobId({
+    tool: "consensus_vote",
+    idempotencyKey: args.idempotencyKey,
+    inputs: args,
+    freshJobId: () => `job-vote-${randomUUID4()}`,
+    replayEnvelope: buildConsensusVoteReplayEnvelope,
+    collisionEnvelope: buildConsensusVoteCollisionEnvelope
+  });
+  if (idempotency.kind === "shortCircuit") return idempotency.value;
+  if (!tryAcquire("consensus_vote")) {
+    return toolSuccess(
+      JSON.stringify({
+        status: "busy",
+        retryAfterMs: suggestRetryAfterMs("consensus_vote"),
+        note: 'Async-mode concurrency cap reached for consensus_vote. Retry later or use mode: "sync".'
+      })
+    );
+  }
+  const jobId = idempotency.jobId;
+  recordConsensusVotePending(jobId, args);
+  void runConsensusVoteInBackground(jobId, deps, args);
+  return toolSuccess(
+    JSON.stringify({
+      status: "pending",
+      jobId,
+      pollTool: "get_job_result",
+      note: 'Poll via get_job_result({ jobId }) until status !== "pending".'
+    })
+  );
+}
+function recordConsensusVotePending(jobId, args) {
+  writeJobPending(jobId, "consensus_vote");
+  if (args.idempotencyKey !== void 0 && args.idempotencyKey !== "") {
+    registerIdempotentJob({
+      tool: "consensus_vote",
+      idempotencyKey: args.idempotencyKey,
+      inputs: args,
+      jobId
+    });
+  }
+}
+async function runConsensusVoteInBackground(jobId, deps, args) {
+  try {
+    const result = await handleConsensusVote(deps, args);
+    writeJobComplete(jobId, "consensus_vote", result);
+  } catch (err2) {
+    const errObj = err2 instanceof Error ? err2 : new Error(String(err2));
+    deps.logger?.error("Async consensus_vote dispatch failed", errObj, { jobId });
+    writeJobFailed(jobId, "consensus_vote", errObj.message);
+  } finally {
+    release("consensus_vote");
+  }
+}
+async function runSyncConsensusVote(deps, notifier, args) {
+  const result = await withProgressHeartbeat(
+    "consensus_vote",
+    notifier,
+    () => handleConsensusVote(deps, args)
+  );
+  if (!result.ok) {
+    return toolStructuredError({ errorCategory: "internal", message: result.error });
+  }
+  for (const vote of result.value.votes) {
+    notifier.debug("consensus_vote", {
+      event: "vote_collected",
+      role: vote.role,
+      decision: vote.decision
+    });
+  }
+  notifier.info("consensus_vote", {
+    event: "vote_complete",
+    decision: result.value.decision,
+    approvalPercentage: result.value.approvalPercentage,
+    voteCount: result.value.votes.length
+  });
+  const data = result.value;
+  return {
+    ...toolSuccess(JSON.stringify(result.value, null, 2)),
+    structuredContent: data
+  };
+}
 function createConsensusVoteHandler(deps) {
   const notifier = deps.notifier ?? NOOP_NOTIFIER;
   return async (args, ctx) => {
@@ -8875,63 +9335,48 @@ function createConsensusVoteHandler(deps) {
     const strategy = validationResult.data.strategy ?? "simple_majority";
     ctx.logger.debug("Starting consensus vote", {
       strategy,
-      quickMode: validationResult.data.quickMode
+      quickMode: validationResult.data.quickMode,
+      ...validationResult.data.mode !== void 0 ? { mode: validationResult.data.mode } : {}
     });
     notifier.info("consensus_vote", {
       event: "vote_start",
       proposalLength: validationResult.data.proposal.length,
       strategy
     });
-    const result = await withProgressHeartbeat(
-      "consensus_vote",
-      notifier,
-      () => handleConsensusVote(deps, validationResult.data)
-    );
-    if (!result.ok) {
-      return toolStructuredError({ errorCategory: "internal", message: result.error });
-    }
-    for (const vote of result.value.votes) {
-      notifier.debug("consensus_vote", {
-        event: "vote_collected",
-        role: vote.role,
-        decision: vote.decision
+    if (validationResult.data.mode === "async") {
+      const asyncResult = dispatchAsyncConsensusVote(deps, validationResult.data);
+      notifier.info("consensus_vote", {
+        event: "vote_dispatched_async",
+        proposalLength: validationResult.data.proposal.length,
+        strategy
       });
+      return asyncResult;
     }
-    notifier.info("consensus_vote", {
-      event: "vote_complete",
-      decision: result.value.decision,
-      approvalPercentage: result.value.approvalPercentage,
-      voteCount: result.value.votes.length
-    });
-    const data = result.value;
-    return {
-      ...toolSuccess(JSON.stringify(result.value, null, 2)),
-      structuredContent: data
-    };
+    return runSyncConsensusVote(deps, notifier, validationResult.data);
   };
 }
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
-  proposal: z10.string(),
+  proposal: z12.string(),
   strategy: VotingStrategySchema,
-  decision: z10.enum(["approved", "rejected", "no_quorum"]),
-  approvalPercentage: z10.number(),
-  voteCounts: z10.object({
-    approve: z10.number(),
-    reject: z10.number(),
-    abstain: z10.number(),
-    error: z10.number()
+  decision: z12.enum(["approved", "rejected", "no_quorum"]),
+  approvalPercentage: z12.number(),
+  voteCounts: z12.object({
+    approve: z12.number(),
+    reject: z12.number(),
+    abstain: z12.number(),
+    error: z12.number()
   }),
-  votes: z10.array(
-    z10.object({
-      role: z10.string().max(100),
-      decision: z10.enum(["approve", "reject", "abstain"]),
-      confidence: z10.number(),
-      reasoning: z10.string().max(4e3),
-      simulated: z10.boolean(),
-      error: z10.boolean(),
-      modelUsed: z10.string().max(100).optional(),
-      rejectionCategories: z10.array(
-        z10.enum([
+  votes: z12.array(
+    z12.object({
+      role: z12.string().max(100),
+      decision: z12.enum(["approve", "reject", "abstain"]),
+      confidence: z12.number(),
+      reasoning: z12.string().max(4e3),
+      simulated: z12.boolean(),
+      error: z12.boolean(),
+      modelUsed: z12.string().max(100).optional(),
+      rejectionCategories: z12.array(
+        z12.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -8944,42 +9389,42 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z10.number(),
-  simulateVotes: z10.boolean(),
-  higherOrderMetadata: z10.object({
-    posteriorApproval: z10.number(),
-    posteriorRejection: z10.number(),
-    effectiveVoteCount: z10.number(),
-    method: z10.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z10.boolean(),
-    improvementOverBaseline: z10.number(),
-    downweightedAgents: z10.array(z10.string().max(100)).max(10),
-    reasoning: z10.string().max(2e3)
+  durationMs: z12.number(),
+  simulateVotes: z12.boolean(),
+  higherOrderMetadata: z12.object({
+    posteriorApproval: z12.number(),
+    posteriorRejection: z12.number(),
+    effectiveVoteCount: z12.number(),
+    method: z12.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z12.boolean(),
+    improvementOverBaseline: z12.number(),
+    downweightedAgents: z12.array(z12.string().max(100)).max(10),
+    reasoning: z12.string().max(2e3)
   }).optional()
 };
 function registerConsensusVoteTool(server, deps) {
-  const logger8 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const toolSchema = {
-    proposal: z10.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
-    threshold: z10.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
+    proposal: z12.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+    threshold: z12.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
     strategy: VotingStrategySchema.optional().describe(
       "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order"
     ),
-    quickMode: z10.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
-    simulateVotes: z10.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+    quickMode: z12.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
+    simulateVotes: z12.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
   };
   const description = "Execute multi-model consensus voting on a proposal. Uses 7 specialized agent roles (architect, security, devex, ai_ml, pm, catfish, scope_steward) to vote on proposals with configurable strategies. Supports higher_order strategy for Bayesian-optimal aggregation with correlation awareness (Issue #514).";
   const secureHandler = createSecureHandler(createConsensusVoteHandler(depsWithNotifier), {
     toolName: "consensus_vote",
     rateLimiter: deps.rateLimiter,
-    logger: logger8
+    logger: logger11
   });
   const timeoutMs = getToolTimeout("consensus_vote", deps.security);
   const wrappedHandler = wrapToolWithTimeout("consensus_vote", secureHandler, {
     timeoutMs,
-    logger: logger8
+    logger: logger11
   });
   server.registerTool(
     "consensus_vote",
@@ -8989,9 +9434,9 @@ function registerConsensusVoteTool(server, deps) {
       outputSchema: CONSENSUS_VOTE_OUTPUT_SCHEMA,
       annotations: getToolAnnotations("consensus_vote")
     },
-    toSdkCallbackWithBudgetCheck(wrappedHandler, "consensus_vote", timeoutMs, logger8)
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "consensus_vote", timeoutMs, logger11)
   );
-  logger8.info("Registered consensus_vote tool with secure handler and timeout protection");
+  logger11.info("Registered consensus_vote tool with secure handler and timeout protection");
 }
 
 export {
@@ -9044,6 +9489,17 @@ export {
   toSdkCallbackWithBudgetCheck,
   getToolAnnotations,
   PersistentOutcomeStore,
+  JobStatusSchema,
+  writeJobPending,
+  writeJobComplete,
+  writeJobFailed,
+  readJobResult,
+  listJobs,
+  registerIdempotentJob,
+  shortCircuitOrFreshJobId,
+  tryAcquire,
+  release,
+  suggestRetryAfterMs,
   DEFAULT_VOTE_TIMEOUT_MS,
   isRateLimitError,
   VOTER_ROLES,
@@ -9113,4 +9569,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-ODKIRXN7.js.map
+//# sourceMappingURL=chunk-IF6TXCSE.js.map