nexus-agents 2.125.37 → 2.125.38

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

@@ -30,7 +30,7 @@ import {
   runConsensusForGoal,
   warnIfSimulatedOutsideTests,
   writeJobCancelled
-} from "./chunk-QASYDORV.js";
+} from "./chunk-PRFSN66J.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
@@ -122,7 +122,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-L7R6DLF3.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
+      workflow: input.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
-    });
-    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(
@@ -39551,7 +39606,13 @@ var TOOL_NAME_BY_PREFIX = {
   // #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"
+  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("-");
@@ -43062,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-ZC25LNEC.js");
+        const { executeVoting } = await import("./consensus-vote-CSKEO3LA.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -43605,7 +43666,7 @@ function createAuditStageRegistry() {
 
 // src/mcp/tools/pr-review-tool.ts
 import { z as z90 } from "zod";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 
 // src/mcp/tools/pr-review-findings.ts
 import { parse as parseYaml2 } from "yaml";
@@ -43857,7 +43918,7 @@ async function prReviewHandler(args, ctx) {
       return runAsJob({
         toolName: "pr_review",
         input,
-        freshJobId: () => `pr-${randomUUID11()}`,
+        freshJobId: () => `pr-${randomUUID13()}`,
         run: () => executePrReviewBody(input, ctx.logger),
         logger: ctx.logger
       });
@@ -45119,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 randomUUID12 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function createAuditLogSink(logger57) {
   return {
     record(record) {
@@ -45294,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: randomUUID12() };
+      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) {
@@ -45589,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 randomUUID13 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 
 // src/pipeline/task-tracker.ts
 import * as fs10 from "fs";
@@ -45911,7 +45973,7 @@ function dispatchAsyncDevPipeline(input, taskText, stages, pipelineOptions, logg
     return runAsJob({
       toolName: "run_dev_pipeline",
       input,
-      freshJobId: () => `dp-${randomUUID13()}`,
+      freshJobId: () => `dp-${randomUUID15()}`,
       run,
       logger: logger57
     });
@@ -45962,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 randomUUID14 } 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. */
@@ -46111,7 +46173,7 @@ async function runPipelineHandler(args, logger57) {
       return runAsJob({
         toolName: "run_pipeline",
         input,
-        freshJobId: () => `rp-${randomUUID14()}`,
+        freshJobId: () => `rp-${randomUUID16()}`,
         run: () => executePipelineBody(task, stages, input.template, input.dryRun),
         logger: logger57
       });
@@ -46175,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.";
@@ -46257,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) {
@@ -46266,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", {
@@ -46415,7 +46501,7 @@ function registerListAvailableModelsTool(server, deps) {
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
 import { z as z105 } from "zod";
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46675,7 +46761,7 @@ async function tradeoffPanelHandler(args, ctx) {
       return runAsJob({
         toolName: "supply_chain_tradeoff_panel",
         input,
-        freshJobId: () => `sc-${randomUUID15()}`,
+        freshJobId: () => `sc-${randomUUID18()}`,
         run: () => executeTradeoffPanelBody(input, ctx.logger),
         logger: ctx.logger
       });
@@ -48231,7 +48317,7 @@ var FeedbackCollectorConfigSchema = z112.object({
 });
 
 // src/learning/outcome-feedback-helpers.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 function countOutcomesByClass(outcomes) {
   const counts = {
     success: 0,
@@ -48284,7 +48370,7 @@ function generateRewardExplanation(outcome, reward) {
 }
 function createRoutingDecision(params) {
   return {
-    id: randomUUID16(),
+    id: randomUUID19(),
     timestamp: getTimeProvider().nowIso(),
     ...params
   };
@@ -48540,7 +48626,7 @@ var DEFAULT_FEEDBACK_INTEGRATION_CONFIG = {
 };
 
 // src/learning/feedback-integration.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 var STEP_QUALITY_SCORING = {
   /** Base score for successful steps. */
   successBase: 0.8,
@@ -48616,8 +48702,8 @@ var FeedbackIntegration = class {
     });
   }
   recordRoutingDecision(decision, traceId) {
-    const id = randomUUID17();
-    const trace = traceId ?? randomUUID17();
+    const id = randomUUID20();
+    const trace = traceId ?? randomUUID20();
     const now = getTimeProvider().now();
     this.evictStaleEntriesThrottled(now);
     if (this.decisionMap.size >= MAX_DECISION_MAP_SIZE) {
@@ -48691,7 +48777,7 @@ var FeedbackIntegration = class {
     } = params;
     const outcomeClass = this.determineOutcomeClass(success, qualityScore);
     const completionRatio = success ? 1 : qualityScore / this.config.successQualityThreshold;
-    const trace = traceId ?? randomUUID17();
+    const trace = traceId ?? randomUUID20();
     const outcome = {
       routingDecisionId,
       timestamp: getTimeProvider().nowIso(),
@@ -50374,4 +50460,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-V2CLCDW6.js.map
+//# sourceMappingURL=chunk-2SIYUWT2.js.map