nexus-agents 4.1.4 → 4.3.0

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

@@ -1,6 +1,6 @@
 import {
   generateSecurityPlan
-} from "./chunk-FD3I5B4X.js";
+} from "./chunk-FHXDRCIW.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-HFOQKCD2.js";
@@ -22,10 +22,10 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-GSUC22YA.js";
+} from "./chunk-D3BKW23W.js";
 import {
   executeExpert
-} from "./chunk-4Z2Z52C7.js";
+} from "./chunk-OYNZ6FCZ.js";
 import {
   JobStatusSchema,
   abortJob,
@@ -46,24 +46,24 @@ import {
   simulationDeniedResult,
   toJobSummary,
   writeJobCancelled
-} from "./chunk-QJKXF2MY.js";
+} from "./chunk-4WU3BGGK.js";
 import {
   allOf
 } from "./chunk-OQB3XC5O.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
-} from "./chunk-BMEJLPAE.js";
+} from "./chunk-A7DEF2I6.js";
 import {
   IssueTriage
-} from "./chunk-N7YLNXHT.js";
+} from "./chunk-H64DUJSZ.js";
 import {
   resolveEnvMode,
   sanitizeInput
-} from "./chunk-5HPJB35V.js";
+} from "./chunk-AQAGVYWS.js";
 import {
   withPrerequisite
-} from "./chunk-WXCRNJNO.js";
+} from "./chunk-MPEQHP4D.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -87,18 +87,18 @@ import {
   withAuditTrail,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-VOLQTAV4.js";
+} from "./chunk-WX5TASVN.js";
 import {
   createAuditTrail,
   createGraphAuditBridge,
   emitPipelinePolicyEvent
-} from "./chunk-ADIMVMAB.js";
+} from "./chunk-5GUP54YH.js";
 import {
   EventTopics,
   createEvent,
   getGlobalEventBus,
   getGlobalRegistry
-} from "./chunk-VKLMXCI2.js";
+} from "./chunk-B6JICUQ6.js";
 import {
   IDENTIFIER_RE,
   LANG_VALUES,
@@ -131,31 +131,31 @@ import {
   parseRegistry,
   sourceExistsInRegistry,
   summarizeContextForPrompt
-} from "./chunk-CNB4PA7Q.js";
+} from "./chunk-LGTY3B3Q.js";
 import {
   loadPapersRegistry,
   loadTechniquesRegistry
-} from "./chunk-UM376MEM.js";
+} from "./chunk-Y3WYSLFZ.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-3OM2W7H7.js";
+} from "./chunk-XABDFFQV.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
   calculateTextJaccardSimilarity,
   getToolMemory
-} from "./chunk-KVHA4AEF.js";
+} from "./chunk-2QYJ7IE2.js";
 import {
   STOPWORDS,
   truncateWithInfo
 } from "./chunk-6T3EPABN.js";
 import {
   createSessionMemory
-} from "./chunk-JRU5G6VW.js";
+} from "./chunk-3K3VGOY4.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -173,25 +173,25 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-AMEVOGE7.js";
+} from "./chunk-MPCBYY4J.js";
 import {
   BaseAdapter,
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-KLN7TJLT.js";
+} from "./chunk-MLR4PF64.js";
 import {
   DEFAULTS
-} from "./chunk-HNC2G7AS.js";
+} from "./chunk-DL5RN53R.js";
 import {
   getAvailabilityCache,
   getCliForModelId,
   resolveFallback
-} from "./chunk-S645LGB6.js";
+} from "./chunk-TKA6653I.js";
 import {
   generateHyphenId,
   generateUUID
-} from "./chunk-FRTNZUUF.js";
+} from "./chunk-CYCXJNPA.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -291,7 +291,7 @@ import {
   selectStrategyByManifest,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-TN7HF2SQ.js";
+} from "./chunk-TMYLHKLJ.js";
 import {
   ensureLearningDir,
   getMetaOutcomesFile,
@@ -28244,7 +28244,7 @@ function execIdFields(executionId) {
 async function populateUnifiedContextOnState(state, options) {
   const taskCandidate = state["task"];
   if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-  const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-SGJTQUCI.js");
+  const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-CIFLPUJA.js");
   const category = inferTaskCategory2(taskCandidate);
   const executionId = options?.executionId;
   const execFields = execIdFields(executionId);
@@ -43929,7 +43929,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-B3KU37U3.js");
+    const { createIssueTriage } = await import("./issue-triage-APE6L5YP.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -43957,7 +43957,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-UH44L5CN.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-B6ZTEZNH.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -45698,7 +45698,7 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-5GVHJR26.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-LYX5N2IP.js");
     const { getLearningDir } = await import("./learning-persistence-EGY4VKKO.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
@@ -45760,7 +45760,7 @@ function recordRoutingExperience(category, success, durationMs, tokensUsed = 0,
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-EIF5XALW.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-WU4C63BA.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -45794,7 +45794,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-FV6YYGT4.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-QLHSZQOT.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -45812,7 +45812,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-5GVHJR26.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-LYX5N2IP.js");
     const { getLearningDir } = await import("./learning-persistence-EGY4VKKO.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -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-ZRLZYJ4D.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -46370,7 +46370,7 @@ async function searchCodebaseForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-4YBZF2LZ.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-C4GK3GU4.js");
     const topic = task.split(/[.!?\n]/).filter((s) => s.trim().length > 10)[0]?.trim();
     if (topic === void 0) return null;
     const result = await synthesizeResearch2(topic.slice(0, 50));
@@ -46441,7 +46441,7 @@ function createScanStageWrapper() {
       try {
         const slug = ctx.task.match(/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+)/)?.[1];
         if (slug !== void 0) {
-          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-E2MTJPSC.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-C4ZSWVY7.js");
           const plan = await generateSecurityPlan2({ repo: slug, maxScanners: 10 });
           const recs = plan.recommendations.slice(0, 5).map((r) => `${r.priority}: ${r.displayName} (${r.category})`).join("; ");
           return output(PIPELINE_STATE_KEYS.FINDINGS, recs, getTimeProvider().now() - start, true);
@@ -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";
@@ -49540,7 +49564,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-HYFTOF35.js");
+    const { createScmProvider } = await import("./factory-RLGGFLYD.js");
     const result = await createScmProvider({ repo: this.config.repo ?? "" });
     if (!result.ok) throw new Error(`SCM provider error: ${result.error.message}`);
     this.cachedProvider = result.value;
@@ -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)
     });
   }
@@ -50414,7 +50455,7 @@ async function probeSource(source, includeModelIds) {
   }
 }
 async function defaultSources(includeOpenRouter) {
-  const { createAllAdapters: createAllAdapters2 } = await import("./factory-GUDAJED7.js");
+  const { createAllAdapters: createAllAdapters2 } = await import("./factory-5BEGXJVB.js");
   const adapters = createAllAdapters2();
   return buildDefaultModelSources(adapters, { includeOpenRouter });
 }
@@ -54456,4 +54497,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-CKOUOEK2.js.map
+//# sourceMappingURL=chunk-OHRCTQDC.js.map