nexus-agents 2.125.36 → 2.125.38

package/dist/{chunk-SOGHVI6W.js → chunk-2SIYUWT2.js}

@@ -30,7 +30,7 @@ import {
   runConsensusForGoal,
   warnIfSimulatedOutsideTests,
   writeJobCancelled
-} from "./chunk-Y5SDY462.js";
+} from "./chunk-PRFSN66J.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
@@ -122,7 +122,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-4LYMLGHZ.js";
+} from "./chunk-Q37HBFVE.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -37599,11 +37599,22 @@ function recordTriageOutcome(success, durationMs, errorMsg) {
 
 // src/mcp/tools/run-graph-workflow.ts
 import { z as z67 } from "zod";
+import { randomUUID as randomUUID11 } from "crypto";
 var RunGraphWorkflowInputSchema = z67.object({
   workflow: z67.string().min(1).max(100).describe("Name of the predefined graph workflow to execute"),
   inputs: z67.record(z67.string(), z67.unknown()).optional().default({}).describe("Input values for the workflow"),
   enableCheckpointing: z67.boolean().optional().default(true).describe("Enable checkpoint saving between steps"),
-  enableAuditTrail: z67.boolean().optional().default(false).describe("Enable audit trail event logging")
+  enableAuditTrail: z67.boolean().optional().default(false).describe("Enable audit trail event logging"),
+  /**
+   * Dispatch mode (#3732). `sync` (default) runs the graph workflow inline and
+   * returns the result — but a workflow of up to ~100 expert nodes can exceed
+   * the MCP request timeout. `async` returns a `{ status: 'pending', jobId }`
+   * envelope immediately and runs in the background; poll
+   * `get_job_result({ jobId })` for the result. Ignored for the `list` sentinel.
+   */
+  dispatch: z67.enum(["sync", "async"]).optional().default("sync").describe(
+    "Dispatch mode (#3732). 'sync' (default): run inline. 'async': return a jobId immediately + run in background (poll get_job_result)."
+  )
 });
 function resolveGraph(workflow, startTime) {
   const registry = getGraphRegistry();
@@ -37688,8 +37699,24 @@ var GRAPH_WORKFLOW_SCHEMA = {
   ),
   inputs: z67.record(z67.string(), z67.unknown()).optional().describe("Input values for the workflow"),
   enableCheckpointing: z67.boolean().optional().describe("Enable checkpoint saving"),
-  enableAuditTrail: z67.boolean().optional().describe("Enable audit trail logging")
+  enableAuditTrail: z67.boolean().optional().describe("Enable audit trail logging"),
+  dispatch: z67.enum(["sync", "async"]).optional().describe(
+    "Dispatch mode (#3732). 'sync' (default): run inline. 'async': return a jobId immediately + run in background (poll get_job_result)."
+  )
 };
+async function executeGraphWorkflowBody(input, logger57, notifier) {
+  const result = await handleRunGraphWorkflow(input, logger57);
+  const succeeded = result.status === "completed";
+  notifier.info("run_graph_workflow", {
+    event: succeeded ? "graph_workflow_complete" : "graph_workflow_failed",
+    workflow: result.workflow,
+    nodeCount: result.nodesExecuted,
+    durationMs: result.durationMs
+  });
+  recordGraphWorkflowResult(result);
+  const text = JSON.stringify(result, null, 2);
+  return succeeded ? toolSuccess(text) : toolStructuredError({ errorCategory: "internal", message: text });
+}
 function createGraphWorkflowHandler(logger57, notifier) {
   return async (args, _ctx) => {
     const parsed = RunGraphWorkflowInputSchema.safeParse(args);
@@ -37699,24 +37726,24 @@ function createGraphWorkflowHandler(logger57, notifier) {
         message: `Validation error: ${formatZodError(parsed.error)}`
       });
     }
