nexus-agents 4.1.4 → 4.2.1

package/dist/{chunk-CKOUOEK2.js → chunk-AY6EN765.js}

@@ -22,7 +22,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-GSUC22YA.js";
+} from "./chunk-U53YMCSE.js";
 import {
   executeExpert
 } from "./chunk-4Z2Z52C7.js";
@@ -46,7 +46,7 @@ import {
   simulationDeniedResult,
   toJobSummary,
   writeJobCancelled
-} from "./chunk-QJKXF2MY.js";
+} from "./chunk-PAGVGHWL.js";
 import {
   allOf
 } from "./chunk-OQB3XC5O.js";
@@ -63,7 +63,7 @@ import {
 } from "./chunk-5HPJB35V.js";
 import {
   withPrerequisite
-} from "./chunk-WXCRNJNO.js";
+} from "./chunk-CIQJIBGF.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -87,7 +87,7 @@ import {
   withAuditTrail,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-VOLQTAV4.js";
+} from "./chunk-5DED5UHM.js";
 import {
   createAuditTrail,
   createGraphAuditBridge,
@@ -45931,7 +45931,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-U3OPVEUE.js");
+        const { executeVoting } = await import("./consensus-vote-ULN3XOCN.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -48663,102 +48663,101 @@ function registerSuggestResearchTasksTool(server, deps) {
 import { z as z107 } from "zod";
 import { randomUUID as randomUUID17 } from "crypto";
 
-// src/orchestration/meta-orchestrator.ts
-import { randomUUID as randomUUID14 } from "crypto";
-
-// src/orchestration/meta-orchestrator-routing.ts
-function reasoningFor(selection, routing) {
-  const { manifest, rule } = selection;
-  const cause = rule.pipelineTypes !== void 0 && rule.patterns === void 0 ? `pipeline template "${rule.pipelineTypes.join("/")}"` : rule.pipelineTypes !== void 0 ? `pipeline template "${rule.pipelineTypes.join("/")}" under pattern "${routing.pattern}"` : `pattern "${routing.pattern}"`;
-  return `${cause} \u2192 ${manifest.strategy} (manifest ${manifest.id}; ${routing.reasoning})`;
-}
-function decideStrategy(routing, classification) {
-  const { pattern, analysis } = routing;
-  const { pipelineType } = classification;
-  const selection = selectStrategyByManifest({
-    pattern,
-    pipelineType,
-    complexity: analysis.complexity
-  });
-  if (selection === void 0) {
-    const fallback = "orchestrate";
-    return {
-      strategy: fallback,
-      reasoning: `No manifest rule matched pattern "${pattern}" \u2014 structural fallback to ${fallback}`,
-      confidence: routing.confidence,
-      manifestId: fallback,
-      manifestSchemaVersion: 0
-    };
+// src/orchestration/meta-dispatcher.ts
+var MetaDispatchError = class extends Error {
+  code;
+  strategy;
+  decisionId;
+  constructor(code, strategy, decisionId, message, options) {
+    super(message, options);
+    this.name = "MetaDispatchError";
+    this.code = code;
+    this.strategy = strategy;
+    this.decisionId = decisionId;
   }
-  const fromTemplate = selection.rule.pipelineTypes !== void 0;
+};
+function createAuditLogOutcomeSink(logger59) {
   return {
-    strategy: selection.strategy,
-    reasoning: reasoningFor(selection, routing),
-    confidence: fromTemplate ? classification.confidence : routing.confidence,
-    manifestId: selection.manifest.id,
-    manifestSchemaVersion: selection.manifest.schemaVersion
+    recordOutcome(record) {
+      logger59.info("MetaDispatcher execution outcome", { ...record });
+    }
   };
 }
-function buildAlternatives(chosen, routing, classification) {
-  const ranked = rankStrategiesByManifest({
-    pattern: routing.pattern,
-    pipelineType: classification.pipelineType,
-    complexity: routing.analysis.complexity
-  });
-  return ranked.filter((s) => s !== chosen);
+function errorMessage(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
 }
-
-// src/orchestration/meta-orchestrator-decision.ts
-function subSignals(routing, classification) {
-  return {
-    pattern: routing.pattern,
-    pipelineType: classification.pipelineType,
-    analysis: routing.analysis,
-    ...routing.capabilityGaps !== void 0 ? { capabilityGaps: routing.capabilityGaps } : {}
+function recordOutcome2(deps, decision, start, success, failureReason) {
+  const record = {
+    decisionId: decision.decisionId,
+    timestamp: new Date(getTimeProvider().now()).toISOString(),
+    strategy: decision.strategy,
+    success,
+    durationMs: Math.max(0, getTimeProvider().now() - start),
+    ...failureReason !== void 0 ? { failureReason } : {}
   };
+  deps.outcomeSink.recordOutcome(record);
+  if (deps.onOutcome !== void 0) {
+    try {
+      deps.onOutcome(record, decision);
+    } catch (err2) {
+      deps.logger.warn("MetaDispatcher onOutcome observer threw (ignored)", {
+        decisionId: decision.decisionId,
+        error: errorMessage(err2)
+      });
+    }
+  }
 }
-function buildForcedDecision(forced, routing, classification) {
-  const manifest = getStrategyManifest(forced);
-  return {
-    strategy: forced,
-    reasoning: `Strategy forced by caller: ${forced} (entrypoint ${entrypointToolFor(forced)})`,
-    confidence: 1,
-    alternatives: buildAlternatives(forced, routing, classification),
-    needsShaping: false,
-    manifestId: manifest?.id ?? forced,
-    manifestSchemaVersion: manifest?.schemaVersion ?? 0,
-    ...subSignals(routing, classification)
-  };
+async function dispatchDecision(decision, input, deps) {
+  const { strategy, decisionId } = decision;
+  const start = getTimeProvider().now();
+  const executor = deps.executors[strategy];
+  if (executor === void 0) {
+    const reason = `No executor registered for strategy "${strategy}"`;
+    recordOutcome2(deps, decision, start, false, reason);
+    deps.logger.error("MetaDispatcher dispatch failed", void 0, {
+      decisionId,
+      strategy,
+      reason
+    });
+    throw new MetaDispatchError("no_executor", strategy, decisionId, reason);
+  }
+  try {
+    const result = await executor(decision, input);
+    recordOutcome2(deps, decision, start, true);
+    return {
+      decisionId,
+      strategy,
+      durationMs: Math.max(0, getTimeProvider().now() - start),
+      result
+    };
+  } catch (err2) {
+    const reason = errorMessage(err2);
+    recordOutcome2(deps, decision, start, false, reason);
+    deps.logger.error(
+      "MetaDispatcher strategy executor threw",
+      err2 instanceof Error ? err2 : void 0,
+      {
+        decisionId,
+        strategy,
+        reason
+      }
+    );
+    throw new MetaDispatchError("executor_failed", strategy, decisionId, reason, { cause: err2 });
+  }
 }
-function buildSelectedDecision(routing, classification) {
-  const core = decideStrategy(routing, classification);
-  const needsShaping = routing.needsClarification === true;
-  return {
-    strategy: core.strategy,
-    reasoning: core.reasoning,
-    confidence: core.confidence,
-    alternatives: buildAlternatives(core.strategy, routing, classification),
-    needsShaping,
-    manifestId: core.manifestId,
-    manifestSchemaVersion: core.manifestSchemaVersion,
-    ...needsShaping && routing.suggestedQuestions !== void 0 ? { shapingQuestions: routing.suggestedQuestions } : {},
-    ...subSignals(routing, classification)
+function createMetaDispatcher(options) {
+  const logger59 = options.logger ?? createLogger({ component: "MetaDispatcher" });
+  const outcomeSink = options.outcomeSink ?? createAuditLogOutcomeSink(logger59);
+  const deps = {
+    executors: options.executors,
+    outcomeSink,
+    logger: logger59,
+    onOutcome: options.onOutcome
   };
-}
-function toRecord(decision, goal, forced, timestamp) {
   return {
-    decisionId: decision.decisionId,
-    timestamp,
-    goal,
-    strategy: decision.strategy,
-    confidence: decision.confidence,
-    pattern: decision.pattern,
-    pipelineType: decision.pipelineType,
-    alternatives: decision.alternatives,
-    needsShaping: decision.needsShaping,
-    forced,
-    manifestId: decision.manifestId,
-    manifestSchemaVersion: decision.manifestSchemaVersion
+    dispatch(decision, input) {
+      return dispatchDecision(decision, input, deps);
+    }
   };
 }
 
@@ -48855,6 +48854,129 @@ function guardExecuteEnvelope(strategy) {
   return decision.envelope;
 }
 
+// src/mcp/tools/run-tool-dry-run.ts
+var DRY_RUN_CAPABLE = "dev-pipeline";
+var DryRunUnsupportedError = class extends Error {
+  constructor(strategy) {
+    super(
+      `dryRun is not supported by the '${strategy}' strategy \u2014 only '${DRY_RUN_CAPABLE}' stops after plan+vote. Refusing rather than running for real. Re-run without dryRun, or force the ${DRY_RUN_CAPABLE} strategy.`
+    );
+    this.strategy = strategy;
+    this.name = "DryRunUnsupportedError";
+  }
+  strategy;
+};
+function assertDryRunSupported(dryRun, strategy) {
+  if (dryRun === true && strategy !== DRY_RUN_CAPABLE) {
+    throw new DryRunUnsupportedError(strategy);
+  }
+}
+function classifyDispatchError(err2) {
+  const noExecutor = err2 instanceof MetaDispatchError && err2.code === "no_executor";
+  const refused = err2 instanceof AuthorityRefusalError;
+  const dryRunUnsupported = err2 instanceof DryRunUnsupportedError;
+  return noExecutor || refused || dryRunUnsupported ? "business" : "internal";
+}
+
+// src/orchestration/meta-orchestrator.ts
+import { randomUUID as randomUUID14 } from "crypto";
+
+// src/orchestration/meta-orchestrator-routing.ts
+function reasoningFor(selection, routing) {
+  const { manifest, rule } = selection;
+  const cause = rule.pipelineTypes !== void 0 && rule.patterns === void 0 ? `pipeline template "${rule.pipelineTypes.join("/")}"` : rule.pipelineTypes !== void 0 ? `pipeline template "${rule.pipelineTypes.join("/")}" under pattern "${routing.pattern}"` : `pattern "${routing.pattern}"`;
+  return `${cause} \u2192 ${manifest.strategy} (manifest ${manifest.id}; ${routing.reasoning})`;
+}
+function decideStrategy(routing, classification) {
+  const { pattern, analysis } = routing;
+  const { pipelineType } = classification;
+  const selection = selectStrategyByManifest({
+    pattern,
+    pipelineType,
+    complexity: analysis.complexity
+  });
+  if (selection === void 0) {
+    const fallback = "orchestrate";
+    return {
+      strategy: fallback,
+      reasoning: `No manifest rule matched pattern "${pattern}" \u2014 structural fallback to ${fallback}`,
+      confidence: routing.confidence,
+      manifestId: fallback,
+      manifestSchemaVersion: 0
+    };
+  }
+  const fromTemplate = selection.rule.pipelineTypes !== void 0;
+  return {
+    strategy: selection.strategy,
+    reasoning: reasoningFor(selection, routing),
+    confidence: fromTemplate ? classification.confidence : routing.confidence,
+    manifestId: selection.manifest.id,
+    manifestSchemaVersion: selection.manifest.schemaVersion
+  };
+}
+function buildAlternatives(chosen, routing, classification) {
+  const ranked = rankStrategiesByManifest({
+    pattern: routing.pattern,
+    pipelineType: classification.pipelineType,
+    complexity: routing.analysis.complexity
+  });
+  return ranked.filter((s) => s !== chosen);
+}
+
+// src/orchestration/meta-orchestrator-decision.ts
+function subSignals(routing, classification) {
+  return {
+    pattern: routing.pattern,
+    pipelineType: classification.pipelineType,
+    analysis: routing.analysis,
+    ...routing.capabilityGaps !== void 0 ? { capabilityGaps: routing.capabilityGaps } : {}
+  };
+}
+function buildForcedDecision(forced, routing, classification) {
+  const manifest = getStrategyManifest(forced);
+  return {
+    strategy: forced,
+    reasoning: `Strategy forced by caller: ${forced} (entrypoint ${entrypointToolFor(forced)})`,
+    confidence: 1,
+    alternatives: buildAlternatives(forced, routing, classification),
+    needsShaping: false,
+    manifestId: manifest?.id ?? forced,
+    manifestSchemaVersion: manifest?.schemaVersion ?? 0,
+    ...subSignals(routing, classification)
+  };
+}
+function buildSelectedDecision(routing, classification) {
+  const core = decideStrategy(routing, classification);
+  const needsShaping = routing.needsClarification === true;
+  return {
+    strategy: core.strategy,
+    reasoning: core.reasoning,
+    confidence: core.confidence,
+    alternatives: buildAlternatives(core.strategy, routing, classification),
+    needsShaping,
+    manifestId: core.manifestId,
+    manifestSchemaVersion: core.manifestSchemaVersion,
+    ...needsShaping && routing.suggestedQuestions !== void 0 ? { shapingQuestions: routing.suggestedQuestions } : {},
+    ...subSignals(routing, classification)
+  };
+}
+function toRecord(decision, goal, forced, timestamp) {
+  return {
+    decisionId: decision.decisionId,
+    timestamp,
+    goal,
+    strategy: decision.strategy,
+    confidence: decision.confidence,
+    pattern: decision.pattern,
+    pipelineType: decision.pipelineType,
+    alternatives: decision.alternatives,
+    needsShaping: decision.needsShaping,
+    forced,
+    manifestId: decision.manifestId,
+    manifestSchemaVersion: decision.manifestSchemaVersion
+  };
+}
+
 // src/orchestration/meta-orchestrator.ts
 function createAuditLogSink(logger59) {
   return {
@@ -49417,104 +49539,6 @@ function evaluateMetaStrategyReadiness(result, config = DEFAULT_META_STRATEGY_RE
   return { ready: blockers.length === 0, criteria, blockers };
 }
 
-// src/orchestration/meta-dispatcher.ts
-var MetaDispatchError = class extends Error {
-  code;
-  strategy;
-  decisionId;
-  constructor(code, strategy, decisionId, message, options) {
-    super(message, options);
-    this.name = "MetaDispatchError";
-    this.code = code;
-    this.strategy = strategy;
-    this.decisionId = decisionId;
-  }
-};
-function createAuditLogOutcomeSink(logger59) {
-  return {
-    recordOutcome(record) {
-      logger59.info("MetaDispatcher execution outcome", { ...record });
-    }
-  };
-}
-function errorMessage(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
-}
-function recordOutcome2(deps, decision, start, success, failureReason) {
-  const record = {
-    decisionId: decision.decisionId,
-    timestamp: new Date(getTimeProvider().now()).toISOString(),
-    strategy: decision.strategy,
-    success,
-    durationMs: Math.max(0, getTimeProvider().now() - start),
-    ...failureReason !== void 0 ? { failureReason } : {}
-  };
-  deps.outcomeSink.recordOutcome(record);
-  if (deps.onOutcome !== void 0) {
-    try {
-      deps.onOutcome(record, decision);
-    } catch (err2) {
-      deps.logger.warn("MetaDispatcher onOutcome observer threw (ignored)", {
-        decisionId: decision.decisionId,
-        error: errorMessage(err2)
-      });
-    }
-  }
-}
-async function dispatchDecision(decision, input, deps) {
-  const { strategy, decisionId } = decision;
-  const start = getTimeProvider().now();
-  const executor = deps.executors[strategy];
-  if (executor === void 0) {
-    const reason = `No executor registered for strategy "${strategy}"`;
-    recordOutcome2(deps, decision, start, false, reason);
-    deps.logger.error("MetaDispatcher dispatch failed", void 0, {
-      decisionId,
-      strategy,
-      reason
-    });
-    throw new MetaDispatchError("no_executor", strategy, decisionId, reason);
-  }
-  try {
-    const result = await executor(decision, input);
-    recordOutcome2(deps, decision, start, true);
-    return {
-      decisionId,
-      strategy,
-      durationMs: Math.max(0, getTimeProvider().now() - start),
-      result
-    };
-  } catch (err2) {
-    const reason = errorMessage(err2);
-    recordOutcome2(deps, decision, start, false, reason);
-    deps.logger.error(
-      "MetaDispatcher strategy executor threw",
-      err2 instanceof Error ? err2 : void 0,
-      {
-        decisionId,
-        strategy,
-        reason
-      }
-    );
-    throw new MetaDispatchError("executor_failed", strategy, decisionId, reason, { cause: err2 });
-  }
-}
-function createMetaDispatcher(options) {
-  const logger59 = options.logger ?? createLogger({ component: "MetaDispatcher" });
-  const outcomeSink = options.outcomeSink ?? createAuditLogOutcomeSink(logger59);
-  const deps = {
-    executors: options.executors,
-    outcomeSink,
-    logger: logger59,
-    onOutcome: options.onOutcome
-  };
-  return {
-    dispatch(decision, input) {
-      return dispatchDecision(decision, input, deps);
-    }
-  };
-}
-
 // src/mcp/tools/dev-pipeline-tool.ts
 import { z as z105 } from "zod";
 import * as fs11 from "fs";
@@ -49770,8 +49794,11 @@ async function createStages(input, trustTier) {
     }
   });
 }
-async function runDevPipelineForGoal(goal, trustTier) {
-  const input = DevPipelineInputSchema.parse({ task: goal });
+async function runDevPipelineForGoal(goal, trustTier, dryRun) {
+  const input = DevPipelineInputSchema.parse({
+    task: goal,
+    ...dryRun !== void 0 ? { dryRun } : {}
+  });
   const stages = await createStages(input, trustTier);
   return runDevPipeline(goal, stages, trustTier !== void 0 ? { trustTier } : void 0);
 }
@@ -50131,6 +50158,21 @@ var RunInputSchema = z107.object({
   execute: z107.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)."
   ),
+  /**
+   * Plan and vote without implementing (#4806).
+   *
+   * `run` is the documented default entry point, but until now it could not
+   * express the cautious caller's first request — "show me the plan, don't
+   * build it". `execute: false` is not a substitute: that returns the SELECTED
+   * STRATEGY, having done no planning and no voting.
+   *
+   * Only the dev-pipeline strategy can honour it. When the router selects any
+   * other, the call is REFUSED rather than executed: silently ignoring a
+   * do-not-act flag is the one outcome a governance substrate cannot allow.
+   */
+  dryRun: z107.boolean().optional().describe(
+    "Plan and vote only, no implementation (#4806). Requires the dev-pipeline strategy \u2014 refused (never silently executed) when the router selects another."
+  ),
   /**
    * Dispatch mode (#3732). Only meaningful with `execute: true` — `run`
    * dispatches the heaviest engines (dev-pipeline/pipeline), which can exceed
@@ -50203,9 +50245,9 @@ function routeGoal(input, logger59) {
     note: NOTE
   };
 }
-function buildDefaultExecutors(trustTier, gatewayAdapters) {
+function buildDefaultExecutors(trustTier, gatewayAdapters, dryRun) {
   return {
-    "dev-pipeline": (_decision, metaInput) => runDevPipelineForGoal(metaInput.goal, trustTier),
+    "dev-pipeline": (_decision, metaInput) => runDevPipelineForGoal(metaInput.goal, trustTier, dryRun),
     pipeline: (_decision, metaInput) => runPipelineForGoal(metaInput.goal),
     // #3988: `research` deliberately ALIASES the `pipeline` engine — it runs the
     // SAME generic stage registry (selectStageRegistry only branches greenfield/
@@ -50238,9 +50280,10 @@ function buildShadowTrainObserver(logger59) {
 }
 async function executeGoal(input, opts = {}) {
   const decision = selectDecision(input, "execute", opts.logger);
+  assertDryRunSupported(input.dryRun, decision.strategy);
   const onOutcome = opts.onOutcome ?? buildShadowTrainObserver(opts.logger);
   const dispatcher = createMetaDispatcher({
-    executors: opts.executors ?? buildDefaultExecutors(opts.trustTier, opts.gatewayAdapters),
+    executors: opts.executors ?? buildDefaultExecutors(opts.trustTier, opts.gatewayAdapters, input.dryRun),
     ...opts.logger !== void 0 ? { logger: opts.logger } : {},
     ...opts.outcomeSink !== void 0 ? { outcomeSink: opts.outcomeSink } : {},
     ...onOutcome !== void 0 ? { onOutcome } : {}
@@ -50306,10 +50349,8 @@ async function executeRunBody(input, logger59, trustTier, gatewayAdapters) {
     }
     return toolSuccess(JSON.stringify(exec2, null, 2));
   } catch (err2) {
-    const noExecutor = err2 instanceof MetaDispatchError && err2.code === "no_executor";
-    const refused = err2 instanceof AuthorityRefusalError;
     return toolStructuredError({
-      errorCategory: noExecutor || refused ? "business" : "internal",
+      errorCategory: classifyDispatchError(err2),
       message: err2 instanceof Error ? err2.message : String(err2)
     });
   }
@@ -54456,4 +54497,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-CKOUOEK2.js.map
+//# sourceMappingURL=chunk-AY6EN765.js.map