-    if (parsed.data.workflow === "list") {
+    const input = parsed.data;
+    if (input.workflow === "list") {
       return toolSuccess(JSON.stringify(getGraphWorkflowList(), null, 2));
     }
     notifier.info("run_graph_workflow", {
       event: "graph_workflow_start",
-      workflow: parsed.data.workflow
-    });
-    const result = await handleRunGraphWorkflow(parsed.data, logger57);
-    const succeeded = result.status === "completed";
-    notifier.info("run_graph_workflow", {
-      event: succeeded ? "graph_workflow_complete" : "graph_workflow_failed",
-      workflow: result.workflow,
-      nodeCount: result.nodesExecuted,
-      durationMs: result.durationMs
+      workflow: input.workflow
     });
-    recordGraphWorkflowResult(result);
-    const text = JSON.stringify(result, null, 2);
-    return succeeded ? toolSuccess(text) : toolStructuredError({ errorCategory: "internal", message: text });
+    if (input.dispatch === "async") {
+      return runAsJob({
+        toolName: "run_graph_workflow",
+        input,
+        freshJobId: () => `gw-${randomUUID11()}`,
+        run: () => executeGraphWorkflowBody(input, logger57, notifier),
+        logger: logger57
+      });
+    }
+    return executeGraphWorkflowBody(input, logger57, notifier);
   };
 }
 function registerRunGraphWorkflowTool(server, deps) {
@@ -38298,9 +38325,21 @@ function suggestImprovement(criterion) {
 
 // src/mcp/tools/execute-spec-tool.ts
 import { z as z68 } from "zod";
+import { randomUUID as randomUUID12 } from "crypto";
 var ExecuteSpecInputSchema = z68.object({
   spec: z68.string().min(1).max(5e4).describe("Markdown specification to execute"),
-  dryRun: z68.boolean().optional().default(false).describe("Parse and decompose only")
+  dryRun: z68.boolean().optional().default(false).describe("Parse and decompose only"),
+  /**
+   * Dispatch mode (#3732). `sync` (default) runs the full DAG pipeline inline
+   * and returns the result — but a real parse→decompose→compile→execute→
+   * validate→analyze run can exceed the MCP request timeout. `async` returns a
+   * `{ status: 'pending', jobId }` envelope immediately and runs in the
+   * background; poll `get_job_result({ jobId })` for the result. Ignored when
+   * `dryRun` is true (parse+decompose completes fast, so dry runs stay sync).
+   */
+  dispatch: z68.enum(["sync", "async"]).default("sync").describe(
+    "Dispatch mode (#3732). 'sync' (default): run inline. 'async': return a jobId immediately + run in background (poll get_job_result). Ignored for dryRun."
+  )
 });
 function createDryRunResponse(input, logger57) {
   const parseResult2 = parseSpec(input.spec);
@@ -38350,9 +38389,8 @@ async function createFullResponse(input, logger57) {
   };
   return toolSuccess(JSON.stringify(output2, null, 2));
 }
-function registerExecuteSpecTool(server, deps) {
-  const logger57 = deps.logger ?? createLogger({ tool: "execute_spec" });
-  const handler3 = async (args, _ctx) => {
+function createExecuteSpecHandler(logger57) {
+  return async (args, _ctx) => {
     const parsed = ExecuteSpecInputSchema.safeParse(args);
     if (!parsed.success) {
       return toolStructuredError({
@@ -38360,11 +38398,25 @@ function registerExecuteSpecTool(server, deps) {
         message: `Invalid input: ${formatZodError(parsed.error)}`
       });
     }
-    if (parsed.data.dryRun) {
-      return createDryRunResponse(parsed.data, logger57);
+    const input = parsed.data;
+    if (input.dryRun) {
+      return createDryRunResponse(input, logger57);
     }
-    return createFullResponse(parsed.data, logger57);
+    if (input.dispatch === "async") {
+      return runAsJob({
+        toolName: "execute_spec",
+        input,
+        freshJobId: () => `es-${randomUUID12()}`,
+        run: () => createFullResponse(input, logger57),
+        logger: logger57
+      });
+    }
+    return createFullResponse(input, logger57);
   };
+}
+function registerExecuteSpecTool(server, deps) {
+  const logger57 = deps.logger ?? createLogger({ tool: "execute_spec" });
+  const handler3 = createExecuteSpecHandler(logger57);
   const secureHandler = createSecureHandler(handler3, {
     toolName: "execute_spec",
     rateLimiter: deps.rateLimiter,
@@ -38376,7 +38428,10 @@ function registerExecuteSpecTool(server, deps) {
     spec: z68.string().min(1).max(5e4).describe(
       'Markdown specification to execute. Must contain "## Requirements" and "## Acceptance Criteria" sections.'
     ),
-    dryRun: z68.boolean().optional().describe("Parse and decompose only (no execution)")
+    dryRun: z68.boolean().optional().describe("Parse and decompose only (no execution)"),
+    dispatch: z68.enum(["sync", "async"]).optional().describe(
+      "Dispatch mode (#3732). 'sync' (default): run inline. 'async': return a jobId immediately + run in background (poll get_job_result). Ignored for dryRun."
+    )
   };
   const description = "Execute a markdown specification through the full pipeline: parse, decompose into task DAG, compile to graph, execute, validate against acceptance criteria, and analyze failures.";
   server.registerTool(
@@ -39547,7 +39602,17 @@ var TOOL_NAME_BY_PREFIX = {
   // resolves those from the sidecar via toolName recorded at writeJobPending).
   dp: "run_dev_pipeline",
   // #3730: run_pipeline async jobs mint `rp-<uuid>` ids (no sessionId surface).
-  rp: "run_pipeline"
+  rp: "run_pipeline",
+  // #3731: pr_review async jobs mint `pr-<uuid>` ids (no sessionId surface).
+  pr: "pr_review",
+  // #3731: supply_chain_tradeoff_panel async jobs mint `sc-<uuid>` ids.
+  sc: "supply_chain_tradeoff_panel",
+  // #3732: execute_spec async jobs mint `es-<uuid>` ids (no sessionId surface).
+  es: "execute_spec",
+  // #3732: run_graph_workflow async jobs mint `gw-<uuid>` ids.
+  gw: "run_graph_workflow",
+  // #3732: run (execute:true) async jobs mint `rn-<uuid>` ids.
+  rn: "run"
 };
 function toolNameFromJobId(jobId) {
   const dash = jobId.indexOf("-");
@@ -43058,7 +43123,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-4ZB7C5QG.js");
+        const { executeVoting } = await import("./consensus-vote-CSKEO3LA.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -43601,6 +43666,7 @@ function createAuditStageRegistry() {
 
 // src/mcp/tools/pr-review-tool.ts
 import { z as z90 } from "zod";
+import { randomUUID as randomUUID13 } from "crypto";
 
 // src/mcp/tools/pr-review-findings.ts
 import { parse as parseYaml2 } from "yaml";
@@ -43692,6 +43758,7 @@ var PR_REVIEW_ROLES = [
 ];
 var MAX_DIFF_LENGTH = 5e4;
 var MAX_DESCRIPTION_LENGTH = 1e4;
+var PR_REVIEW_ASYNC_HINT = "A pr_review run fans out to 5 live LLM voters and can exceed the synchronous MCP request timeout. Retry with `dispatch: 'async'` to get a jobId immediately, then poll get_job_result({ jobId }) for the result.";
 var PrReviewInputSchema = z90.object({
   prTitle: z90.string().min(1).max(500).describe("PR title"),
   prDescription: z90.string().max(MAX_DESCRIPTION_LENGTH).optional().describe("PR body / description"),
@@ -43699,7 +43766,17 @@ var PrReviewInputSchema = z90.object({
   repoContext: z90.string().max(2e3).optional().describe("Optional one-paragraph repo context (architecture, conventions)"),
   baseRef: z90.string().max(200).optional().describe("Base branch ref (e.g. main)"),
   headRef: z90.string().max(200).optional().describe("Head branch ref"),
-  simulate: z90.boolean().default(false).describe("Use simulated voters (testing only; never ship live with this true)")
+  simulate: z90.boolean().default(false).describe("Use simulated voters (testing only; never ship live with this true)"),
+  /**
+   * Dispatch mode (#3731). `sync` (default) runs the 5-voter panel inline and
+   * returns the result — but a live fan-out can exceed the MCP request timeout.
+   * `async` returns a `{ status: 'pending', jobId }` envelope immediately and
+   * runs the panel in the background; poll `get_job_result({ jobId })` for the
+   * result.
+   */
+  dispatch: z90.enum(["sync", "async"]).default("sync").describe(
+    "Dispatch mode (#3731). 'sync' (default): run inline. 'async': return a jobId immediately + run the panel in background (poll get_job_result)."
+  )
 });
 function mapVoteDecisionToPrDecision(voteDecision) {
   if (voteDecision === "reject") return "request_changes";
@@ -43806,6 +43883,27 @@ function summarizeReviews(reviews) {
     errorCount: reviews.filter((r) => r.source === "error").length
   };
 }
+async function executePrReviewBody(input, logger57) {
+  const start = Date.now();
+  const proposal = buildPrReviewProposal(input);
+  const voteResults = await collectRealVotes({
+    roles: PR_REVIEW_ROLES,
+    proposal,
+    simulate: input.simulate,
+    logger: logger57
+  });
+  const reviews = voteResults.map(toPrReviewVote);
+  const counts = summarizeReviews(reviews);
+  const aggregate = aggregatePrDecisions(reviews);
+  const response = {
+    summary: aggregate.decision,
+    verified: aggregate.verified,
+    ...counts,
+    reviews,
+    totalDurationMs: Date.now() - start
+  };
+  return toolSuccess(JSON.stringify(response, null, 2));
+}
 async function prReviewHandler(args, ctx) {
   const parsed = PrReviewInputSchema.safeParse(args);
   if (!parsed.success) {
@@ -43815,30 +43913,21 @@ async function prReviewHandler(args, ctx) {
     });
   }
   const input = parsed.data;
-  const start = Date.now();
   try {
-    const proposal = buildPrReviewProposal(input);
-    const voteResults = await collectRealVotes({
-      roles: PR_REVIEW_ROLES,
-      proposal,
-      simulate: input.simulate,
-      logger: ctx.logger
-    });
-    const reviews = voteResults.map(toPrReviewVote);
-    const counts = summarizeReviews(reviews);
-    const aggregate = aggregatePrDecisions(reviews);
-    const response = {
-      summary: aggregate.decision,
-      verified: aggregate.verified,
-      ...counts,
-      reviews,
-      totalDurationMs: Date.now() - start
-    };
-    return toolSuccess(JSON.stringify(response, null, 2));
+    if (input.dispatch === "async") {
+      return runAsJob({
+        toolName: "pr_review",
+        input,
+        freshJobId: () => `pr-${randomUUID13()}`,
+        run: () => executePrReviewBody(input, ctx.logger),
+        logger: ctx.logger
+      });
+    }
+    return await executePrReviewBody(input, ctx.logger);
   } catch (error) {
     return toolStructuredError({
       errorCategory: "internal",
-      message: `PR review failed: ${getErrorMessage(error)}`
+      message: `${PR_REVIEW_ASYNC_HINT} PR review failed: ${getErrorMessage(error)}`
     });
   }
 }
@@ -45091,9 +45180,10 @@ function registerSuggestResearchTasksTool(server, deps) {
 
 // src/mcp/tools/run-tool.ts
 import { z as z103 } from "zod";
+import { randomUUID as randomUUID17 } from "crypto";
 
 // src/orchestration/meta-orchestrator.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function createAuditLogSink(logger57) {
   return {
     record(record) {
@@ -45266,7 +45356,7 @@ function createMetaOrchestrator(options) {
       const classification = classifyTask(input.goal);
       const forced = input.forceStrategy !== void 0;
       const base = input.forceStrategy !== void 0 ? buildForcedDecision(input.forceStrategy, routing, classification) : buildSelectedDecision(routing, classification);
-      const decision = { ...base, decisionId: randomUUID11() };
+      const decision = { ...base, decisionId: randomUUID14() };
       const timestamp = new Date(getTimeProvider().now()).toISOString();
       sink.record(toRecord(decision, input.goal, forced, timestamp));
       if (shadowSelector !== void 0 && shadowSink !== void 0) {
@@ -45561,7 +45651,7 @@ function createMetaDispatcher(options) {
 import { z as z101 } from "zod";
 import * as fs11 from "fs";
 import * as path10 from "path";
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 
 // src/pipeline/task-tracker.ts
 import * as fs10 from "fs";
@@ -45883,7 +45973,7 @@ function dispatchAsyncDevPipeline(input, taskText, stages, pipelineOptions, logg
     return runAsJob({
       toolName: "run_dev_pipeline",
       input,
-      freshJobId: () => `dp-${randomUUID12()}`,
+      freshJobId: () => `dp-${randomUUID15()}`,
       run,
       logger: logger57
     });
@@ -45934,7 +46024,7 @@ function registerDevPipelineTool(server, deps) {
 import { z as z102 } from "zod";
 import * as fs12 from "fs";
 import * as path11 from "path";
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 var PIPELINE_ASYNC_HINT = "A full run_pipeline run can exceed the synchronous MCP request timeout. Retry with `dispatch: 'async'` to get a jobId immediately, then poll get_job_result({ jobId }) for the result.";
 var PipelineInputSchema = z102.object({
   /** The task to execute. */
@@ -46083,7 +46173,7 @@ async function runPipelineHandler(args, logger57) {
       return runAsJob({
         toolName: "run_pipeline",
         input,
-        freshJobId: () => `rp-${randomUUID13()}`,
+        freshJobId: () => `rp-${randomUUID16()}`,
         run: () => executePipelineBody(task, stages, input.template, input.dryRun),
         logger: logger57
       });
@@ -46147,6 +46237,17 @@ var RunInputSchema = z103.object({
   isNovel: z103.boolean().optional().describe("Hint: this kind of task has not been seen before."),
   execute: z103.boolean().optional().describe(
     "When true, actually run the selected strategy (if an executor is wired) and return its result; otherwise return the routing decision only (default false, read-only)."
+  ),
+  /**
+   * Dispatch mode (#3732). Only meaningful with `execute: true` — `run`
+   * dispatches the heaviest engines (dev-pipeline/pipeline), which can exceed
+   * the MCP request timeout even with the 1800s class guard (#3734). `sync`
+   * (default) runs inline; `async` returns a `{ status: 'pending', jobId }`
+   * envelope immediately and runs in the background; poll
+   * `get_job_result({ jobId })`. Ignored for read-only routing (execute:false).
+   */
+  dispatch: z103.enum(["sync", "async"]).optional().describe(
+    "Dispatch mode (#3732). 'sync' (default): run inline. 'async' (only with execute:true): return a jobId immediately + run in background (poll get_job_result)."
   )
 });
 var NOTE = "Routing decision only (read-only). Invoke the recommendedTool to execute, or wait for inline execution (run execute: true) in a later release. The other pipeline tools remain available as advanced force-strategy paths.";
@@ -46229,6 +46330,26 @@ async function executeGoal(input, opts = {}) {
     result: dispatch.result
   };
 }
+async function executeRunBody(input, logger57, trustTier) {
+  try {
+    const exec2 = await executeGoal(input, {
+      logger: logger57,
+      ...trustTier !== void 0 ? { trustTier } : {}
+    });
+    logger57.info("run: executed goal", {
+      decisionId: exec2.decisionId,
+      strategy: exec2.strategy,
+      durationMs: exec2.durationMs
+    });
+    return toolSuccess(JSON.stringify(exec2, null, 2));
+  } catch (err2) {
+    const noExecutor = err2 instanceof MetaDispatchError && err2.code === "no_executor";
+    return toolStructuredError({
+      errorCategory: noExecutor ? "business" : "internal",
+      message: err2 instanceof Error ? err2.message : String(err2)
+    });
+  }
+}
 async function runHandler(args, logger57, trustTier) {
   const parsed = RunInputSchema.safeParse(args);
   if (!parsed.success) {
@@ -46238,24 +46359,17 @@ async function runHandler(args, logger57, trustTier) {
     });
   }
   if (parsed.data.execute === true) {
-    try {
-      const exec2 = await executeGoal(parsed.data, {
-        logger: logger57,
-        ...trustTier !== void 0 ? { trustTier } : {}
-      });
-      logger57.info("run: executed goal", {
-        decisionId: exec2.decisionId,
-        strategy: exec2.strategy,
-        durationMs: exec2.durationMs
-      });
-      return toolSuccess(JSON.stringify(exec2, null, 2));
-    } catch (err2) {
-      const noExecutor = err2 instanceof MetaDispatchError && err2.code === "no_executor";
-      return toolStructuredError({
-        errorCategory: noExecutor ? "business" : "internal",
-        message: err2 instanceof Error ? err2.message : String(err2)
+    const input = parsed.data;
+    if (input.dispatch === "async") {
+      return runAsJob({
+        toolName: "run",
+        input,
+        freshJobId: () => `rn-${randomUUID17()}`,
+        run: () => executeRunBody(input, logger57, trustTier),
+        logger: logger57
       });
     }
+    return executeRunBody(input, logger57, trustTier);
   }
   const response = routeGoal(parsed.data, logger57);
   logger57.info("run: routed goal", {
@@ -46387,6 +46501,7 @@ function registerListAvailableModelsTool(server, deps) {
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
 import { z as z105 } from "zod";
+import { randomUUID as randomUUID18 } from "crypto";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46396,6 +46511,7 @@ var MAX_AXES = 6;
 var MAX_AXIS_NAME_LENGTH = 64;
 var MAX_PROPOSAL_LENGTH = 4e3;
 var MAX_CONTEXT_LENGTH = 4e3;
+var TRADEOFF_PANEL_ASYNC_HINT = "A supply_chain_tradeoff_panel run fans out to up to 7 live LLM voters and can exceed the synchronous MCP request timeout. Retry with `dispatch: 'async'` to get a jobId immediately, then poll get_job_result({ jobId }) for the result.";
 var FULL_PANEL = [
   "architect",
   "security",
@@ -46415,7 +46531,17 @@ var SupplyChainTradeoffPanelInputSchema = z105.object({
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
   quickMode: z105.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
-  simulate: z105.boolean().optional().default(false).describe("Use simulated voters (testing only)")
+  simulate: z105.boolean().optional().default(false).describe("Use simulated voters (testing only)"),
+  /**
+   * Dispatch mode (#3731). `sync` (default) runs the panel inline and returns
+   * the result — but a live fan-out (up to 7 voters) can exceed the MCP request
+   * timeout. `async` returns a `{ status: 'pending', jobId }` envelope
+   * immediately and runs the panel in the background; poll
+   * `get_job_result({ jobId })` for the result.
+   */
+  dispatch: z105.enum(["sync", "async"]).default("sync").describe(
+    "Dispatch mode (#3731). 'sync' (default): run inline. 'async': return a jobId immediately + run the panel in background (poll get_job_result)."
+  )
 });
 function buildTradeoffProposal(input) {
   const axes = input.axes ?? DEFAULT_AXES;
@@ -46593,6 +46719,34 @@ function toPanelVote(result, axes) {
     ...result.error !== void 0 && { errorMessage: result.error }
   };
 }
+async function executeTradeoffPanelBody(input, logger57) {
+  const axes = input.axes ?? DEFAULT_AXES;
+  const roles = input.quickMode ? QUICK_PANEL : FULL_PANEL;
+  const start = Date.now();
+  const proposal = buildTradeoffProposal(input);
+  const voteResults = await collectRealVotes({
+    roles,
+    proposal,
+    simulate: input.simulate,
+    logger: logger57
+  });
+  const votes = voteResults.map((r) => toPanelVote(r, axes));
+  const axisVerdicts = axes.map((a) => aggregateAxis(a, votes));
+  const decision = aggregatePanel(axisVerdicts);
+  const recommendation = buildRecommendation(decision, axisVerdicts);
+  const voterErrors = votes.filter((v) => v.source === "error").length;
+  const response = {
+    proposal: input.proposal,
+    axes,
+    decision,
+    axisVerdicts,
+    recommendation,
+    votes,
+    voterErrors,
+    durationMs: Date.now() - start
+  };
+  return toolSuccess(JSON.stringify(response, null, 2));
+}
 async function tradeoffPanelHandler(args, ctx) {
   const parsed = SupplyChainTradeoffPanelInputSchema.safeParse(args);
   if (!parsed.success) {
@@ -46602,37 +46756,21 @@ async function tradeoffPanelHandler(args, ctx) {
     });
   }
   const input = parsed.data;
-  const axes = input.axes ?? DEFAULT_AXES;
-  const roles = input.quickMode ? QUICK_PANEL : FULL_PANEL;
-  const start = Date.now();
   try {
-    const proposal = buildTradeoffProposal(input);
-    const voteResults = await collectRealVotes({
-      roles,
-      proposal,
-      simulate: input.simulate,
-      logger: ctx.logger
-    });
-    const votes = voteResults.map((r) => toPanelVote(r, axes));
-    const axisVerdicts = axes.map((a) => aggregateAxis(a, votes));
-    const decision = aggregatePanel(axisVerdicts);
-    const recommendation = buildRecommendation(decision, axisVerdicts);
-    const voterErrors = votes.filter((v) => v.source === "error").length;
-    const response = {
-      proposal: input.proposal,
-      axes,
-      decision,
-      axisVerdicts,
-      recommendation,
-      votes,
-      voterErrors,
-      durationMs: Date.now() - start
-    };
-    return toolSuccess(JSON.stringify(response, null, 2));
+    if (input.dispatch === "async") {
+      return runAsJob({
+        toolName: "supply_chain_tradeoff_panel",
+        input,
+        freshJobId: () => `sc-${randomUUID18()}`,
+        run: () => executeTradeoffPanelBody(input, ctx.logger),
+        logger: ctx.logger
+      });
+    }
+    return await executeTradeoffPanelBody(input, ctx.logger);
   } catch (error) {
     return toolStructuredError({
       errorCategory: "internal",
-      message: `Tradeoff panel failed: ${getErrorMessage(error)}`
+      message: `${TRADEOFF_PANEL_ASYNC_HINT} Tradeoff panel failed: ${getErrorMessage(error)}`
     });
   }
 }
@@ -48179,7 +48317,7 @@ var FeedbackCollectorConfigSchema = z112.object({
 });
 
 // src/learning/outcome-feedback-helpers.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 function countOutcomesByClass(outcomes) {
   const counts = {
     success: 0,
@@ -48232,7 +48370,7 @@ function generateRewardExplanation(outcome, reward) {
 }
 function createRoutingDecision(params) {
   return {
-    id: randomUUID14(),
+    id: randomUUID19(),
     timestamp: getTimeProvider().nowIso(),
     ...params
   };
@@ -48488,7 +48626,7 @@ var DEFAULT_FEEDBACK_INTEGRATION_CONFIG = {
 };
 
 // src/learning/feedback-integration.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 var STEP_QUALITY_SCORING = {
   /** Base score for successful steps. */
   successBase: 0.8,
@@ -48564,8 +48702,8 @@ var FeedbackIntegration = class {
     });
   }
   recordRoutingDecision(decision, traceId) {
-    const id = randomUUID15();
-    const trace = traceId ?? randomUUID15();
+    const id = randomUUID20();
+    const trace = traceId ?? randomUUID20();
     const now = getTimeProvider().now();
     this.evictStaleEntriesThrottled(now);
     if (this.decisionMap.size >= MAX_DECISION_MAP_SIZE) {
@@ -48639,7 +48777,7 @@ var FeedbackIntegration = class {
     } = params;
     const outcomeClass = this.determineOutcomeClass(success, qualityScore);
     const completionRatio = success ? 1 : qualityScore / this.config.successQualityThreshold;
-    const trace = traceId ?? randomUUID15();
+    const trace = traceId ?? randomUUID20();
     const outcome = {
       routingDecisionId,
       timestamp: getTimeProvider().nowIso(),
@@ -50322,4 +50460,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-SOGHVI6W.js.map
+//# sourceMappingURL=chunk-2SIYUWT2.js.map